1use alloc::{borrow::{Cow, ToOwned}, boxed::Box, rc::Rc, sync::Arc};
2use super::*;
3
4#[cfg(feature = "unique-rc")]
5#[cfg_attr(docsrs, doc(cfg(feature = "unique-rc")))]
6mod unique_rc_impl;
7
8impl<V: VecLike> VecLike for &mut V {
9 type Elem = V::Elem;
10 type Slice = V::Slice;
11 type Collection = V::Collection;
12 type Drain<'a> = V::Drain<'a> where Self: 'a;
13
14 #[inline]
15 fn len(&self) -> usize {
16 (**self).len()
17 }
18
19 #[inline]
20 fn is_empty(&self) -> bool {
21 (**self).is_empty()
22 }
23
24 fn as_slice(&self) -> &Self::Slice {
25 (**self).as_slice()
26 }
27
28 fn as_mut_slice(&mut self) -> &mut Self::Slice {
29 (**self).as_mut_slice()
30 }
31
32 fn as_mut_collection(&mut self) -> &mut Self::Collection {
33 (**self).as_mut_collection()
34 }
35
36 fn capacity(&self) -> usize {
37 (**self).capacity()
38 }
39
40 fn pop(&mut self) -> Option<Self::Elem> {
41 (**self).pop()
42 }
43
44 #[track_caller]
45 fn push(&mut self, value: Self::Elem) {
46 (**self).push(value);
47 }
48
49 #[track_caller]
50 fn remove(&mut self, index: usize) -> Self::Elem {
51 (**self).remove(index)
52 }
53
54 #[track_caller]
55 fn insert(&mut self, index: usize, element: Self::Elem) {
56 (**self).insert(index, element);
57 }
58
59 #[track_caller]
60 fn reserve(&mut self, additional: usize) {
61 (**self).reserve(additional)
62 }
63
64 #[track_caller]
65 fn reserve_exact(&mut self, additional: usize) {
66 (**self).reserve_exact(additional)
67 }
68
69 #[track_caller]
70 fn shrink_to(&mut self, min_capacity: usize) {
71 (**self).shrink_to(min_capacity)
72 }
73
74 #[track_caller]
75 fn shrink_to_fit(&mut self) {
76 (**self).shrink_to_fit()
77 }
78
79 fn truncate(&mut self, len: usize) {
80 (**self).truncate(len);
81 }
82
83 #[track_caller]
84 fn split_off(&mut self, at: usize) -> Self::Collection {
85 (**self).split_off(at)
86 }
87
88 #[track_caller]
89 fn resize(&mut self, new_len: usize, value: Self::Elem)
90 where Self::Elem: Clone,
91 {
92 (**self).resize(new_len, value);
93 }
94
95 #[track_caller]
96 fn resize_with<F>(&mut self, new_len: usize, f: F)
97 where F: FnMut() -> Self::Elem,
98 {
99 (**self).resize_with(new_len, f);
100 }
101
102 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
103 where R: RangeBounds<usize>,
104 {
105 (**self).drain(range)
106 }
107
108 fn clear(&mut self) {
109 (**self).clear();
110 }
111
112 #[track_caller]
113 fn append(&mut self, other: &mut Self::Collection) {
114 (**self).append(other);
115 }
116}
117impl<V: VecLikeSolid> VecLikeSolid for &mut V {
118 fn swap_remove(&mut self, index: usize) -> Self::Elem {
119 (**self).swap_remove(index)
120 }
121
122 fn retain<F>(&mut self, f: F)
123 where F: FnMut(&Self::Elem) -> bool,
124 {
125 (**self).retain(f);
126 }
127
128 fn retain_mut<F>(&mut self, f: F)
129 where F: FnMut(&mut Self::Elem) -> bool,
130 {
131 (**self).retain_mut(f);
132 }
133
134 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
135 where F: FnOnce(&mut Self::Elem) -> bool,
136 {
137 (**self).pop_if(predicate)
138 }
139}
140
141impl<V: VecLike> VecLike for Box<V> {
142 type Elem = V::Elem;
143 type Slice = V::Slice;
144 type Collection = V::Collection;
145 type Drain<'a> = V::Drain<'a> where Self: 'a;
146
147 #[inline]
148 fn len(&self) -> usize {
149 (**self).len()
150 }
151
152 #[inline]
153 fn is_empty(&self) -> bool {
154 (**self).is_empty()
155 }
156
157 fn as_slice(&self) -> &Self::Slice {
158 (**self).as_slice()
159 }
160
161 fn as_mut_slice(&mut self) -> &mut Self::Slice {
162 (**self).as_mut_slice()
163 }
164
165 fn as_mut_collection(&mut self) -> &mut Self::Collection {
166 (**self).as_mut_collection()
167 }
168
169 fn capacity(&self) -> usize {
170 (**self).capacity()
171 }
172
173 fn pop(&mut self) -> Option<Self::Elem> {
174 (**self).pop()
175 }
176
177 #[track_caller]
178 fn push(&mut self, value: Self::Elem) {
179 (**self).push(value);
180 }
181
182 #[track_caller]
183 fn remove(&mut self, index: usize) -> Self::Elem {
184 (**self).remove(index)
185 }
186
187 #[track_caller]
188 fn insert(&mut self, index: usize, element: Self::Elem) {
189 (**self).insert(index, element);
190 }
191
192 #[track_caller]
193 fn reserve(&mut self, additional: usize) {
194 (**self).reserve(additional)
195 }
196
197 #[track_caller]
198 fn reserve_exact(&mut self, additional: usize) {
199 (**self).reserve_exact(additional)
200 }
201
202 #[track_caller]
203 fn shrink_to(&mut self, min_capacity: usize) {
204 (**self).shrink_to(min_capacity)
205 }
206
207 #[track_caller]
208 fn shrink_to_fit(&mut self) {
209 (**self).shrink_to_fit()
210 }
211
212 fn truncate(&mut self, len: usize) {
213 (**self).truncate(len);
214 }
215
216 #[track_caller]
217 fn split_off(&mut self, at: usize) -> Self::Collection {
218 (**self).split_off(at)
219 }
220
221 #[track_caller]
222 fn resize(&mut self, new_len: usize, value: Self::Elem)
223 where Self::Elem: Clone,
224 {
225 (**self).resize(new_len, value);
226 }
227
228 #[track_caller]
229 fn resize_with<F>(&mut self, new_len: usize, f: F)
230 where F: FnMut() -> Self::Elem,
231 {
232 (**self).resize_with(new_len, f);
233 }
234
235 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
236 where R: RangeBounds<usize>,
237 {
238 (**self).drain(range)
239 }
240
241 fn clear(&mut self) {
242 (**self).clear();
243 }
244
245 #[track_caller]
246 fn append(&mut self, other: &mut Self::Collection) {
247 (**self).append(other);
248 }
249}
250impl<V: VecLikeSolid> VecLikeSolid for Box<V> {
251 fn swap_remove(&mut self, index: usize) -> Self::Elem {
252 (**self).swap_remove(index)
253 }
254
255 fn retain<F>(&mut self, f: F)
256 where F: FnMut(&Self::Elem) -> bool,
257 {
258 (**self).retain(f);
259 }
260
261 fn retain_mut<F>(&mut self, f: F)
262 where F: FnMut(&mut Self::Elem) -> bool,
263 {
264 (**self).retain_mut(f);
265 }
266
267 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
268 where F: FnOnce(&mut Self::Elem) -> bool,
269 {
270 (**self).pop_if(predicate)
271 }
272}
273
274impl<V: VecLike + Clone> VecLike for Rc<V> {
275 type Elem = V::Elem;
276 type Slice = V::Slice;
277 type Collection = V::Collection;
278 type Drain<'a> = V::Drain<'a> where Self: 'a;
279
280 #[inline]
281 fn len(&self) -> usize {
282 (**self).len()
283 }
284
285 #[inline]
286 fn is_empty(&self) -> bool {
287 (**self).is_empty()
288 }
289
290 fn as_slice(&self) -> &Self::Slice {
291 (**self).as_slice()
292 }
293
294 fn as_mut_slice(&mut self) -> &mut Self::Slice {
295 Self::make_mut(self).as_mut_slice()
296 }
297
298 fn as_mut_collection(&mut self) -> &mut Self::Collection {
299 Self::make_mut(self).as_mut_collection()
300 }
301
302 fn capacity(&self) -> usize {
303 (**self).capacity()
304 }
305
306 fn pop(&mut self) -> Option<Self::Elem> {
307 Self::make_mut(self).pop()
308 }
309
310 #[track_caller]
311 fn push(&mut self, value: Self::Elem) {
312 Self::make_mut(self).push(value);
313 }
314
315 #[track_caller]
316 fn remove(&mut self, index: usize) -> Self::Elem {
317 Self::make_mut(self).remove(index)
318 }
319
320 #[track_caller]
321 fn insert(&mut self, index: usize, element: Self::Elem) {
322 Self::make_mut(self).insert(index, element);
323 }
324
325 #[track_caller]
326 fn reserve(&mut self, additional: usize) {
327 Self::make_mut(self).reserve(additional)
328 }
329
330 #[track_caller]
331 fn reserve_exact(&mut self, additional: usize) {
332 Self::make_mut(self).reserve_exact(additional)
333 }
334
335 #[track_caller]
336 fn shrink_to(&mut self, min_capacity: usize) {
337 Self::make_mut(self).shrink_to(min_capacity)
338 }
339
340 #[track_caller]
341 fn shrink_to_fit(&mut self) {
342 Self::make_mut(self).shrink_to_fit()
343 }
344
345 fn truncate(&mut self, len: usize) {
346 Self::make_mut(self).truncate(len);
347 }
348
349 #[track_caller]
350 fn split_off(&mut self, at: usize) -> Self::Collection {
351 Self::make_mut(self).split_off(at)
352 }
353
354 #[track_caller]
355 fn resize(&mut self, new_len: usize, value: Self::Elem)
356 where Self::Elem: Clone,
357 {
358 Self::make_mut(self).resize(new_len, value);
359 }
360
361 #[track_caller]
362 fn resize_with<F>(&mut self, new_len: usize, f: F)
363 where F: FnMut() -> Self::Elem,
364 {
365 Self::make_mut(self).resize_with(new_len, f);
366 }
367
368 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
369 where R: RangeBounds<usize>,
370 {
371 Self::make_mut(self).drain(range)
372 }
373
374 fn clear(&mut self) {
375 Self::make_mut(self).clear();
376 }
377
378 #[track_caller]
379 fn append(&mut self, other: &mut Self::Collection) {
380 Self::make_mut(self).append(other);
381 }
382}
383impl<V: VecLikeSolid + Clone> VecLikeSolid for Rc<V> {
384 fn swap_remove(&mut self, index: usize) -> Self::Elem {
385 Self::make_mut(self).swap_remove(index)
386 }
387
388 fn retain<F>(&mut self, f: F)
389 where F: FnMut(&Self::Elem) -> bool,
390 {
391 Self::make_mut(self).retain(f);
392 }
393
394 fn retain_mut<F>(&mut self, f: F)
395 where F: FnMut(&mut Self::Elem) -> bool,
396 {
397 Self::make_mut(self).retain_mut(f);
398 }
399
400 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
401 where F: FnOnce(&mut Self::Elem) -> bool,
402 {
403 Self::make_mut(self).pop_if(predicate)
404 }
405}
406
407impl<V: VecLike + Clone> VecLike for Arc<V> {
408 type Elem = V::Elem;
409 type Slice = V::Slice;
410 type Collection = V::Collection;
411 type Drain<'a> = V::Drain<'a> where Self: 'a;
412
413 #[inline]
414 fn len(&self) -> usize {
415 (**self).len()
416 }
417
418 #[inline]
419 fn is_empty(&self) -> bool {
420 (**self).is_empty()
421 }
422
423 fn as_slice(&self) -> &Self::Slice {
424 (**self).as_slice()
425 }
426
427 fn as_mut_slice(&mut self) -> &mut Self::Slice {
428 Self::make_mut(self).as_mut_slice()
429 }
430
431 fn as_mut_collection(&mut self) -> &mut Self::Collection {
432 Self::make_mut(self).as_mut_collection()
433 }
434
435 fn capacity(&self) -> usize {
436 (**self).capacity()
437 }
438
439 fn pop(&mut self) -> Option<Self::Elem> {
440 Self::make_mut(self).pop()
441 }
442
443 #[track_caller]
444 fn push(&mut self, value: Self::Elem) {
445 Self::make_mut(self).push(value);
446 }
447
448 #[track_caller]
449 fn remove(&mut self, index: usize) -> Self::Elem {
450 Self::make_mut(self).remove(index)
451 }
452
453 #[track_caller]
454 fn insert(&mut self, index: usize, element: Self::Elem) {
455 Self::make_mut(self).insert(index, element);
456 }
457
458 #[track_caller]
459 fn reserve(&mut self, additional: usize) {
460 Self::make_mut(self).reserve(additional)
461 }
462
463 #[track_caller]
464 fn reserve_exact(&mut self, additional: usize) {
465 Self::make_mut(self).reserve_exact(additional)
466 }
467
468 #[track_caller]
469 fn shrink_to(&mut self, min_capacity: usize) {
470 Self::make_mut(self).shrink_to(min_capacity)
471 }
472
473 #[track_caller]
474 fn shrink_to_fit(&mut self) {
475 Self::make_mut(self).shrink_to_fit()
476 }
477
478 fn truncate(&mut self, len: usize) {
479 Self::make_mut(self).truncate(len);
480 }
481
482 #[track_caller]
483 fn split_off(&mut self, at: usize) -> Self::Collection {
484 Self::make_mut(self).split_off(at)
485 }
486
487 #[track_caller]
488 fn resize(&mut self, new_len: usize, value: Self::Elem)
489 where Self::Elem: Clone,
490 {
491 Self::make_mut(self).resize(new_len, value);
492 }
493
494 #[track_caller]
495 fn resize_with<F>(&mut self, new_len: usize, f: F)
496 where F: FnMut() -> Self::Elem,
497 {
498 Self::make_mut(self).resize_with(new_len, f);
499 }
500
501 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
502 where R: RangeBounds<usize>,
503 {
504 Self::make_mut(self).drain(range)
505 }
506
507 fn clear(&mut self) {
508 Self::make_mut(self).clear();
509 }
510
511 #[track_caller]
512 fn append(&mut self, other: &mut Self::Collection) {
513 Self::make_mut(self).append(other);
514 }
515}
516impl<V: VecLikeSolid + Clone> VecLikeSolid for Arc<V> {
517 fn swap_remove(&mut self, index: usize) -> Self::Elem {
518 Self::make_mut(self).swap_remove(index)
519 }
520
521 fn retain<F>(&mut self, f: F)
522 where F: FnMut(&Self::Elem) -> bool,
523 {
524 Self::make_mut(self).retain(f);
525 }
526
527 fn retain_mut<F>(&mut self, f: F)
528 where F: FnMut(&mut Self::Elem) -> bool,
529 {
530 Self::make_mut(self).retain_mut(f);
531 }
532
533 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
534 where F: FnOnce(&mut Self::Elem) -> bool,
535 {
536 Self::make_mut(self).pop_if(predicate)
537 }
538}
539
540impl<S> VecLike for Cow<'_, S>
541where S: ToOwned + Slice,
542 S::Owned: VecLike<Slice = S>,
543{
544 type Elem = <S::Owned as VecLike>::Elem;
545 type Slice = <S::Owned as VecLike>::Slice;
546 type Collection = <S::Owned as VecLike>::Collection;
547 type Drain<'a> = <S::Owned as VecLike>::Drain<'a> where Self: 'a;
548
549 #[inline]
550 fn len(&self) -> usize {
551 (**self).len()
552 }
553
554 #[inline]
555 fn is_empty(&self) -> bool {
556 (**self).is_empty()
557 }
558
559 fn as_slice(&self) -> &Self::Slice {
560 self
561 }
562
563 fn as_mut_slice(&mut self) -> &mut Self::Slice {
564 self.to_mut().as_mut_slice()
565 }
566
567 fn as_mut_collection(&mut self) -> &mut Self::Collection {
568 self.to_mut().as_mut_collection()
569 }
570
571 fn capacity(&self) -> usize {
572 match self {
573 Cow::Borrowed(slice) => slice.len(),
574 Cow::Owned(owned) => owned.capacity(),
575 }
576 }
577
578 fn pop(&mut self) -> Option<Self::Elem> {
579 self.to_mut().pop()
580 }
581
582 #[track_caller]
583 fn push(&mut self, value: Self::Elem) {
584 self.to_mut().push(value);
585 }
586
587 #[track_caller]
588 fn remove(&mut self, index: usize) -> Self::Elem {
589 self.to_mut().remove(index)
590 }
591
592 #[track_caller]
593 fn insert(&mut self, index: usize, element: Self::Elem) {
594 self.to_mut().insert(index, element);
595 }
596
597 #[track_caller]
598 fn reserve(&mut self, additional: usize) {
599 self.to_mut().reserve(additional)
600 }
601
602 #[track_caller]
603 fn reserve_exact(&mut self, additional: usize) {
604 self.to_mut().reserve_exact(additional)
605 }
606
607 #[track_caller]
608 fn shrink_to(&mut self, min_capacity: usize) {
609 self.to_mut().shrink_to(min_capacity)
610 }
611
612 #[track_caller]
613 fn shrink_to_fit(&mut self) {
614 self.to_mut().shrink_to_fit()
615 }
616
617 fn truncate(&mut self, len: usize) {
618 self.to_mut().truncate(len);
619 }
620
621 #[track_caller]
622 fn split_off(&mut self, at: usize) -> Self::Collection {
623 self.to_mut().split_off(at)
624 }
625
626 #[track_caller]
627 fn resize(&mut self, new_len: usize, value: Self::Elem)
628 where Self::Elem: Clone,
629 {
630 self.to_mut().resize(new_len, value);
631 }
632
633 #[track_caller]
634 fn resize_with<F>(&mut self, new_len: usize, f: F)
635 where F: FnMut() -> Self::Elem,
636 {
637 self.to_mut().resize_with(new_len, f);
638 }
639
640 fn drain<R>(&mut self, range: R) -> Self::Drain<'_>
641 where R: RangeBounds<usize>,
642 {
643 self.to_mut().drain(range)
644 }
645
646 fn clear(&mut self) {
647 self.to_mut().clear();
648 }
649
650 #[track_caller]
651 fn append(&mut self, other: &mut Self::Collection) {
652 self.to_mut().append(other);
653 }
654}
655impl<S> VecLikeSolid for Cow<'_, S>
656where S: ToOwned + Slice,
657 S::Owned: VecLikeSolid<Slice = S>,
658{
659 fn swap_remove(&mut self, index: usize) -> Self::Elem {
660 self.to_mut().swap_remove(index)
661 }
662
663 fn retain<F>(&mut self, f: F)
664 where F: FnMut(&Self::Elem) -> bool,
665 {
666 self.to_mut().retain(f);
667 }
668
669 fn retain_mut<F>(&mut self, f: F)
670 where F: FnMut(&mut Self::Elem) -> bool,
671 {
672 self.to_mut().retain_mut(f);
673 }
674
675 fn pop_if<F>(&mut self, predicate: F) -> Option<Self::Elem>
676 where F: FnOnce(&mut Self::Elem) -> bool,
677 {
678 self.to_mut().pop_if(predicate)
679 }
680}