offset_vec/vec_like/
smallstr_impl.rs

1use core::{iter::{repeat_n, repeat_with}, ops::{Bound, Range, RangeBounds}};
2use smallstr::{SmallString, DrainRange};
3use smallvec::Array;
4use super::*;
5
6impl<A: Array<Item = u8>> VecLike for SmallString<A> {
7    type Elem = char;
8    type ElemRef<'a> = char where Self: 'a;
9    type Slice = str;
10    type Collection = Self;
11    type Drain<'a> = DrainRange<'a, A> where A: 'a;
12
13    #[inline]
14    fn len(&self) -> usize {
15        self.len()
16    }
17
18    #[inline]
19    fn is_empty(&self) -> bool {
20        self.is_empty()
21    }
22
23    fn as_slice(&self) -> &Self::Slice {
24        self
25    }
26
27    fn as_mut_slice(&mut self) -> &mut Self::Slice {
28        self
29    }
30
31    fn as_mut_collection(&mut self) -> &mut Self::Collection {
32        self
33    }
34
35    fn capacity(&self) -> usize {
36        self.capacity()
37    }
38
39    fn pop(&mut self) -> Option<Self::Elem> {
40        self.pop()
41    }
42
43    #[track_caller]
44    fn push(&mut self, ch: Self::Elem) {
45        self.push(ch);
46    }
47
48    #[track_caller]
49    fn remove(&mut self, idx: usize) -> Self::Elem {
50        self.remove(idx)
51    }
52
53    #[track_caller]
54    fn insert(&mut self, idx: usize, ch: Self::Elem) {
55        self.insert(idx, ch);
56    }
57
58    #[track_caller]
59    fn reserve(&mut self, additional: usize) {
60        self.reserve(additional)
61    }
62
63    #[track_caller]
64    fn reserve_exact(&mut self, additional: usize) {
65        self.reserve_exact(additional)
66    }
67
68    #[track_caller]
69    fn shrink_to_fit(&mut self) {
70        self.shrink_to_fit()
71    }
72
73    fn truncate(&mut self, new_len: usize) {
74        self.truncate(new_len);
75    }
76
77    #[track_caller]
78    fn resize(&mut self, new_len: usize, value: Self::Elem)
79    where Self::Elem: Clone,
80    {
81        let len = self.len();
82        if new_len > len {
83            self.extend(repeat_n(value, new_len-len));
84        } else {
85            self.truncate(new_len);
86        }
87    }
88
89    #[track_caller]
90    fn resize_with<F>(&mut self, new_len: usize, f: F)
91    where F: FnMut() -> Self::Elem,
92    {
93        let len = self.len();
94        if new_len > len {
95            self.extend(repeat_with(f).take(new_len-len));
96        } else {
97            self.truncate(new_len);
98        }
99    }
100
101    // FIXME: Replace to unimplemented smallstr::drain_range
102    #[track_caller]
103    fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
104    where R: RangeBounds<usize>,
105    {
106        let start = match range.start_bound() {
107            Bound::Included(&n) => n,
108            Bound::Excluded(&n) => n.checked_add(1).unwrap(),
109            Bound::Unbounded => 0,
110        };
111        let end = match range.end_bound() {
112            Bound::Included(&n) => n.checked_add(1).unwrap(),
113            Bound::Excluded(&n) => n,
114            Bound::Unbounded => self.len(),
115        };
116        let range = Range { start, end };
117        let _ = self.as_str()[range.clone()];
118        self.drain_range(range)
119    }
120
121    fn clear(&mut self) {
122        self.clear();
123    }
124
125    #[track_caller]
126    fn append(&mut self, other: &mut Self::Collection) {
127        self.push_str(other)
128    }
129
130    fn retain<F>(&mut self, f: F)
131    where F: FnMut(Self::Elem) -> bool,
132    {
133        self.retain(f);
134    }
135}
136
137
138#[cfg(test)]
139mod tests {
140    use alloc::string::String;
141    use smallstr::SmallString;
142    use crate::VecLike;
143
144    #[test]
145    fn test() {
146        let mut s: SmallString<[u8; 0]> = SmallString::from_str("foobar");
147        assert_eq!(s, "foobar");
148        let s1: String = VecLike::drain(&mut s, 1..=3).collect();
149        assert_eq!(s1, "oob");
150        assert_eq!(s, "far");
151    }
152
153    #[test]
154    fn test_rev() {
155        let mut s: SmallString<[u8; 0]> = SmallString::from_str("foobar");
156        assert_eq!(s, "foobar");
157        let s1: String = VecLike::drain(&mut s, 1..=3).rev().collect();
158        assert_eq!(s1, "boo");
159        assert_eq!(s, "far");
160    }
161
162    #[test]
163    fn test_empty() {
164        let mut s: SmallString<[u8; 0]> = SmallString::new();
165        assert_eq!(s, "");
166        let s1: String = VecLike::drain(&mut s, 0..0).collect();
167        assert_eq!(s1, "");
168        assert_eq!(s, "");
169    }
170
171    #[test]
172    fn test_multi_bytes() {
173        let mut s: SmallString<[u8; 0]> = SmallString::from_str("从前有座山");
174        assert_eq!(s, "从前有座山");
175        let s1: String = VecLike::drain(&mut s, 6..12).collect();
176        assert_eq!(s1, "有座");
177        assert_eq!(s, "从前山");
178    }
179
180    #[test]
181    fn test_multi_bytes_rev() {
182        let mut s: SmallString<[u8; 0]> = SmallString::from_str("从前有座山");
183        assert_eq!(s, "从前有座山");
184        let s1: String = VecLike::drain(&mut s, 6..12).rev().collect();
185        assert_eq!(s1, "座有");
186        assert_eq!(s, "从前山");
187    }
188
189    #[test]
190    fn some_consume() {
191        let mut s: SmallString<[u8; 0]> = SmallString::from_str("foobar");
192        assert_eq!(s, "foobar");
193        let ch = VecLike::drain(&mut s, 1..=3).next();
194        assert_eq!(ch, Some('o'));
195        assert_eq!(s, "far");
196    }
197
198    #[test]
199    fn no_consume() {
200        let mut s: SmallString<[u8; 0]> = SmallString::from_str("foobar");
201        assert_eq!(s, "foobar");
202        VecLike::drain(&mut s, 1..=3);
203        assert_eq!(s, "far");
204    }
205
206    #[test]
207    fn size_hint() {
208        let mut s: SmallString<[u8; 0]> = SmallString::from_str("foobar");
209        assert_eq!(s, "foobar");
210        let size_hint = VecLike::drain(&mut s, 1..=3).size_hint();
211        assert_eq!(size_hint, (1, Some(3)));
212    }
213}
offset_vec/vec_like/smallstr_impl.rs

offset_vec/vec_like/
smallstr_impl.rs
