modio 0.7.1

Rust interface for integrating https://mod.io - a modding API for game developers
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

// macro: bitflags {{{
macro_rules! bitflags {
    (
        $(#[$outer:meta])*
        $vis:vis struct $BitFlags:ident: $T:ty {
            $(
                $(#[$inner:ident $($args:tt)*])*
                const $Flag:ident = $value:expr;
            )*
        }

        $($t:tt)*
    ) => {
        bitflags::bitflags! {
            $(#[$outer])*
            $vis struct $BitFlags: $T {
                $(
                    $(#[$inner $($args)*])*
                    const $Flag = $value;
                )*
            }
        }

        bitflags!(__impl_display $BitFlags);
        bitflags!(__impl_serde $BitFlags: $T);

        bitflags! {
            $($t)*
        }
    };
    (__impl_display $BitFlags:ident) => {
        impl ::std::fmt::Display for $BitFlags {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                self.bits.fmt(f)
            }
        }
    };
    (__impl_serde $BitFlags:ident: $T:tt) => {
        impl<'de> ::serde::de::Deserialize<'de> for $BitFlags {
            fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> ::std::result::Result<Self, D::Error> {
                let value = <$T>::deserialize(deserializer)?;
                Self::from_bits(value)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom(format!("invalid {} value: {}", stringify!($BitFlags), value))
                    })
            }
        }
    };
    () => {};
}
// }}}

// macro: enum_number {{{
macro_rules! enum_number {
    (
        $(#[$outer:meta])*
        $vis:vis enum $Enum:ident {
            $(
                $(#[$inner:ident $($args:tt)*])*
                $Variant:ident = $value:literal,
            )*
            _ => Unknown($T:ty),
        }
    ) => {
        $(#[$outer])*
        $vis enum $Enum {
            $(
                $(#[$inner $($args)*])*
                $Variant,
            )*
            /// Variant value is unknown.
            Unknown($T),
        }

        impl ::std::fmt::Display for $Enum {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                <$T>::from(*self).fmt(f)
            }
        }

        impl From<$T> for $Enum {
            fn from(value: $T) -> Self {
                #[allow(unused_doc_comments)]
                match value {
                    $($(#[$inner $($args)*])* $value => Self::$Variant,)*
                    unknown => Self::Unknown(unknown),
                }
            }
        }

        impl From<$Enum> for $T {
            fn from(value: $Enum) -> Self {
                #[allow(unused_doc_comments)]
                match value {
                    $($(#[$inner $($args)*])* $Enum::$Variant => $value,)*
                    $Enum::Unknown(unknown) => unknown,
                }
            }
        }
    };
}
// }}}

// vim: fdm=marker