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

offset_vec/vec_like/
smallstr_impl.rs
