vmi-core 0.7.0

Core VMI library
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

macro_rules! impl_ops {
    (
        $(#[$meta:meta])*
        $vis:vis struct $name:ident($inner_vis:vis $inner:ty);
    ) => {
        $(#[$meta])*
        #[derive(
            Debug,
            Default,
            Clone,
            Copy,
            PartialEq,
            Eq,
            PartialOrd,
            Ord,
            Hash,
            ::serde::Serialize,
            ::serde::Deserialize,
        )]
        $vis struct $name($inner_vis $inner);

        impl From<$inner> for $name {
            fn from(value: $inner) -> Self {
                Self(value)
            }
        }

        impl From<$name> for $inner {
            fn from(value: $name) -> $inner {
                value.0
            }
        }

        impl ::std::fmt::Display for $name {
            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                write!(f, "{}", self.0)
            }
        }

        impl ::std::fmt::LowerHex for $name {
            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                ::std::fmt::LowerHex::fmt(&self.0, f)
            }
        }

        impl ::std::fmt::UpperHex for $name {
            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                ::std::fmt::UpperHex::fmt(&self.0, f)
            }
        }
    };
}

macro_rules! impl_predicate {
    (
        $(#[$outer_meta:meta])*
        $vis:vis trait $name:ident & impl for &str {
            $(#[$inner_meta:meta])*
            fn matches(&$self:ident, $value:ident: &Os::$subtype:ident<'_>) -> Result<bool, VmiError> {
                $($rest:tt)*
            }
        }

        $(
            #[any]
            $any_vis:vis struct $any_name:ident;
        )?
    ) => {
        $(#[$outer_meta])*
        $vis trait $name<Os>
        where
            Os: VmiOs,
        {
            #[doc = concat!("Returns `Ok(true)` if `", stringify!($value), "` matches the predicate.")]
            fn matches(&self, $value: &Os::$subtype<'_>) -> Result<bool, VmiError>;
        }

        impl<Os> $name<Os> for &str
        where
            Os: VmiOs,
        {
            $(#[$inner_meta])*
            fn matches(&$self, $value: &Os::$subtype<'_>) -> Result<bool, VmiError> {
                $($rest)*
            }
        }

        impl<Os> $name<Os> for &String
        where
            Os: VmiOs,
        {
            $(#[$inner_meta])*
            fn matches(&self, $value: &Os::$subtype<'_>) -> Result<bool, VmiError> {
                $name::<Os>::matches(&self.as_str(), $value)
            }
        }

        impl<Os, F> $name<Os> for F
        where
            Os: VmiOs,
            F: Fn(&Os::$subtype<'_>) -> Result<bool, VmiError>,
        {
            fn matches(&self, $value: &Os::$subtype<'_>) -> Result<bool, VmiError> {
                self($value)
            }
        }

        $(
            #[doc = concat!(
                "A [`", stringify!($name), "`] that matches every `",
                stringify!($subtype), "`."
            )]
            $any_vis struct $any_name;

            impl<Os> $name<Os> for $any_name
            where
                Os: VmiOs,
            {
                fn matches(&self, _: &Os::$subtype<'_>) -> Result<bool, VmiError> {
                    Ok(true)
                }
            }
        )?
    };
}

pub(crate) use impl_ops;
pub(crate) use impl_predicate;