hocon 0.9.0

Reads HOCON configuration files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Wrapper for custom deserialization from Hocon

use std::{
    fmt,
    ops::{Deref, DerefMut},
    time::Duration,
};

use serde::{
    de::{self, Deserialize, Visitor},
    Deserializer,
};

use crate::Hocon;

/// Wrapper for custom deserialization from Hocon.
///
/// Implemented for [`Duration`]
///
/// ## As a newtype wrapper
///
/// ```rust
/// # use std::time::Duration;
/// # use hocon::de::wrappers::Serde;
/// # use serde::Deserialize;
/// #[derive(Deserialize, Debug)]
/// struct StructWithDuration {
///     timeout: Serde<Duration>,
/// }
/// # fn usage() {
/// # let doc = r#"{"a":"1 second"}"#;
///
/// let my_struct: StructWithDuration = hocon::de::from_str(doc).unwrap();
/// assert_eq!(*my_struct.timeout, Duration::from_secs(1));
/// # }
/// ```
///
/// ## As a serde attribute
///
/// ```rust
/// # use std::time::Duration;
/// # use hocon::de::wrappers::Serde;
/// # use serde::Deserialize;
/// #[derive(Deserialize, Debug)]
/// struct StructWithDuration {
///     #[serde(deserialize_with = "Serde::<Duration>::with")]
///     timeout: Duration,
/// }
/// # fn usage() {
/// # let doc = r#"{"a":"1 second"}"#;
///
/// let my_struct: StructWithDuration = hocon::de::from_str(doc).unwrap();
/// assert_eq!(my_struct.timeout, Duration::from_secs(1));
/// # }
/// ```
#[doc(alias = "Duration")]
#[derive(Debug)]
pub struct Serde<T>(T);

impl<T> Deref for Serde<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for Serde<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

struct StringDurationVisitor;

impl<'de> Visitor<'de> for StringDurationVisitor {
    type Value = Duration;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("a duration")
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        let duration = Hocon::str_as_milliseconds(&v)
            .ok_or_else(|| E::custom(format!("expected duration, found \"{}\"", v)))?;

        Ok(Duration::from_secs_f64(duration / 1000.0))
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        let duration = Hocon::str_as_milliseconds(v)
            .ok_or_else(|| E::custom(format!("expected duration, found \"{}\"", v)))?;

        Ok(Duration::from_secs_f64(duration / 1000.0))
    }
}

impl<'de> Deserialize<'de> for Serde<Duration> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Ok(Serde(deserializer.deserialize_str(StringDurationVisitor)?))
    }
}

impl Serde<Duration> {
    /// Custom deserializer for a duration, to use with Serde `deserialize_with` attribute
    pub fn with<'de, D>(deserializer: D) -> Result<Duration, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_str(StringDurationVisitor)
    }
}