openstranded_plugin_api/
registry.rs1use std::collections::HashMap;
2
3use crate::ServiceError;
4
5#[cfg(feature = "parse")]
6use crate::Value;
7#[cfg(feature = "parse")]
8use ron::value::Value as RonValue;
9
10#[derive(Clone, Debug)]
12pub struct RegistryEntry {
13 pub filename: String,
15
16 pub data: Vec<u8>,
18}
19
20#[derive(Clone, Debug, Default)]
34pub struct Registry {
35 pub domains: HashMap<String, HashMap<String, Vec<u8>>>,
37}
38
39impl Registry {
40 #[must_use]
42 pub fn new() -> Self {
43 Self {
44 domains: HashMap::new(),
45 }
46 }
47
48 pub fn domain(&self, name: &str) -> Result<&HashMap<String, Vec<u8>>, ServiceError> {
50 self.domains
51 .get(name)
52 .ok_or_else(|| ServiceError::RegistryDomainNotFound(name.into()))
53 }
54
55 pub fn file(&self, domain: &str, filename: &str) -> Result<&[u8], ServiceError> {
57 self.domains
58 .get(domain)
59 .and_then(|files| files.get(filename))
60 .map(std::vec::Vec::as_slice)
61 .ok_or_else(|| ServiceError::FileNotFound {
62 domain: domain.into(),
63 filename: filename.into(),
64 })
65 }
66
67 pub fn domain_entries(&self, name: &str) -> Result<Vec<RegistryEntry>, ServiceError> {
69 let files = self.domain(name)?;
70 Ok(files
71 .iter()
72 .map(|(filename, data)| RegistryEntry {
73 filename: filename.clone(),
74 data: data.clone(),
75 })
76 .collect())
77 }
78
79 pub fn add_file(&mut self, domain: &str, filename: &str, data: Vec<u8>) {
81 self.domains
82 .entry(domain.to_owned())
83 .or_default()
84 .insert(filename.to_owned(), data);
85 }
86
87 #[must_use]
89 pub fn has_domain(&self, name: &str) -> bool {
90 self.domains.contains_key(name)
91 }
92
93 pub fn domain_names(&self) -> impl Iterator<Item = &str> {
95 self.domains.keys().map(std::string::String::as_str)
96 }
97
98 #[must_use]
100 pub fn len(&self) -> usize {
101 self.domains.len()
102 }
103
104 #[must_use]
106 pub fn is_empty(&self) -> bool {
107 self.domains.is_empty()
108 }
109}
110
111#[cfg(feature = "parse")]
130pub fn parse_registry_data(bytes: &[u8]) -> Result<Value, ServiceError> {
131 let s = std::str::from_utf8(bytes).map_err(|e| {
132 ServiceError::ParseError(format!("registry data is not valid UTF-8: {e}"))
133 })?;
134 let ron_value: RonValue = ron::from_str(s).map_err(|e| {
135 ServiceError::ParseError(format!("failed to parse registry data: {e}"))
136 })?;
137 Ok(convert_ron_value(ron_value))
138}
139
140#[cfg(feature = "parse")]
154pub fn parse_registry_list(bytes: &[u8]) -> Result<Vec<Value>, ServiceError> {
155 let root = parse_registry_data(bytes)?;
156 match root {
157 Value::Array(arr) => Ok(arr),
158 other => Err(ServiceError::TypeMismatch {
159 expected: "array".into(),
160 found: format!("{other:?}"),
161 }),
162 }
163}
164
165#[cfg(feature = "parse")]
169fn convert_ron_value(v: RonValue) -> Value {
170 match v {
171 RonValue::Unit => Value::Null,
172 RonValue::Bool(b) => Value::Bool(b),
173 RonValue::Number(n) => {
174 match n {
175 ron::value::Number::I32(i) => Value::I32(i),
176 ron::value::Number::I64(i) => {
177 if let Ok(n) = i32::try_from(i) {
178 Value::I32(n)
179 } else {
180 Value::F64(i as f64)
181 }
182 }
183 ron::value::Number::F32(f) => Value::F64(f64::from(f.0)),
184 ron::value::Number::F64(f) => Value::F64(f.0),
185 ron::value::Number::U32(u) => Value::U32(u),
186 ron::value::Number::U64(u) => {
187 if let Ok(n) = u32::try_from(u) {
188 Value::U32(n)
189 } else {
190 Value::F64(u as f64)
191 }
192 }
193 ron::value::Number::I8(i) => Value::I32(i32::from(i)),
195 ron::value::Number::I16(i) => Value::I32(i32::from(i)),
196 ron::value::Number::U8(u) => Value::U32(u32::from(u)),
197 ron::value::Number::U16(u) => Value::U32(u32::from(u)),
198 #[allow(unreachable_patterns)]
199 _ => Value::Null,
200 }
201 }
202 RonValue::Char(c) => Value::String(c.to_string()),
203 RonValue::String(s) => Value::String(s),
204 RonValue::Bytes(b) => Value::Bytes(b),
205 RonValue::Seq(arr) => {
206 Value::Array(arr.into_iter().map(convert_ron_value).collect())
207 }
208 RonValue::Map(map) => {
209 Value::Map(
210 map.into_iter()
211 .map(|(k, v)| (convert_ron_key(k), convert_ron_value(v)))
212 .collect(),
213 )
214 }
215 RonValue::Option(Some(v)) => convert_ron_value(*v),
216 RonValue::Option(None) => Value::Null,
217 }
218}
219
220#[cfg(feature = "parse")]
222fn convert_ron_key(k: RonValue) -> String {
223 match k {
224 RonValue::String(s) => s,
225 RonValue::Char(c) => c.to_string(),
226 other => format!("{other:?}"),
227 }
228}
229
230#[cfg(test)]
233#[cfg(feature = "parse")]
234mod tests {
235 use super::*;
236
237 #[test]
238 fn test_parse_registry_data_object() {
239 let ron = br#"ItemDef(id: 1, name: "Wood")"#;
240 let value = parse_registry_data(ron).unwrap();
241 assert_eq!(value.get("id").unwrap().as_u32().unwrap(), 1);
242 assert_eq!(value.get("name").unwrap().as_str().unwrap(), "Wood");
243 }
244
245 #[test]
246 fn test_parse_registry_data_array() {
247 let ron = br#"[1, 2, 3]"#;
248 let value = parse_registry_data(ron).unwrap();
249 assert_eq!(value.as_array().unwrap().len(), 3);
250 }
251
252 #[test]
253 fn test_parse_registry_list_ok() {
254 let ron = br#"[ItemDef(id: 1), ItemDef(id: 2)]"#;
255 let items = parse_registry_list(ron).unwrap();
256 assert_eq!(items.len(), 2);
257 assert_eq!(items[0].get("id").unwrap().as_u32().unwrap(), 1);
258 }
259
260 #[test]
261 fn test_parse_registry_list_not_array() {
262 let ron = br#"ItemDef(id: 1)"#;
263 let err = parse_registry_list(ron).unwrap_err();
264 assert!(matches!(err, ServiceError::TypeMismatch { .. }));
265 }
266
267 #[test]
268 fn test_parse_invalid_ron() {
269 let ron = b"not valid ron {{{";
270 assert!(parse_registry_data(ron).is_err());
271 }
272
273 #[test]
274 fn test_registry_add_and_get() {
275 let mut reg = Registry::new();
276 reg.add_file("items", "items_edible.ron", vec![1, 2, 3]);
277 reg.add_file("items", "items_material.ron", vec![4, 5, 6]);
278
279 assert_eq!(reg.file("items", "items_edible.ron").unwrap(), &[1, 2, 3]);
280 assert_eq!(reg.domain_entries("items").unwrap().len(), 2);
281 }
282
283 #[test]
284 fn test_registry_file_not_found() {
285 let reg = Registry::new();
286 let err = reg.file("nonexistent", "foo.ron").unwrap_err();
287 assert!(matches!(err, ServiceError::FileNotFound { .. }));
288 }
289
290 #[test]
291 fn test_registry_domain_not_found() {
292 let reg = Registry::new();
293 let err = reg.domain("nonexistent").unwrap_err();
294 assert!(matches!(err, ServiceError::RegistryDomainNotFound(..)));
295 }
296}