dare 0.0.3

daring flexible data representation
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

#[doc(hidden)]
#[macro_export]
macro_rules! _impl_from_for_value {
    ($($t:ty => $variant:ident),+) => {
        $(
            impl From<$t> for Value {
                fn from(item: $t) -> Self {
                    Value::$variant(item.into())
                }
            }
        )+

        #[cfg(not(feature = "serde"))]
        impl From<&'static [Value]> for Value {
            fn from(item: &'static [Value]) -> Self {
                Value::Slice(item)
            }
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! _impl_value_methods {
    ($($variant:ident => $type:ty, $as_method:ident, $is_method:ident);+ $(;)?) => {
        impl Value {
            $(
                pub fn $is_method(&self) -> bool {
                    matches!(self, Value::$variant(_))
                }

                pub fn $as_method(&self) -> Option<$type> {
                    match self {
                        Value::$variant(v) => Some(v.clone()),
                        _ => None,
                    }
                }
            )+

            #[cfg(not(feature = "serde"))]
            pub fn as_slice(&self) -> Option<&'static [Value]> {
                match self {
                    Value::Slice(v) => Some(v),
                    _ => None,
                }
            }

            #[cfg(not(feature = "serde"))]
            pub fn is_slice(&self) -> bool {
                matches!(self, Value::Slice(_))
            }

            pub fn to_value(self) -> Value {
                self
            }

            pub fn is_null(&self) -> bool {
                matches!(self, Value::Null)
            }
        }
    };
}

#[doc(inline)]
pub use _impl_from_for_value as impl_for;

#[doc(inline)]
pub use _impl_value_methods as impl_methods;