offset_vec/vec_like/
smallstr_impl.rs

1use core::{iter::{repeat_n, repeat_with}, ops::{Bound, Range, RangeBounds}};
2use smallstr::SmallString;
3use smallvec::Array;
4use super::*;
5
6mod drain;
7use drain::*;
8
9impl<A: Array<Item = u8>> VecLike for SmallString<A> {
10    type Elem = char;
11    type Slice = str;
12    type Collection = Self;
13    type Drain<'a> = Drain<'a, A> where A: 'a;
14
15    #[inline]
16    fn len(&self) -> usize {
17        self.len()
18    }
19
20    #[inline]
21    fn is_empty(&self) -> bool {
22        self.is_empty()
23    }
24
25    fn as_slice(&self) -> &Self::Slice {
26        self
27    }
28
29    fn as_mut_slice(&mut self) -> &mut Self::Slice {
30        self
31    }
32
33    fn as_mut_collection(&mut self) -> &mut Self::Collection {
34        self
35    }
36
37    fn capacity(&self) -> usize {
38        self.capacity()
39    }
40
41    fn pop(&mut self) -> Option<Self::Elem> {
42        self.pop()
43    }
44
45    #[track_caller]
46    fn push(&mut self, ch: Self::Elem) {
47        self.push(ch);
48    }
49
50    #[track_caller]
51    fn remove(&mut self, idx: usize) -> Self::Elem {
52        self.remove(idx)
53    }
54
55    #[track_caller]
56    fn insert(&mut self, idx: usize, ch: Self::Elem) {
57        self.insert(idx, ch);
58    }
59
60    #[track_caller]
61    fn reserve(&mut self, additional: usize) {
62        self.reserve(additional)
63    }
64
65    #[track_caller]
66    fn reserve_exact(&mut self, additional: usize) {
67        self.reserve_exact(additional)
68    }
69
70    #[track_caller]
71    fn shrink_to_fit(&mut self) {
72        self.shrink_to_fit()
73    }
74
75    fn truncate(&mut self, new_len: usize) {
76        self.truncate(new_len);
77    }
78
79    #[track_caller]
80    fn resize(&mut self, new_len: usize, value: Self::Elem)
81    where Self::Elem: Clone,
82    {
83        let len = self.len();
84        if new_len > len {
85            self.extend(repeat_n(value, new_len-len));
86        } else {
87            self.truncate(new_len);
88        }
89    }
90
91    #[track_caller]
92    fn resize_with<F>(&mut self, new_len: usize, f: F)
93    where F: FnMut() -> Self::Elem,
94    {
95        let len = self.len();
96        if new_len > len {
97            self.extend(repeat_with(f).take(new_len-len));
98        } else {
99            self.truncate(new_len);
100        }
101    }
102
103    #[track_caller]
104    fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
105    where R: RangeBounds<usize>,
106    {
107        let start = match range.start_bound() {
108            Bound::Included(&n) => n,
109            Bound::Excluded(&n) => n.checked_add(1).unwrap(),
110            Bound::Unbounded => 0,
111        };
112        let end = match range.end_bound() {
113            Bound::Included(&n) => n.checked_add(1).unwrap(),
114            Bound::Excluded(&n) => n,
115            Bound::Unbounded => self.len(),
116        };
117        let range = Range { start, end };
118        let _ = self.as_str()[range.clone()];
119        let bytes = unsafe { self.as_mut_vec() };
120        Drain { inner: bytes.drain(range) }
121    }
122
123    fn clear(&mut self) {
124        self.clear();
125    }
126
127    #[track_caller]
128    fn append(&mut self, other: &mut Self::Collection) {
129        self.push_str(other)
130    }
131}
132impl<A: Array<Item = u8>> VecLikeAbstract for SmallString<A> {
133    type Indices<'a> = core::str::CharIndices<'a> where A: 'a;
134
135    fn retain<F>(&mut self, f: F)
136    where F: FnMut(Self::Elem) -> bool,
137    {
138        self.retain(f);
139    }
140
141    fn elem_indices(&self) -> Self::Indices<'_> {
142        self.char_indices()
143    }
144}
offset_vec/vec_like/smallstr_impl.rs

offset_vec/vec_like/
smallstr_impl.rs
