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

offset_vec/vec_like/
rc_vec_impl.rs
