offset_vec/vec_like/
rc_vec_impl.rs

1use core::ops::RangeBounds;
2use rc_vec::{ArcVec, ArcVecDrain, RcVec, RcVecDrain};
3use super::*;
4
5impl<T> VecLike for RcVec<T> {
6    type Elem = T;
7    type ElemRef<'a> = &'a T where Self: 'a;
8    type Slice = [T];
9    type Collection = RcVec<T>;
10    type Drain<'a> = RcVecDrain<'a, T> where Self: 'a;
11
12    #[inline]
13    fn len(&self) -> usize {
14        self.len()
15    }
16
17    #[inline]
18    fn is_empty(&self) -> bool {
19        self.is_empty()
20    }
21
22    fn as_slice(&self) -> &[Self::Elem] {
23        self
24    }
25
26    fn as_mut_slice(&mut self) -> &mut [Self::Elem] {
27        self
28    }
29
30    fn as_mut_collection(&mut self) -> &mut Self::Collection {
31        self
32    }
33
34    fn capacity(&self) -> usize {
35        self.capacity()
36    }
37
38    fn pop(&mut self) -> Option<Self::Elem> {
39        self.pop()
40    }
41
42    #[track_caller]
43    fn push(&mut self, value: Self::Elem) {
44        self.push(value);
45    }
46
47    #[track_caller]
48    fn remove(&mut self, index: usize) -> Self::Elem {
49        self.remove(index)
50    }
51
52    fn insert(&mut self, index: usize, element: Self::Elem) {
53        self.insert(index, element);
54    }
55
56    #[track_caller]
57    fn reserve(&mut self, additional: usize) {
58        self.reserve(additional)
59    }
60
61    #[track_caller]
62    fn reserve_exact(&mut self, additional: usize) {
63        self.reserve_exact(additional)
64    }
65
66    #[track_caller]
67    fn shrink_to(&mut self, min_capacity: usize) {
68        self.shrink_to(min_capacity)
69    }
70
71    #[track_caller]
72    fn shrink_to_fit(&mut self) {
73        self.shrink_to_fit()
74    }
75
76    fn truncate(&mut self, len: usize) {
77        self.truncate(len);
78    }
79
80    #[track_caller]
81    fn split_off(&mut self, at: usize) -> Self::Collection {
82        self.split_off(at)
83    }
84
85    #[track_caller]
86    fn resize(&mut self, new_len: usize, value: Self::Elem)
87    where Self::Elem: Clone,
88    {
89        self.resize(new_len, value);
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        self.resize_with(new_len, f);
97    }
98
99    fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
100    where R: RangeBounds<usize>,
101    {
102        self.drain(range)
103    }
104
105    fn clear(&mut self) {
106        self.clear();
107    }
108
109    #[track_caller]
110    fn append(&mut self, other: &mut Self::Collection) {
111        self.append(other);
112    }
113
114    fn retain<F>(&mut self, f: F)
115    where F: FnMut(&T) -> bool,
116    {
117        self.retain(f);
118    }
119}
120impl<T> VecLikeSolid for RcVec<T> {
121    fn swap_remove(&mut self, index: usize) -> Self::Elem {
122        self.swap_remove(index)
123    }
124
125    fn retain_mut<F>(&mut self, f: F)
126    where F: FnMut(&mut Self::Elem) -> bool,
127    {
128        self.retain_mut(f);
129    }
130
131    fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
132    where F: FnOnce(&mut Self::Elem) -> bool,
133    {
134        self.pop_if(predicate)
135    }
136}
137
138impl<T> VecLike for ArcVec<T> {
139    type Elem = T;
140    type ElemRef<'a> = &'a T where Self: 'a;
141    type Slice = [T];
142    type Collection = ArcVec<T>;
143    type Drain<'a> = ArcVecDrain<'a, T> where Self: 'a;
144
145    #[inline]
146    fn len(&self) -> usize {
147        self.len()
148    }
149
150    #[inline]
151    fn is_empty(&self) -> bool {
152        self.is_empty()
153    }
154
155    fn as_slice(&self) -> &[Self::Elem] {
156        self
157    }
158
159    fn as_mut_slice(&mut self) -> &mut [Self::Elem] {
160        self
161    }
162
163    fn as_mut_collection(&mut self) -> &mut Self::Collection {
164        self
165    }
166
167    fn capacity(&self) -> usize {
168        self.capacity()
169    }
170
171    fn pop(&mut self) -> Option<Self::Elem> {
172        self.pop()
173    }
174
175    #[track_caller]
176    fn push(&mut self, value: Self::Elem) {
177        self.push(value);
178    }
179
180    #[track_caller]
181    fn remove(&mut self, index: usize) -> Self::Elem {
182        self.remove(index)
183    }
184
185    fn insert(&mut self, index: usize, element: Self::Elem) {
186        self.insert(index, element);
187    }
188
189    #[track_caller]
190    fn reserve(&mut self, additional: usize) {
191        self.reserve(additional)
192    }
193
194    #[track_caller]
195    fn reserve_exact(&mut self, additional: usize) {
196        self.reserve_exact(additional)
197    }
198
199    #[track_caller]
200    fn shrink_to(&mut self, min_capacity: usize) {
201        self.shrink_to(min_capacity)
202    }
203
204    #[track_caller]
205    fn shrink_to_fit(&mut self) {
206        self.shrink_to_fit()
207    }
208
209    fn truncate(&mut self, len: usize) {
210        self.truncate(len);
211    }
212
213    #[track_caller]
214    fn split_off(&mut self, at: usize) -> Self::Collection {
215        self.split_off(at)
216    }
217
218    #[track_caller]
219    fn resize(&mut self, new_len: usize, value: Self::Elem)
220    where Self::Elem: Clone,
221    {
222        self.resize(new_len, value);
223    }
224
225    #[track_caller]
226    fn resize_with<F>(&mut self, new_len: usize, f: F)
227    where F: FnMut() -> Self::Elem,
228    {
229        self.resize_with(new_len, f);
230    }
231
232    fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
233    where R: RangeBounds<usize>,
234    {
235        self.drain(range)
236    }
237
238    fn clear(&mut self) {
239        self.clear();
240    }
241
242    #[track_caller]
243    fn append(&mut self, other: &mut Self::Collection) {
244        self.append(other);
245    }
246
247    fn retain<F>(&mut self, f: F)
248    where F: FnMut(&T) -> bool,
249    {
250        self.retain(f);
251    }
252}
253impl<T> VecLikeSolid for ArcVec<T> {
254    fn swap_remove(&mut self, index: usize) -> Self::Elem {
255        self.swap_remove(index)
256    }
257
258    fn retain_mut<F>(&mut self, f: F)
259    where F: FnMut(&mut Self::Elem) -> bool,
260    {
261        self.retain_mut(f);
262    }
263
264    fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
265    where F: FnOnce(&mut Self::Elem) -> bool,
266    {
267        self.pop_if(predicate)
268    }
269}
offset_vec/vec_like/rc_vec_impl.rs

offset_vec/vec_like/
rc_vec_impl.rs
