offset_vec/vec_like/pointers_impl/
unique_rc_impl.rs1use unique_rc::{UniqArc, UniqRc};
2use super::*;
3
4impl<V: VecLike> VecLike for UniqRc<V> {
5 type Elem = V::Elem;
6 type Slice = V::Slice;
7 type Collection = V::Collection;
8 type Drain<'a> = V::Drain<'a> where Self: 'a;
9
10 #[inline]
11 fn len(&self) -> usize {
12 (**self).len()
13 }
14
15 #[inline]
16 fn is_empty(&self) -> bool {
17 (**self).is_empty()
18 }
19
20 fn as_slice(&self) -> &Self::Slice {
21 (**self).as_slice()
22 }
23
24 fn as_mut_slice(&mut self) -> &mut Self::Slice {
25 (**self).as_mut_slice()
26 }
27
28 fn as_mut_collection(&mut self) -> &mut Self::Collection {
29 (**self).as_mut_collection()
30 }
31
32 fn capacity(&self) -> usize {
33 (**self).capacity()
34 }
35
36 fn pop(&mut self) -> Option<Self::Elem> {
37 (**self).pop()
38 }
39
40 #[track_caller]
41 fn push(&mut self, value: Self::Elem) {
42 (**self).push(value);
43 }
44
45 #[track_caller]
46 fn remove(&mut self, index: usize) -> Self::Elem {
47 (**self).remove(index)
48 }
49
50 #[track_caller]
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<V: VecLikeSolid> VecLikeSolid for UniqRc<V> {
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<V: VecLike> VecLike for UniqArc<V> {
138 type Elem = V::Elem;
139 type Slice = V::Slice;
140 type Collection = V::Collection;
141 type Drain<'a> = V::Drain<'a> 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::Slice {
154 (**self).as_slice()
155 }
156
157 fn as_mut_slice(&mut self) -> &mut Self::Slice {
158 (**self).as_mut_slice()
159 }
160
161 fn as_mut_collection(&mut self) -> &mut Self::Collection {
162 (**self).as_mut_collection()
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 #[track_caller]
184 fn insert(&mut self, index: usize, element: Self::Elem) {
185 (**self).insert(index, element);
186 }
187
188 #[track_caller]
189 fn reserve(&mut self, additional: usize) {
190 (**self).reserve(additional)
191 }
192
193 #[track_caller]
194 fn reserve_exact(&mut self, additional: usize) {
195 (**self).reserve_exact(additional)
196 }
197
198 #[track_caller]
199 fn shrink_to(&mut self, min_capacity: usize) {
200 (**self).shrink_to(min_capacity)
201 }
202
203 #[track_caller]
204 fn shrink_to_fit(&mut self) {
205 (**self).shrink_to_fit()
206 }
207
208 fn truncate(&mut self, len: usize) {
209 (**self).truncate(len);
210 }
211
212 #[track_caller]
213 fn split_off(&mut self, at: usize) -> Self::Collection {
214 (**self).split_off(at)
215 }
216
217 #[track_caller]
218 fn resize(&mut self, new_len: usize, value: Self::Elem)
219 where Self::Elem: Clone,
220 {
221 (**self).resize(new_len, value);
222 }
223
224 #[track_caller]
225 fn resize_with<F>(&mut self, new_len: usize, f: F)
226 where F: FnMut() -> Self::Elem,
227 {
228 (**self).resize_with(new_len, f);
229 }
230
231 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
232 where R: RangeBounds<usize>,
233 {
234 (**self).drain(range)
235 }
236
237 fn clear(&mut self) {
238 (**self).clear();
239 }
240
241 #[track_caller]
242 fn append(&mut self, other: &mut Self::Collection) {
243 (**self).append(other);
244 }
245}
246impl<V: VecLikeSolid> VecLikeSolid for UniqArc<V> {
247 fn swap_remove(&mut self, index: usize) -> Self::Elem {
248 (**self).swap_remove(index)
249 }
250
251 fn retain<F>(&mut self, f: F)
252 where F: FnMut(&Self::Elem) -> bool,
253 {
254 (**self).retain(f);
255 }
256
257 fn retain_mut<F>(&mut self, f: F)
258 where F: FnMut(&mut Self::Elem) -> bool,
259 {
260 (**self).retain_mut(f);
261 }
262
263 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
264 where F: FnOnce(&mut Self::Elem) -> bool,
265 {
266 (**self).pop_if(predicate)
267 }
268}