bytes_kman/std/
ops.rs

1use crate::{TBuffer, TBytes};
2
3impl<T: TBytes> TBytes for ::std::ops::Range<T> {
4    fn size(&self) -> usize {
5        self.end.size() + self.end.size()
6    }
7
8    fn to_bytes(&self) -> Vec<u8> {
9        let mut buffer = Vec::with_capacity(self.size());
10
11        buffer.append(&mut self.start.to_bytes());
12        buffer.append(&mut self.end.to_bytes());
13
14        buffer
15    }
16
17    fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
18    where
19        Self: Sized,
20    {
21        let start = T::from_bytes(buffer);
22        let end = T::from_bytes(buffer);
23
24        if let Some(start) = start {
25            if let Some(end) = end {
26                Some(start..end)
27            } else {
28                let mut bytes = start.to_bytes();
29                while let Some(byte) = bytes.pop() {
30                    buffer.insert(0, byte)
31                }
32                None
33            }
34        } else {
35            None
36        }
37    }
38}
39
40impl<T: TBytes> TBytes for ::std::ops::RangeInclusive<T> {
41    fn size(&self) -> usize {
42        self.start().size() + self.end().size()
43    }
44
45    fn to_bytes(&self) -> Vec<u8> {
46        let mut buffer = Vec::with_capacity(self.size());
47
48        buffer.append(&mut self.start().to_bytes());
49        buffer.append(&mut self.end().to_bytes());
50
51        buffer
52    }
53
54    fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
55    where
56        Self: Sized,
57    {
58        let start = T::from_bytes(buffer);
59        let end = T::from_bytes(buffer);
60
61        if let Some(start) = start {
62            if let Some(end) = end {
63                Some(start..=end)
64            } else {
65                let mut bytes = start.to_bytes();
66                while let Some(byte) = bytes.pop() {
67                    buffer.insert(0, byte)
68                }
69                None
70            }
71        } else {
72            None
73        }
74    }
75}
76
77impl<T: TBytes> TBytes for ::std::ops::RangeToInclusive<T> {
78    fn size(&self) -> usize {
79        self.end.size()
80    }
81
82    fn to_bytes(&self) -> Vec<u8> {
83        self.end.to_bytes()
84    }
85
86    fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
87    where
88        Self: Sized,
89    {
90        let end = T::from_bytes(buffer)?;
91        Some(..=end)
92    }
93}
94
95impl TBytes for ::std::ops::RangeFull {
96    fn size(&self) -> usize {
97        0
98    }
99
100    fn to_bytes(&self) -> Vec<u8> {
101        Vec::new()
102    }
103
104    fn from_bytes(_: &mut TBuffer) -> Option<Self>
105    where
106        Self: Sized,
107    {
108        Some(..)
109    }
110}
111
112impl<T: TBytes> TBytes for ::std::ops::RangeTo<T> {
113    fn size(&self) -> usize {
114        self.end.size()
115    }
116
117    fn to_bytes(&self) -> Vec<u8> {
118        self.end.to_bytes()
119    }
120
121    fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
122    where
123        Self: Sized,
124    {
125        let end = T::from_bytes(buffer)?;
126        Some(..end)
127    }
128}
129
130impl<T: TBytes> TBytes for ::std::ops::RangeFrom<T> {
131    fn size(&self) -> usize {
132        self.start.size()
133    }
134
135    fn to_bytes(&self) -> Vec<u8> {
136        self.start.to_bytes()
137    }
138
139    fn from_bytes(buffer: &mut TBuffer) -> Option<Self>
140    where
141        Self: Sized,
142    {
143        let start = T::from_bytes(buffer)?;
144        Some(start..)
145    }
146}
147
148#[cfg(test)]
149mod test {
150    use std::ops::{Range, RangeFrom, RangeInclusive, RangeTo, RangeToInclusive};
151
152    use crate::TBytes;
153
154    #[test]
155    fn range() {
156        let a = 13..21;
157
158        let mut bytes = a.to_bytes();
159
160        let b = <Range<i32>>::from_bytes(&mut bytes).unwrap();
161
162        assert_eq!(a, b)
163    }
164
165    #[test]
166    fn range_incomplete() {
167        let mut buffer = Vec::new();
168        buffer.append(&mut 50usize.to_bytes());
169
170        let clone_buffer = buffer.clone();
171
172        let other_buffer = Range::<usize>::from_bytes(&mut buffer);
173        if let Some(other_buffer) = other_buffer {
174            panic!("This should be possible! Other buffer: {other_buffer:?}");
175        }
176
177        assert_eq!(buffer, clone_buffer);
178        buffer.append(&mut 100usize.to_bytes());
179
180        let value = Range::<usize>::from_bytes(&mut buffer).unwrap();
181        assert_eq!(value, 50..100)
182    }
183
184    #[test]
185    fn range_to() {
186        let a = ..21;
187
188        let mut bytes = a.to_bytes();
189
190        let b = <RangeTo<i32>>::from_bytes(&mut bytes).unwrap();
191
192        assert_eq!(a, b)
193    }
194
195    #[test]
196    fn range_from() {
197        let a = 21..;
198
199        let mut bytes = a.to_bytes();
200
201        let b = <RangeFrom<i32>>::from_bytes(&mut bytes).unwrap();
202
203        assert_eq!(a, b)
204    }
205
206    #[test]
207    fn range_inclusive() {
208        let a = 6..=21;
209
210        let mut bytes = a.to_bytes();
211
212        let b = <RangeInclusive<i32>>::from_bytes(&mut bytes).unwrap();
213
214        assert_eq!(a, b)
215    }
216
217    #[test]
218    fn range_inclusive_incomplete() {
219        let mut buffer = Vec::new();
220        buffer.append(&mut 50usize.to_bytes());
221
222        let clone_buffer = buffer.clone();
223
224        let other_buffer = RangeInclusive::<usize>::from_bytes(&mut buffer);
225        if let Some(other_buffer) = other_buffer {
226            panic!("This should be possible! Other buffer: {other_buffer:?}");
227        }
228
229        assert_eq!(buffer, clone_buffer);
230        buffer.append(&mut 100usize.to_bytes());
231
232        let value = RangeInclusive::<usize>::from_bytes(&mut buffer).unwrap();
233        assert_eq!(value, 50..=100)
234    }
235
236    #[test]
237    fn range_to_inclusive() {
238        let a = ..=23;
239
240        let mut bytes = a.to_bytes();
241
242        let b = <RangeToInclusive<i32>>::from_bytes(&mut bytes).unwrap();
243
244        assert_eq!(a, b)
245    }
246}
bytes_kman/std/ops.rs

bytes_kman/std/
ops.rs
