idl/ids/
nodes.rs

1use core::fmt;
2
3use serde::{de::value, Deserialize, Serialize};
4
5#[derive(Debug, Copy, Clone, Eq, PartialEq, Deserialize, Serialize)]
6#[serde(rename_all = "camelCase")]
7pub enum Keywords {
8    Package,
9    Client,
10    Server,
11}
12
13#[derive(Debug, Deserialize, Serialize, Clone)]
14pub enum ItemType {
15    NatInt(i64),
16    NatFloat(f64),
17    NatString(String),
18    NatBool(bool),
19    Identifier(String),
20    ClientTypeName(String),
21    ServerTypeName(String),
22    Values(Vec<ItemType>),
23}
24
25impl fmt::Display for ItemType {
26    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
27        let errstr = match self {
28            ItemType::NatInt(value) => value.to_string(),
29            ItemType::NatFloat(value) => value.to_string(),
30            ItemType::NatString(value) => format!("\"{}\"", value),
31            ItemType::NatBool(value) => value.to_string(),
32            ItemType::Identifier(value) => value.to_owned(),
33            ItemType::ServerTypeName(value) | ItemType::ClientTypeName(value) => value.to_owned(),
34            ItemType::Values(value) => {
35                format!(
36                    "{}]",
37                    value
38                        .iter()
39                        .fold("[".to_owned(), |p, val| format!("{}{},", p, val))
40                )
41            }
42        };
43
44        write!(f, "{}", errstr)
45    }
46}
47
48impl ItemType {
49    pub fn is_int(&self) -> bool {
50        match self {
51            ItemType::NatInt(_) => true,
52            _ => false,
53        }
54    }
55
56    pub fn is_float(&self) -> bool {
57        match self {
58            ItemType::NatFloat(_) => true,
59            _ => false,
60        }
61    }
62
63    pub fn is_string(&self) -> bool {
64        match self {
65            ItemType::NatString(_) => true,
66            _ => false,
67        }
68    }
69
70    pub fn is_boolean(&self) -> bool {
71        match self {
72            ItemType::NatBool(_) => true,
73            _ => false,
74        }
75    }
76
77    pub fn is_client(&self) -> bool {
78        match self {
79            ItemType::ClientTypeName(_) => true,
80            _ => false,
81        }
82    }
83
84    pub fn is_server(&self) -> bool {
85        match self {
86            ItemType::ServerTypeName(_) => true,
87            _ => false,
88        }
89    }
90
91    pub fn is_identifier(&self) -> bool {
92        match self {
93            ItemType::Identifier(_) => true,
94            _ => false,
95        }
96    }
97
98    pub fn is_values(&self) -> bool {
99        match self {
100            ItemType::Values(_) => true,
101            _ => false,
102        }
103    }
104
105    pub fn as_identifier(&self) -> Option<String> {
106        match self {
107            ItemType::Identifier(value) => Some(value.clone()),
108            _ => None,
109        }
110    }
111
112    pub fn as_string_value(&self) -> Option<String> {
113        match self {
114            ItemType::NatString(value) => Some(value.clone()),
115            _ => None,
116        }
117    }
118
119    pub fn as_int_value(&self) -> Option<i64> {
120        match self {
121            ItemType::NatInt(value) => Some(*value),
122            _ => None,
123        }
124    }
125
126    pub fn as_float_value(&self) -> Option<f64> {
127        match self {
128            ItemType::NatFloat(value) => Some(*value),
129            _ => None,
130        }
131    }
132
133    pub fn as_bool_value(&self) -> Option<bool> {
134        match self {
135            ItemType::NatBool(value) => Some(*value),
136            _ => None,
137        }
138    }
139
140    pub fn as_client_name(&self) -> Option<String> {
141        match self {
142            ItemType::ClientTypeName(value) => Some(value.clone()),
143            _ => None,
144        }
145    }
146
147    pub fn as_server_name(&self) -> Option<String> {
148        match self {
149            ItemType::ServerTypeName(value) => Some(value.clone()),
150            _ => None,
151        }
152    }
153
154    pub fn as_values(&self) -> Option<Vec<ItemType>> {
155        match self {
156            ItemType::Values(value) => Some(value.clone()),
157            _ => None,
158        }
159    }
160}
161
162#[derive(Debug, Deserialize, Serialize, Clone)]
163pub enum IdsNode {
164    Package(Box<super::package::Package>),
165    Server(Box<super::server::Server>),
166    Client(Box<super::client::Client>),
167}
idl/ids/nodes.rs

idl/ids/
nodes.rs
