Skip to main content

reflectx/dynamic/
sequence.rs

1use std::sync::Arc;
2
3use crate::TypeOf;
4
5/// ## Sequence
6///
7/// implemented by types that
8/// can reflect their value/type and that
9/// of their individual index's in a sequence
10pub trait Sequence: crate::Dyn {
11    fn len(&self) -> usize;
12    fn index(&self, i: usize) -> crate::Value;
13    fn index_ref(&self, _: usize) -> &crate::Value {
14        unimplemented!()
15    }
16}
17
18impl dyn Sequence {
19    pub fn downcast_ref<T: std::any::Any>(&self) -> Option<&T> {
20        let value: &dyn std::any::Any = self;
21        return value.downcast_ref::<T>();
22    }
23
24    pub fn downcast_mut<T: std::any::Any>(&mut self) -> Option<&mut T> {
25        let value: &mut dyn std::any::Any = self;
26        return value.downcast_mut::<T>();
27    }
28
29    pub fn is<T: std::any::Any>(&self) -> bool {
30        let value: &dyn std::any::Any = self;
31        return value.is::<T>();
32    }
33}
34
35#[cfg(feature = "serde")]
36impl serde::Serialize for dyn Sequence {
37    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
38    where
39        S: serde::Serializer,
40    {
41        use serde::ser::SerializeSeq;
42
43        let ty = self.to_type().to_slice();
44        let mut ser = serializer.serialize_seq(ty.capacity())?;
45
46        for i in 0..self.len() {
47            ser.serialize_element(&self.index(i))?;
48        }
49
50        return ser.end();
51    }
52}
53
54impl std::fmt::Display for dyn Sequence {
55    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56        write!(f, "[")?;
57
58        for i in 0..self.len() {
59            write!(f, "\n\t{}", self.index(i))?;
60        }
61
62        return write!(f, "\n]");
63    }
64}
65
66impl<T: Clone + Sequence> Sequence for Arc<T> {
67    fn len(&self) -> usize {
68        return self.as_ref().len();
69    }
70
71    fn index(&self, i: usize) -> crate::Value {
72        return self.as_ref().index(i);
73    }
74}
75
76impl<T> crate::TypeOf for Vec<T> {
77    fn type_of() -> crate::Type {
78        return crate::StructType::new()
79            .with_path(&crate::Path::from("std::vec"))
80            .with_name("Vec")
81            .with_visibility(crate::Visibility::Public(crate::Public::Full))
82            .with_generics(&crate::Generics::from([crate::TypeParam::new()
83                .with_name("T")
84                .build()
85                .to_generic()]))
86            .build()
87            .to_type();
88    }
89}
90
91impl<T> crate::ToType for Vec<T> {
92    fn to_type(&self) -> crate::Type {
93        return Vec::<T>::type_of();
94    }
95}
96
97impl<T> crate::ToValue for Vec<T>
98where
99    T: Clone + crate::TypeOf + crate::AsValue,
100{
101    fn to_value(self) -> crate::Value {
102        return crate::Value::Slice(crate::Slice {
103            ty: crate::SliceType {
104                ty: Box::new(T::type_of()),
105                capacity: None,
106            },
107            value: self.iter().map(|v| v.as_value()).collect::<Vec<_>>(),
108        });
109    }
110}
111
112impl<T> crate::AsValue for Vec<T>
113where
114    T: Clone + crate::TypeOf + crate::AsValue,
115{
116    fn as_value(&self) -> crate::Value {
117        return crate::Value::Slice(crate::Slice {
118            ty: crate::SliceType {
119                ty: Box::new(T::type_of()),
120                capacity: None,
121            },
122            value: self.iter().map(|v| v.as_value()).collect::<Vec<_>>(),
123        });
124    }
125}
126
127impl<T> crate::Sequence for Vec<T>
128where
129    T: Clone + std::fmt::Debug + crate::TypeOf + crate::AsValue + 'static,
130{
131    fn len(&self) -> usize {
132        return self.len();
133    }
134
135    fn index(&self, i: usize) -> crate::Value {
136        return match self.get(i) {
137            None => crate::Value::Null,
138            Some(v) => v.as_value().index(i),
139        };
140    }
141}