module 0.3.1

Modular NixOS-style configuration crate.
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
122
123
124
125
126
127
128
129

//! Types implementing various merge strategies.

pub mod first;
pub mod last;
pub mod lines;
pub mod no_merge;
pub mod ordered;
pub mod overridable;

#[doc(inline)]
pub use self::first::First;
#[doc(inline)]
pub use self::last::Last;
#[doc(inline)]
pub use self::lines::Lines;
#[doc(inline)]
pub use self::no_merge::NoMerge;
#[doc(inline)]
pub use self::ordered::Ordered;
#[doc(inline)]
pub use self::overridable::Overridable;

#[allow(unused_imports)]
mod prelude {
    pub(super) use crate::merge::{Context, Error, Merge};

    macro_rules! impl_borrow {
        ($t:ident $(<$tp:ident>)? => $u:ty { $($tail:tt)* }) => {
            impl $(<$tp>)? ::core::borrow::Borrow<$u> for $t $(<$tp>)? {
                #[inline]
                fn borrow(&self) -> &$u {
                    &self $($tail)*
                }
            }

            impl $(<$tp>)? ::core::borrow::BorrowMut<$u> for $t $(<$tp>)? {
                #[inline]
                fn borrow_mut(&mut self) -> &mut $u {
                    &mut self $($tail)*
                }
            }
        }
    }

    pub(super) use impl_borrow;

    macro_rules! impl_as_ref {
        ($t:ident $(<$tp:ident>)? => $u:ty { $($tail:tt)* }) => {
            impl $(<$tp>)? ::core::convert::AsRef<$u> for $t $(<$tp>)? {
                #[inline]
                fn as_ref(&self) -> &$u {
                    &self $($tail)*
                }
            }

            impl $(<$tp>)? ::core::convert::AsMut<$u> for $t $(<$tp>)? {
                #[inline]
                fn as_mut(&mut self) -> &mut $u {
                    &mut self $($tail)*
                }
            }
        }
    }

    pub(super) use impl_as_ref;

    macro_rules! impl_deref {
        ($t:ident $(<$tp:ident>)? => $u:ty { $($tail:tt)* }) => {
            impl $(<$tp>)? ::core::ops::Deref for $t $(<$tp>)? {
                type Target = $u;

                #[inline]
                fn deref(&self) -> &Self::Target {
                    &self $($tail)*
                }
            }

            impl $(<$tp>)? ::core::ops::DerefMut for $t $(<$tp>)? {
                #[inline]
                fn deref_mut(&mut self) -> &mut Self::Target {
                    &mut self $($tail)*
                }
            }
        }
    }

    pub(super) use impl_deref;

    macro_rules! impl_wrapper {
        ($($tail:tt)*) => {
            impl_borrow! { $($tail)* }
            impl_as_ref! { $($tail)* }
            impl_deref!  { $($tail)* }
        }
    }

    pub(super) use impl_wrapper;

    macro_rules! merge_thin_wrapper {
        (
            $(#[$attr:meta])*
            $vis:vis struct $wrapper:ident;
        ) => {
            $(#[$attr])*
            #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
            $vis struct $wrapper<T>(pub T);

            impl<T> ::core::default::Default for $wrapper<T>
            where
                T: ::core::default::Default
            {
                fn default() -> Self {
                    Self(T::default())
                }
            }

            impl<T> ::core::convert::From<T> for $wrapper<T> {
                #[inline]
                fn from(x: T) -> Self {
                    Self(x)
                }
            }

            impl_wrapper!($wrapper<T> => T { .0 });
        };
    }

    pub(super) use merge_thin_wrapper;
}