gsettings-macro 0.2.3

Macro for typesafe GSettings key access
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

use serde::Deserialize;

#[derive(Debug, Deserialize)]
pub struct SchemaList {
    #[serde(rename = "enum", default)]
    pub enums: Vec<Enum>,
    #[serde(default)]
    pub flags: Vec<Flag>,
    #[serde(rename = "schema")]
    pub schemas: Vec<Schema>,
}

#[derive(Debug, Deserialize)]
pub struct Enum {
    #[serde(rename = "@id")]
    pub id: String,
    #[serde(rename = "value")]
    pub values: Vec<EnumValues>,
}

#[derive(Debug, Deserialize)]
pub struct EnumValues {
    #[serde(rename = "@nick")]
    pub nick: String,
    #[serde(rename = "@value")]
    pub value: i32,
}

#[derive(Debug, Deserialize)]
pub struct Flag {
    #[serde(rename = "@id")]
    pub id: String,
    #[serde(rename = "value")]
    pub values: Vec<FlagValues>,
}

#[derive(Debug, Deserialize)]
pub struct FlagValues {
    #[serde(rename = "@nick")]
    pub nick: String,
    #[serde(rename = "@value")]
    pub value: u32,
}

#[derive(Debug, Deserialize)]
pub struct Schema {
    #[serde(rename = "@id")]
    pub id: String,
    #[serde(rename = "key")]
    pub keys: Vec<Key>,
}

#[derive(Debug, Deserialize)]
pub struct Key {
    #[serde(rename = "@name")]
    pub name: String,
    #[serde(rename = "@type")]
    type_: Option<String>,
    #[serde(rename = "@enum")]
    enum_id: Option<String>,
    #[serde(rename = "@flags")]
    flag_id: Option<String>,
    pub default: String,
    pub summary: Option<String>,
    pub description: Option<String>,
    pub choices: Option<Choices>,
    pub range: Option<Range>,
}

#[derive(PartialEq, Eq, Hash)]
pub enum KeySignature {
    Type(String),
    Enum(String),
    Flag(String),
}

impl std::fmt::Display for KeySignature {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            KeySignature::Type(type_) => write!(f, "`{}` type", type_),
            KeySignature::Enum(enum_) => write!(f, "`{}` enum", enum_),
            KeySignature::Flag(flag) => write!(f, "`{}` flag", flag),
        }
    }
}

impl Key {
    pub fn signature(&self) -> Option<KeySignature> {
        match (&self.type_, &self.enum_id, &self.flag_id) {
            (Some(type_name), None, None) => Some(KeySignature::Type(type_name.to_string())),
            (None, Some(enum_id), None) => Some(KeySignature::Enum(enum_id.to_string())),
            (None, None, Some(flag_id)) => Some(KeySignature::Flag(flag_id.to_string())),
            _ => None,
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct Choice {
    #[serde(rename = "@value")]
    pub value: String,
}

#[derive(Debug, Deserialize)]
pub struct Choices {
    #[serde(rename = "choice")]
    pub choices: Vec<Choice>,
}

#[derive(Debug, Deserialize)]
pub struct Range {
    #[serde(rename = "@max")]
    pub max: Option<String>,
    #[serde(rename = "@min")]
    pub min: Option<String>,
}