figen 0.2.0

Strongly typed configuration bindings and registries generated from a declarative schema
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
130

#[cfg(feature = "std")]
mod std {
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct ConfigRegistry {
        pub version: u32,
        pub entries: Vec<RegistryEntry>,
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub struct RegistryEntry {
        pub key: String,
        pub default_value: Option<Value>,
        pub value_kind: ValueKind,
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    #[derive(Eq, PartialEq, Debug)]
    pub enum Value {
        String(String),
        Number(i32),
        Boolean(bool),
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    #[derive(Eq, PartialEq, Debug, Copy, Clone)]
    pub enum ValueKind {
        String,
        Number,
        Boolean,
        Custom,
    }
}

#[cfg(not(feature = "std"))]
mod nostd {
    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    pub struct ConfigRegistry {
        pub version: u32,
        pub entries: &'static [RegistryEntry],
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    pub struct RegistryEntry {
        pub key: &'static str,
        pub default_value: Option<Value>,
        pub value_kind: ValueKind,
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    #[derive(Eq, PartialEq, Debug)]
    pub enum Value {
        String(&'static str),
        Number(i32),
        Boolean(bool),
    }

    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
    #[derive(Eq, PartialEq, Debug, Copy, Clone)]
    pub enum ValueKind {
        String,
        Number,
        Boolean,
        Custom,
    }
}

#[cfg(not(feature = "std"))]
pub use nostd::*;

#[cfg(feature = "std")]
pub use std::*;

impl ConfigRegistry {
    #[cfg(not(feature = "std"))]
    pub const fn new(version: u32, entries: &'static [RegistryEntry]) -> Self {
        Self { version, entries }
    }
    #[cfg(feature = "std")]
    pub const fn new(version: u32, entries: Vec<RegistryEntry>) -> Self {
        Self { version, entries }
    }

    pub fn get_version(&self) -> u32 {
        self.version
    }

    pub fn has_entry(&self, key: &str) -> bool {
        self.entries.iter().any(|entry| entry.key == key)
    }

    pub fn get_entry(&self, key: &str) -> Option<&RegistryEntry> {
        self.entries.iter().find(|entry| entry.key == key)
    }

    pub fn get_default_value(&self, key: &str) -> Option<&Value> {
        let entry = self.get_entry(key);
        if let Some(entry) = entry {
            entry.default_value.as_ref()
        } else {
            None
        }
    }

    pub fn iter_entries(&self) -> impl Iterator<Item = &RegistryEntry> {
        self.entries.iter()
    }
}

impl RegistryEntry {
    #[cfg(not(feature = "std"))]
    pub const fn new(
        key: &'static str,
        value_kind: ValueKind,
        default_value: Option<Value>,
    ) -> Self {
        Self {
            key,
            default_value,
            value_kind,
        }
    }
    #[cfg(feature = "std")]
    pub fn new(key: &'static str, value_kind: ValueKind, default_value: Option<Value>) -> Self {
        Self {
            key: key.into(),
            default_value,
            value_kind,
        }
    }
}