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 ElemRef<'a> = V::ElemRef<'a> where Self: 'a;
7 type Slice = V::Slice;
8 type Collection = V::Collection;
9 type Drain<'a> = V::Drain<'a> 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::Slice {
22 (**self).as_slice()
23 }
24
25 fn as_mut_slice(&mut self) -> &mut Self::Slice {
26 (**self).as_mut_slice()
27 }
28
29 fn as_mut_collection(&mut self) -> &mut Self::Collection {
30 (**self).as_mut_collection()
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 #[track_caller]
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(V::ElemRef<'_>) -> bool,
116 {
117 (**self).retain(f);
118 }
119}
120impl<V: VecLikeSolid> VecLikeSolid for UniqRc<V> {
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<V: VecLike> VecLike for UniqArc<V> {
139 type Elem = V::Elem;
140 type ElemRef<'a> = V::ElemRef<'a> where Self: 'a;
141 type Slice = V::Slice;
142 type Collection = V::Collection;
143 type Drain<'a> = V::Drain<'a> 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::Slice {
156 (**self).as_slice()
157 }
158
159 fn as_mut_slice(&mut self) -> &mut Self::Slice {
160 (**self).as_mut_slice()
161 }
162
163 fn as_mut_collection(&mut self) -> &mut Self::Collection {
164 (**self).as_mut_collection()
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 #[track_caller]
186 fn insert(&mut self, index: usize, element: Self::Elem) {
187 (**self).insert(index, element);
188 }
189
190 #[track_caller]
191 fn reserve(&mut self, additional: usize) {
192 (**self).reserve(additional)
193 }
194
195 #[track_caller]
196 fn reserve_exact(&mut self, additional: usize) {
197 (**self).reserve_exact(additional)
198 }
199
200 #[track_caller]
201 fn shrink_to(&mut self, min_capacity: usize) {
202 (**self).shrink_to(min_capacity)
203 }
204
205 #[track_caller]
206 fn shrink_to_fit(&mut self) {
207 (**self).shrink_to_fit()
208 }
209
210 fn truncate(&mut self, len: usize) {
211 (**self).truncate(len);
212 }
213
214 #[track_caller]
215 fn split_off(&mut self, at: usize) -> Self::Collection {
216 (**self).split_off(at)
217 }
218
219 #[track_caller]
220 fn resize(&mut self, new_len: usize, value: Self::Elem)
221 where Self::Elem: Clone,
222 {
223 (**self).resize(new_len, value);
224 }
225
226 #[track_caller]
227 fn resize_with<F>(&mut self, new_len: usize, f: F)
228 where F: FnMut() -> Self::Elem,
229 {
230 (**self).resize_with(new_len, f);
231 }
232
233 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
234 where R: RangeBounds<usize>,
235 {
236 (**self).drain(range)
237 }
238
239 fn clear(&mut self) {
240 (**self).clear();
241 }
242
243 #[track_caller]
244 fn append(&mut self, other: &mut Self::Collection) {
245 (**self).append(other);
246 }
247
248 fn retain<F>(&mut self, f: F)
249 where F: FnMut(V::ElemRef<'_>) -> bool,
250 {
251 (**self).retain(f);
252 }
253}
254impl<V: VecLikeSolid> VecLikeSolid for UniqArc<V> {
255 fn swap_remove(&mut self, index: usize) -> Self::Elem {
256 (**self).swap_remove(index)
257 }
258
259 fn retain_mut<F>(&mut self, f: F)
260 where F: FnMut(&mut Self::Elem) -> bool,
261 {
262 (**self).retain_mut(f);
263 }
264
265 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
266 where F: FnOnce(&mut Self::Elem) -> bool,
267 {
268 (**self).pop_if(predicate)
269 }
270}