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