reflectx/dynamic/
sequence.rs1use std::sync::Arc;
2
3use crate::TypeOf;
4
5pub 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}