muzzman_lib/
types.rs

1use std::{
2    collections::HashMap,
3    fmt::{Debug, Display},
4    hash::Hash,
5    path::PathBuf,
6    sync::{Arc, RwLock},
7};
8
9use bytes_kman::TBytes;
10
11pub type LRef = Arc<RwLock<RefLocation>>;
12pub type ERef = Arc<RwLock<RefElement>>;
13pub type MRef = Arc<RwLock<RefModule>>;
14
15pub type LRow = Arc<RwLock<Location>>;
16pub type ERow = Arc<RwLock<Element>>;
17pub type MRow = Arc<RwLock<Module>>;
18
19#[derive(Debug, Clone, bytes_kman::Bytes)]
20pub enum ID {
21    Element(ElementId),
22    Location(LocationId),
23}
24
25impl PartialEq for ID {
26    fn eq(&self, other: &Self) -> bool {
27        match self {
28            ID::Element(e) => {
29                if let ID::Element(se) = other {
30                    e == se
31                } else {
32                    false
33                }
34            }
35            ID::Location(l) => {
36                if let ID::Location(sl) = other {
37                    l == sl
38                } else {
39                    false
40                }
41            }
42        }
43    }
44}
45
46impl ID {
47    pub fn get_ref(&self, session: &dyn TSession) -> Result<Ref, SessionError> {
48        match self {
49            ID::Element(e) => Ok(Ref::Element(session.get_element_ref(e)?)),
50            ID::Location(l) => Ok(Ref::Location(session.get_location_ref(l)?)),
51        }
52    }
53}
54
55use serde::{Deserialize, Serialize};
56
57use crate::{
58    element::ElementId,
59    enums::{AdvanceEnum, CustomEnum},
60    prelude::{
61        Element, FileOrData, Location, LocationId, Module, Ref, RefElement, RefLocation, RefModule,
62        SessionError, TSession,
63    },
64};
65
66#[derive(Debug, Clone, Serialize, Deserialize, bytes_kman::Bytes)]
67pub enum Type {
68    U8(u8),
69    U16(u16),
70    U32(u32),
71    U64(u64),
72    U128(u128),
73    USize(usize),
74
75    I8(i8),
76    I16(i16),
77    I32(i32),
78    I64(i64),
79    I128(i128),
80    ISize(isize),
81
82    F32(f32),
83    F64(f64),
84
85    Bool(bool),
86
87    String(String),
88    Path(PathBuf),
89    HashMapSS(HashMap<String, String>),
90    HashMapS(HashMap<String, Type>),
91    // HashMap(HashMap<Type, Type>),
92    FileOrData(FileOrData),
93    CustomEnum(CustomEnum),
94    AdvancedEnum(AdvanceEnum),
95    // Fields(Box<dyn Fields>),
96    Vec(Vec<Type>),
97    Bytes(Vec<u8>),
98
99    None,
100}
101
102impl Hash for Type {
103    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
104        match self {
105            Type::U8(i) => i.hash(state),
106            Type::U16(i) => i.hash(state),
107            Type::U32(i) => i.hash(state),
108            Type::U64(i) => i.hash(state),
109            Type::U128(i) => i.hash(state),
110            Type::USize(i) => i.hash(state),
111            Type::I8(i) => i.hash(state),
112            Type::I16(i) => i.hash(state),
113            Type::I32(i) => i.hash(state),
114            Type::I64(i) => i.hash(state),
115            Type::I128(i) => i.hash(state),
116            Type::ISize(i) => i.hash(state),
117            Type::F32(f) => (*f as i32).hash(state),
118            Type::F64(f) => (*f as i64).hash(state),
119            Type::Bool(b) => b.hash(state),
120            Type::String(s) => s.hash(state),
121            Type::Path(p) => p.hash(state),
122            Type::HashMapSS(h) => {
123                for (k, e) in h.iter() {
124                    k.hash(state);
125                    e.hash(state)
126                }
127            }
128            Type::HashMapS(h) => {
129                for k in h.keys() {
130                    k.hash(state)
131                }
132            }
133            Type::FileOrData(ford) => ford.hash(state),
134            Type::CustomEnum(e) => e.hash(state),
135            Type::AdvancedEnum(e) => e.hash(state),
136            Type::Vec(v) => v.hash(state),
137            Type::Bytes(b) => b.hash(state),
138            Type::None => 0.hash(state),
139        }
140    }
141}
142
143impl Type {
144    pub fn to_tag(&self) -> TypeTag {
145        use TypeTag::*;
146
147        match self {
148            Type::U8(_) => U8,
149            Type::U16(_) => U16,
150            Type::U32(_) => U32,
151            Type::U64(_) => U64,
152            Type::U128(_) => U128,
153            Type::USize(_) => USize,
154            Type::I8(_) => I8,
155            Type::I16(_) => I16,
156            Type::I32(_) => I32,
157            Type::I64(_) => I64,
158            Type::I128(_) => I128,
159            Type::ISize(_) => ISize,
160            Type::F32(_) => F32,
161            Type::F64(_) => F64,
162            Type::Bool(_) => Bool,
163            Type::String(_) => String,
164            Type::Path(_) => Path,
165            Type::HashMapSS(_) => HashMapSS,
166            Type::HashMapS(h) => {
167                let Some(ty) = h.iter().next() else{return None;};
168                HashMapS(Box::new(ty.1.to_tag()))
169            }
170            Type::FileOrData(_) => FileOrData,
171            Type::CustomEnum(e) => CustomEnum(e.clone()),
172            Type::AdvancedEnum(e) => AdvancedEnum(e.clone()),
173            Type::Vec(v) => {
174                let Some(d) = v.get(0)else{return Vec(Box::new(None))};
175                Vec(Box::new(d.to_tag()))
176            }
177            Type::Bytes(_) => Bytes,
178            Type::None => None,
179        }
180    }
181}
182
183impl Display for Type {
184    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
185        match self {
186            Type::U8(v) => (v as &dyn Display).fmt(f),
187            Type::U16(v) => (v as &dyn Display).fmt(f),
188            Type::U32(v) => (v as &dyn Display).fmt(f),
189            Type::U64(v) => (v as &dyn Display).fmt(f),
190            Type::U128(v) => (v as &dyn Display).fmt(f),
191            Type::USize(v) => (v as &dyn Display).fmt(f),
192            Type::I8(v) => (v as &dyn Display).fmt(f),
193            Type::I16(v) => (v as &dyn Display).fmt(f),
194            Type::I32(v) => (v as &dyn Display).fmt(f),
195            Type::I64(v) => (v as &dyn Display).fmt(f),
196            Type::I128(v) => (v as &dyn Display).fmt(f),
197            Type::ISize(v) => (v as &dyn Display).fmt(f),
198            Type::F32(v) => (v as &dyn Display).fmt(f),
199            Type::F64(v) => (v as &dyn Display).fmt(f),
200            Type::Bool(v) => (v as &dyn Display).fmt(f),
201            Type::String(s) => f.write_str(s),
202            Type::Path(v) => f.write_str(if let Some(str) = v.to_str() {
203                str
204            } else {
205                "Cannot parse!"
206            }),
207            Type::HashMapSS(v) => {
208                let mut buff = String::new();
209                for (k, v) in v.iter() {
210                    buff.push_str(&format!("{k}: {v}"));
211                }
212                f.write_str(&buff)
213            }
214            Type::HashMapS(v) => {
215                let mut buff = String::new();
216                for (k, v) in v.iter() {
217                    buff.push_str(&format!("{k}: {v}"));
218                }
219                f.write_str(&buff)
220            }
221            Type::FileOrData(ford) => match ford {
222                FileOrData::File(file_path, _) => write!(
223                    f,
224                    "File: {}",
225                    if let Some(path) = file_path.to_str() {
226                        path
227                    } else {
228                        "Cannot parse path!"
229                    }
230                ),
231                FileOrData::Bytes(b) => b.fmt(f),
232            },
233            Type::CustomEnum(e) => {
234                if let Some(e) = e.get_active() {
235                    f.write_str(&e)
236                } else {
237                    f.write_str("None")
238                }
239            }
240            Type::AdvancedEnum(_) => {
241                f.write_str("Not Implemented")
242                // if let Some(e) = e.get_active() {
243                //     e
244                // } else {
245                //     format!("None")
246                // }
247            }
248            Type::Vec(v) => v.fmt(f),
249            Type::Bytes(b) => (b as &dyn std::fmt::Debug).fmt(f),
250            Type::None => f.write_str(""),
251        }
252    }
253}
254
255impl From<u8> for Type {
256    fn from(value: u8) -> Self {
257        Self::U8(value)
258    }
259}
260
261impl From<u16> for Type {
262    fn from(value: u16) -> Self {
263        Self::U16(value)
264    }
265}
266
267impl From<u32> for Type {
268    fn from(value: u32) -> Self {
269        Self::U32(value)
270    }
271}
272
273impl From<u64> for Type {
274    fn from(value: u64) -> Self {
275        Self::U64(value)
276    }
277}
278
279impl From<u128> for Type {
280    fn from(value: u128) -> Self {
281        Self::U128(value)
282    }
283}
284
285impl From<usize> for Type {
286    fn from(value: usize) -> Self {
287        Self::USize(value)
288    }
289}
290
291impl From<i8> for Type {
292    fn from(value: i8) -> Self {
293        Self::I8(value)
294    }
295}
296
297impl From<i16> for Type {
298    fn from(value: i16) -> Self {
299        Self::I16(value)
300    }
301}
302
303impl From<i32> for Type {
304    fn from(value: i32) -> Self {
305        Self::I32(value)
306    }
307}
308
309impl From<i64> for Type {
310    fn from(value: i64) -> Self {
311        Self::I64(value)
312    }
313}
314
315impl From<i128> for Type {
316    fn from(value: i128) -> Self {
317        Self::I128(value)
318    }
319}
320
321impl From<isize> for Type {
322    fn from(value: isize) -> Self {
323        Self::ISize(value)
324    }
325}
326
327impl From<f32> for Type {
328    fn from(value: f32) -> Self {
329        Self::F32(value)
330    }
331}
332
333impl From<f64> for Type {
334    fn from(value: f64) -> Self {
335        Self::F64(value)
336    }
337}
338
339impl From<bool> for Type {
340    fn from(value: bool) -> Self {
341        Self::Bool(value)
342    }
343}
344
345impl From<String> for Type {
346    fn from(value: String) -> Self {
347        Self::String(value)
348    }
349}
350
351impl From<&str> for Type {
352    fn from(value: &str) -> Self {
353        Self::String(value.into())
354    }
355}
356
357impl TryInto<u8> for Type {
358    type Error = ();
359
360    fn try_into(self) -> Result<u8, Self::Error> {
361        if let Self::U8(value) = self {
362            Ok(value)
363        } else {
364            Err(())
365        }
366    }
367}
368
369impl TryInto<u16> for Type {
370    type Error = ();
371
372    fn try_into(self) -> Result<u16, Self::Error> {
373        if let Self::U16(value) = self {
374            Ok(value)
375        } else {
376            Err(())
377        }
378    }
379}
380
381impl TryInto<u32> for Type {
382    type Error = ();
383
384    fn try_into(self) -> Result<u32, Self::Error> {
385        if let Self::U32(value) = self {
386            Ok(value)
387        } else {
388            Err(())
389        }
390    }
391}
392
393impl TryInto<u64> for Type {
394    type Error = ();
395
396    fn try_into(self) -> Result<u64, Self::Error> {
397        if let Self::U64(value) = self {
398            Ok(value)
399        } else {
400            Err(())
401        }
402    }
403}
404
405impl TryInto<u128> for Type {
406    type Error = ();
407
408    fn try_into(self) -> Result<u128, Self::Error> {
409        if let Self::U128(value) = self {
410            Ok(value)
411        } else {
412            Err(())
413        }
414    }
415}
416
417impl TryInto<usize> for Type {
418    type Error = ();
419
420    fn try_into(self) -> Result<usize, Self::Error> {
421        if let Self::USize(value) = self {
422            Ok(value)
423        } else {
424            Err(())
425        }
426    }
427}
428
429impl TryInto<i8> for Type {
430    type Error = ();
431
432    fn try_into(self) -> Result<i8, Self::Error> {
433        if let Self::I8(value) = self {
434            Ok(value)
435        } else {
436            Err(())
437        }
438    }
439}
440
441impl TryInto<i16> for Type {
442    type Error = ();
443
444    fn try_into(self) -> Result<i16, Self::Error> {
445        if let Self::I16(value) = self {
446            Ok(value)
447        } else {
448            Err(())
449        }
450    }
451}
452
453impl TryInto<i32> for Type {
454    type Error = ();
455
456    fn try_into(self) -> Result<i32, Self::Error> {
457        if let Self::I32(value) = self {
458            Ok(value)
459        } else {
460            Err(())
461        }
462    }
463}
464
465impl TryInto<i64> for Type {
466    type Error = ();
467
468    fn try_into(self) -> Result<i64, Self::Error> {
469        if let Self::I64(value) = self {
470            Ok(value)
471        } else {
472            Err(())
473        }
474    }
475}
476
477impl TryInto<i128> for Type {
478    type Error = ();
479
480    fn try_into(self) -> Result<i128, Self::Error> {
481        if let Self::I128(value) = self {
482            Ok(value)
483        } else {
484            Err(())
485        }
486    }
487}
488
489impl TryInto<isize> for Type {
490    type Error = ();
491
492    fn try_into(self) -> Result<isize, Self::Error> {
493        if let Self::ISize(value) = self {
494            Ok(value)
495        } else {
496            Err(())
497        }
498    }
499}
500
501impl TryInto<f32> for Type {
502    type Error = ();
503
504    fn try_into(self) -> Result<f32, Self::Error> {
505        if let Self::F32(value) = self {
506            Ok(value)
507        } else {
508            Err(())
509        }
510    }
511}
512
513impl TryInto<f64> for Type {
514    type Error = ();
515
516    fn try_into(self) -> Result<f64, Self::Error> {
517        if let Self::F64(value) = self {
518            Ok(value)
519        } else {
520            Err(())
521        }
522    }
523}
524
525impl TryInto<bool> for Type {
526    type Error = ();
527
528    fn try_into(self) -> Result<bool, Self::Error> {
529        if let Self::Bool(value) = self {
530            Ok(value)
531        } else {
532            Err(())
533        }
534    }
535}
536
537impl TryInto<String> for Type {
538    type Error = ();
539
540    fn try_into(self) -> Result<String, Self::Error> {
541        if let Self::String(value) = self {
542            Ok(value)
543        } else {
544            Err(())
545        }
546    }
547}
548
549#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Hash, bytes_kman::Bytes)]
550pub enum TypeTag {
551    U8,
552    U16,
553    U32,
554    U64,
555    U128,
556    USize,
557
558    I8,
559    I16,
560    I32,
561    I64,
562    I128,
563    ISize,
564
565    F32,
566    F64,
567
568    Bool,
569
570    String,
571    Url,
572    Path,
573    HashMapSS,
574    HashMapS(Box<TypeTag>),
575    FileOrData,
576
577    Any,
578
579    CustomEnum(CustomEnum),
580    AdvancedEnum(AdvanceEnum),
581
582    Vec(Box<TypeTag>),
583    Bytes,
584
585    None,
586}
587
588impl Display for TypeTag {
589    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
590        f.write_str(match self {
591            TypeTag::U8 => "u8",
592            TypeTag::U16 => "u16",
593            TypeTag::U32 => "u32",
594            TypeTag::U64 => "u64",
595            TypeTag::U128 => "u128",
596            TypeTag::USize => "usize",
597            TypeTag::I8 => "i8",
598            TypeTag::I16 => "i16",
599            TypeTag::I32 => "i32",
600            TypeTag::I64 => "i64",
601            TypeTag::I128 => "i128",
602            TypeTag::ISize => "isize",
603            TypeTag::F32 => "f32",
604            TypeTag::F64 => "f64",
605            TypeTag::Bool => "bool",
606            TypeTag::String => "string",
607            TypeTag::Url => "url",
608            TypeTag::Path => "path",
609            TypeTag::HashMapSS => "hashmap_string_string",
610            TypeTag::HashMapS(h) => return write!(f, "hashmap_string({h})"),
611            TypeTag::FileOrData => "file_or_data",
612            TypeTag::Any => "any",
613            TypeTag::CustomEnum(_) => "custom_enum",
614            TypeTag::AdvancedEnum(_) => "advanced_enum",
615            TypeTag::Vec(v) => return write!(f, "vec({v})"),
616            TypeTag::Bytes => "bytes",
617            TypeTag::None => "none",
618        })
619    }
620}
621
622#[derive(Debug, Clone, Serialize, Deserialize, Hash, bytes_kman::Bytes)]
623pub enum TypeValidation {
624    Range(usize, usize),
625}
muzzman_lib/types.rs

muzzman_lib/
types.rs
