nson/
array.rs

1use std::fmt;
2use std::ops::{Deref, DerefMut};
3use std::iter::FromIterator;
4use std::convert::Into;
5use std::io::{Write, Read, Cursor};
6
7use crate::value::Value;
8use crate::message::Message;
9use crate::message_id::MessageId;
10use crate::encode::{encode_array, encode_value, write_u32, EncodeResult};
11use crate::decode::{decode_array, DecodeResult};
12
13#[derive(Clone, PartialEq, Default, Eq)]
14pub struct Array {
15    inner: Vec<Value>
16}
17
18impl Array {
19    pub fn new() -> Array {
20        Array {
21            inner: Vec::new()
22        }
23    }
24
25    pub fn with_capacity(capacity: usize) -> Array {
26        Array {
27            inner: Vec::with_capacity(capacity)
28        }
29    }
30
31    pub fn from_vec(vec: Vec<Value>) -> Array {
32        Array {
33            inner: vec
34        }
35    }
36
37    pub fn len(&self) -> usize {
38        self.inner.len()
39    }
40
41    pub fn is_empty(&self) -> bool {
42        self.inner.is_empty()
43    }
44
45    pub fn push(&mut self, value: impl Into<Value>) {
46        self.inner.push(value.into());
47    }
48
49    pub fn push_value(&mut self, value: Value) {
50        self.inner.push(value);
51    }
52
53    pub fn inner(&self) -> &Vec<Value> {
54        &self.inner
55    }
56
57    pub fn as_mut_inner(&mut self) -> &mut Vec<Value> {
58        &mut self.inner
59    }
60
61    pub fn into_inner(self) -> Vec<Value> {
62        self.inner
63    }
64
65    pub fn iter(&self) -> std::slice::Iter<'_, Value> {
66        self.into_iter()
67    }
68
69    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, Value> {
70        self.into_iter()
71    }
72
73    pub fn encode(&self, writer: &mut impl Write) -> EncodeResult<()> {
74        encode_array(writer, self)
75    }
76
77    pub fn decode(reader: &mut impl Read) -> DecodeResult<Array> {
78        decode_array(reader)
79    }
80
81    pub fn to_bytes(&self) -> EncodeResult<Vec<u8>> {
82        let len = self.bytes_size();
83
84        let mut buf = Vec::with_capacity(len);
85        write_u32(&mut buf, len as u32)?;
86
87        for val in self.iter() {
88            buf.write_all(&[val.element_type() as u8])?;
89
90            encode_value(&mut buf, val)?;
91        }
92
93        buf.write_all(&[0])?;
94
95        Ok(buf)
96    }
97
98    pub fn from_bytes(slice: &[u8]) -> DecodeResult<Array> {
99        let mut reader = Cursor::new(slice);
100        decode_array(&mut reader)
101    }
102
103    pub fn bytes_size(&self) -> usize {
104        4 + self.iter().map(|v| v.bytes_size() + 1).sum::<usize>() + 1
105    }
106}
107
108impl fmt::Debug for Array {
109    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
110        write!(f, "{:?}", self.inner)
111    }
112}
113
114impl Deref for Array {
115    type Target = Vec<Value>;
116    fn deref(&self) -> &Vec<Value> {
117        &self.inner
118    }
119}
120
121impl DerefMut for Array {
122    fn deref_mut(&mut self) -> &mut Vec<Value> {
123        &mut self.inner
124    }
125}
126
127impl AsRef<Vec<Value>> for Array {
128    fn as_ref(&self) -> &Vec<Value> {
129        &self.inner
130    }
131}
132
133macro_rules! array_from_impls {
134    ($($T:ty)+) => {
135        $(
136            impl From<Vec<$T>> for Array {
137                fn from(vec: Vec<$T>) -> Array {
138                    vec.into_iter().map(Into::into).collect()
139                }
140            }
141        )+
142    }
143}
144
145array_from_impls! {
146    f32 f64 i32 i64 u32 u64 &str String &String Array
147    Message bool Vec<u8> Vec<Vec<u8>> MessageId
148}
149
150impl IntoIterator for Array {
151    type Item = Value;
152    type IntoIter = std::vec::IntoIter<Value>;
153
154    fn into_iter(self) -> Self::IntoIter {
155        self.inner.into_iter()
156    }
157}
158
159impl<'a> IntoIterator for &'a Array {
160    type Item = &'a Value;
161    type IntoIter = std::slice::Iter<'a, Value>;
162
163    fn into_iter(self) -> Self::IntoIter {
164        self.inner.iter()
165    }
166}
167
168impl<'a> IntoIterator for &'a mut Array {
169    type Item = &'a mut Value;
170    type IntoIter = std::slice::IterMut<'a, Value>;
171
172    fn into_iter(self) -> Self::IntoIter {
173        self.inner.iter_mut()
174    }
175}
176
177impl FromIterator<Value> for Array {
178    fn from_iter<I: IntoIterator<Item=Value>>(iter: I) -> Self {
179        let mut array = Array::new();
180
181        for i in iter {
182            array.push(i);
183        }
184
185        array
186    }
187}
188
189#[cfg(test)]
190mod test {
191    use crate::Array;
192
193    #[test]
194    fn to_vec() {
195        let mut array = Array::new();
196
197        array.push(123);
198        array.push("haha");
199
200        let vec = array.to_bytes().unwrap();
201
202        let array2 = Array::from_bytes(&vec).unwrap();
203
204        assert_eq!(array, array2);
205    }
206}
nson/array.rs

nson/
array.rs
