Enum hocon::Hocon

pub enum Hocon {
    Real(f64),
    Integer(i64),
    String(String),
    Boolean(bool),
    Array(Vec<Hocon>),
    Hash(LinkedHashMap<String, Hocon>),
    Null,
    BadValue(Error),
}

An HOCON document

Values can be retrieved as a basic type, with basic cast between some of the value types: Automatic type conversions. If the value if not of the expected type, a None will be returned.

If the value is a Hocon::Hash, its values can be accessed by indexing with a str, as in hash[key]. If the value is an Hocon::Array, its values can be accessed by indexing with a usize. An Hocon::Hash whose keys can be converted to numeric values ("0", "1", …) can be indexed with a usize following the rules described in Conversion of numerically-indexed objects to arrays.

Indexing a Hocon value with a wrong key type, or a type of value that can’t be indexed will return a Hocon::BadValue with an error of type crate::Error::InvalidKey.

Indexing a Hocon value with a key that is not present will return a Hocon::BadValue with an error of type crate::Error::MissingKey.

Values can also be accessed as a Duration or a size following the rules described in Units format.

Usage

// Accessing a value of the expected type
assert_eq!(
    HoconLoader::new().load_str(r#"{ a: 7 }"#)?.hocon()?["a"].as_i64(),
    Some(7)
);

// Accessing a value with automatic conversion
assert_eq!(
    HoconLoader::new().load_str(r#"{ a: off }"#)?.hocon()?["a"].as_bool(),
    Some(false)
);

// Accessing an Array
assert_eq!(
    HoconLoader::new().load_str(r#"{ a: [ first, second ] }"#)?.hocon()?["a"][0].as_string(),
    Some(String::from("first"))
);

// Accessing an Hash with a missing key
assert_eq!(
    HoconLoader::new().load_str(r#"{ a: 7 }"#)?.hocon()?["b"],
    Hocon::BadValue(Error::MissingKey)
);

// Accessing an Hash as if it was an Array
assert_eq!(
    HoconLoader::new().load_str(r#"{ a: 7 }"#)?.hocon()?[0],
    Hocon::BadValue(Error::InvalidKey)
);

Variants

Real(f64)

A floating value

Tuple Fields of Real

0: f64

Integer(i64)

An integer value

Tuple Fields of Integer

0: i64

String(String)

A string

Tuple Fields of String

0: String

Boolean(bool)

A boolean

Tuple Fields of Boolean

0: bool

Array(Vec<Hocon>)

An array of Hocon values

Tuple Fields of Array

0: Vec<Hocon>

Hash(LinkedHashMap<String, Hocon>)

An HashMap of Hocon values with keys

Tuple Fields of Hash

0: LinkedHashMap<String, Hocon>

Null

A null value

BadValue(Error)

A BadValue, marking an error in parsing or a missing value

Tuple Fields of BadValue

0: Error

Implementations

impl Hocon

pub fn as_f64(&self) -> Option<f64>

Try to cast a value as a f64 value

pub fn as_i64(&self) -> Option<i64>

Try to cast a value as a i64 value

pub fn as_string(&self) -> Option<String>

Try to cast a value as a String value

pub fn as_bool(&self) -> Option<bool>

Try to cast a value as a bool value

impl Hocon

pub fn as_bytes(&self) -> Option<f64>

Try to return a value as a size in bytes according to size in bytes format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ size = 1.5KiB }"#)?.hocon()?["size"].as_bytes(),
    Some(1536.0)
);

pub fn as_milliseconds(&self) -> Option<f64>

Try to return a value as a duration in milliseconds according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_milliseconds(),
    Some(5400000.0)
);

pub fn as_nanoseconds(&self) -> Option<f64>

Try to return a value as a duration in nanoseconds according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_nanoseconds(),
    Some(5400000000000.0)
);

pub fn as_microseconds(&self) -> Option<f64>

Try to return a value as a duration in microseconds according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_microseconds(),
    Some(5400000000.0)
);

pub fn as_seconds(&self) -> Option<f64>

Try to return a value as a duration in seconds according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_seconds(),
    Some(5400.0)
);

pub fn as_minutes(&self) -> Option<f64>

Try to return a value as a duration in minutes according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_minutes(),
    Some(90.0)
);

pub fn as_hours(&self) -> Option<f64>

Try to return a value as a duration in hours according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_hours(),
    Some(1.5)
);

pub fn as_days(&self) -> Option<f64>

Try to return a value as a duration in days according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hour  }"#)?
        .hocon()?["duration"].as_days(),
    Some(0.0625)
);

pub fn as_weeks(&self) -> Option<f64>

Try to return a value as a duration in weeks according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 days  }"#)?
        .hocon()?["duration"].as_weeks(),
    Some(0.21428571428571427)
);

pub fn as_months(&self) -> Option<f64>

Try to return a value as a duration in months according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 days  }"#)?
        .hocon()?["duration"].as_months(),
    Some(0.05)
);

pub fn as_years(&self) -> Option<f64>

Try to return a value as a duration in years according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 days  }"#)?
        .hocon()?["duration"].as_years(),
    Some(0.00410958904109589)
);

pub fn as_duration(&self) -> Option<Duration>

Try to return a value as a duration according to duration format.

Bare numbers are taken to be in bytes already, while strings are parsed as a number plus an optional unit string.

Example

assert_eq!(
    HoconLoader::new().load_str(r#"{ duration = 1.5 hours  }"#)?
        .hocon()?["duration"].as_duration(),
    Some(std::time::Duration::from_secs(5400))
);

impl Hocon

pub fn resolve<'de, T>(self) -> Result<T, Error> where
    T: Deserialize<'de>, 

Deserialize the loaded documents to the target type

Errors

• Error::Deserialization if there was a serde error during deserialization (missing required field, type issue, …)

Additional errors in strict mode

• Error::Include if there was an issue with an included file
• Error::KeyNotFound if there is a substitution with a key that is not present in the document
• Error::DisabledExternalUrl if crate was built without feature url-support and an include url("...") was found

Trait Implementations

impl Clone for Hocon

fn clone(&self) -> Hocon

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Hocon

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Index<&'a str> for Hocon

type Output = Hocon

The returned type after indexing.

fn index(&self, idx: &'a str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<usize> for Hocon

type Output = Hocon

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl PartialEq<Hocon> for Hocon

fn eq(&self, other: &Hocon) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Hocon) -> bool

This method tests for !=.

impl StructuralPartialEq for Hocon