rc_vec/
trait_impls.rs

1use alloc::{boxed::Box, rc::Rc, sync::Arc, vec::Vec};
2use core::{
3    borrow::{Borrow, BorrowMut},
4    fmt::{self, Debug},
5    hash::{self, Hash},
6    ops::{Index, IndexMut},
7    ptr,
8    slice::SliceIndex,
9};
10use rc_vec_proc_macro::rc_impl_gen_arc_impl;
11use unique_rc::{UniqArc, UniqRc};
12
13use crate::{ArcVec, RcVec};
14
15mod into_iter;
16
17#[rc_impl_gen_arc_impl]
18impl<T> AsRef<Self> for RcVec<T> {
19    fn as_ref(&self) -> &Self {
20        self
21    }
22}
23
24#[rc_impl_gen_arc_impl]
25impl<T> AsMut<Self> for RcVec<T> {
26    fn as_mut(&mut self) -> &mut Self {
27        self
28    }
29}
30
31#[rc_impl_gen_arc_impl]
32impl<T> AsRef<[T]> for RcVec<T> {
33    fn as_ref(&self) -> &[T] {
34        self
35    }
36}
37
38#[rc_impl_gen_arc_impl]
39impl<T> AsMut<[T]> for RcVec<T> {
40    fn as_mut(&mut self) -> &mut [T] {
41        self
42    }
43}
44
45#[rc_impl_gen_arc_impl]
46impl<T> Borrow<[T]> for RcVec<T> {
47    fn borrow(&self) -> &[T] {
48        self
49    }
50}
51
52#[rc_impl_gen_arc_impl]
53impl<T> BorrowMut<[T]> for RcVec<T> {
54    fn borrow_mut(&mut self) -> &mut [T] {
55        self
56    }
57}
58
59#[rc_impl_gen_arc_impl]
60impl<T: Clone> From<&[T]> for RcVec<T> {
61    fn from(value: &[T]) -> Self {
62        let uniq_rc: UniqRc<[T]> = UniqRc::from(value);
63        Self::from(uniq_rc)
64    }
65}
66
67#[rc_impl_gen_arc_impl]
68impl<T: Clone> From<&mut [T]> for RcVec<T> {
69    fn from(value: &mut [T]) -> Self {
70        let uniq_rc: UniqRc<[T]> = UniqRc::from(value);
71        Self::from(uniq_rc)
72    }
73}
74
75#[rc_impl_gen_arc_impl]
76impl<T: Clone> From<Rc<[T]>> for RcVec<T> {
77    fn from(value: Rc<[T]>) -> Self {
78        let uniq_rc = UniqRc::from(value);
79        Self::from(uniq_rc)
80    }
81}
82
83#[rc_impl_gen_arc_impl]
84impl From<UniqRc<str>> for RcVec<u8> {
85    fn from(value: UniqRc<str>) -> Self {
86        let len = value.len();
87        let rc = UniqRc::into_raw(value).cast::<u8>();
88        let slice = ptr::slice_from_raw_parts_mut(rc, len);
89        let value = unsafe { UniqRc::from_raw_unchecked(slice) };
90        value.into()
91    }
92}
93
94#[rc_impl_gen_arc_impl]
95impl From<Rc<str>> for RcVec<u8> {
96    fn from(value: Rc<str>) -> Self {
97        UniqRc::new(value).into()
98    }
99}
100
101#[rc_impl_gen_arc_impl]
102impl<T, const N: usize> From<[T; N]> for RcVec<T> {
103    fn from(value: [T; N]) -> Self {
104        Self::from_iter(value)
105    }
106}
107
108#[rc_impl_gen_arc_impl]
109impl<T> FromIterator<T> for RcVec<T> {
110    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
111        let iter = iter.into_iter();
112        let mut buf = Self::with_capacity(iter.size_hint().0);
113        buf.extend(iter);
114        buf
115    }
116}
117
118#[rc_impl_gen_arc_impl]
119impl<T> Extend<T> for RcVec<T> {
120    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
121        let iter = iter.into_iter();
122        self.reserve(iter.size_hint().0);
123        iter.for_each(|value| self.push(value));
124    }
125}
126
127#[rc_impl_gen_arc_impl]
128impl<'a, T: Copy> Extend<&'a T> for RcVec<T> {
129    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
130        self.extend(iter.into_iter().copied());
131    }
132}
133
134#[rc_impl_gen_arc_impl]
135impl<T> From<RcVec<T>> for Rc<[T]> {
136    fn from(value: RcVec<T>) -> Self {
137        value.into_rc_slice()
138    }
139}
140
141// 这将产生分配和拷贝
142#[rc_impl_gen_arc_impl]
143impl<T> From<RcVec<T>> for Box<[T]> {
144    fn from(value: RcVec<T>) -> Self {
145        let len = value.len();
146        let raw = value.into_raw_vec();
147        Box::from_iter(raw.slice()[..len].iter().map(|value| {
148            unsafe { value.assume_init_read() }
149        }))
150    }
151}
152
153#[rc_impl_gen_arc_impl]
154impl From<&str> for RcVec<u8> {
155    fn from(value: &str) -> Self {
156        let uniq_rc: UniqRc<str> = UniqRc::from(value);
157        let len = uniq_rc.len();
158        let str_ptr = UniqRc::into_raw(uniq_rc);
159        let uniq_rc = unsafe {
160            let slice_ptr = ptr::slice_from_raw_parts_mut(
161                str_ptr.cast::<u8>(),
162                len,
163            );
164            UniqRc::from_raw_unchecked(slice_ptr)
165        };
166        Self::from(uniq_rc)
167    }
168}
169
170#[rc_impl_gen_arc_impl]
171impl<T: Eq> Eq for RcVec<T> {}
172
173#[rc_impl_gen_arc_impl]
174impl<T: PartialEq> PartialEq for RcVec<T> {
175    fn eq(&self, other: &Self) -> bool {
176        **self == **other
177    }
178}
179
180#[rc_impl_gen_arc_impl]
181impl<T: PartialEq> PartialEq<[T]> for RcVec<T> {
182    fn eq(&self, other: &[T]) -> bool {
183        **self == *other
184    }
185}
186
187#[rc_impl_gen_arc_impl]
188impl<T: PartialEq> PartialEq<RcVec<T>> for Vec<T> {
189    fn eq(&self, other: &RcVec<T>) -> bool {
190        **self == **other
191    }
192}
193
194#[rc_impl_gen_arc_impl]
195impl<T: PartialEq> PartialEq<Vec<T>> for RcVec<T> {
196    fn eq(&self, other: &Vec<T>) -> bool {
197        **self == **other
198    }
199}
200
201#[rc_impl_gen_arc_impl]
202impl<T: PartialEq, const N: usize> PartialEq<[T; N]> for RcVec<T> {
203    fn eq(&self, other: &[T; N]) -> bool {
204        **self == *other
205    }
206}
207
208#[rc_impl_gen_arc_impl]
209impl<T: PartialEq, const N: usize> PartialEq<&[T; N]> for RcVec<T> {
210    fn eq(&self, other: &&[T; N]) -> bool {
211        **self == **other
212    }
213}
214
215#[rc_impl_gen_arc_impl]
216impl<T: PartialEq, const N: usize> PartialEq<&mut [T; N]> for RcVec<T> {
217    fn eq(&self, other: &&mut [T; N]) -> bool {
218        **self == **other
219    }
220}
221
222#[rc_impl_gen_arc_impl]
223impl<T: PartialEq> PartialEq<&[T]> for RcVec<T> {
224    fn eq(&self, other: &&[T]) -> bool {
225        **self == **other
226    }
227}
228
229#[rc_impl_gen_arc_impl]
230impl<T: PartialEq> PartialEq<&mut [T]> for RcVec<T> {
231    fn eq(&self, other: &&mut [T]) -> bool {
232        **self == **other
233    }
234}
235
236#[rc_impl_gen_arc_impl]
237impl<T: PartialEq> PartialEq<RcVec<T>> for [T] {
238    fn eq(&self, other: &RcVec<T>) -> bool {
239        *self == **other
240    }
241}
242
243#[rc_impl_gen_arc_impl]
244impl<T: PartialEq> PartialEq<RcVec<T>> for &[T] {
245    fn eq(&self, other: &RcVec<T>) -> bool {
246        **self == **other
247    }
248}
249
250#[rc_impl_gen_arc_impl]
251impl<T: PartialEq> PartialEq<RcVec<T>> for &mut [T] {
252    fn eq(&self, other: &RcVec<T>) -> bool {
253        **self == **other
254    }
255}
256
257#[rc_impl_gen_arc_impl]
258impl<T: PartialEq> PartialEq<UniqRc<[T]>> for RcVec<T> {
259    fn eq(&self, other: &UniqRc<[T]>) -> bool {
260        **self == **other
261    }
262}
263
264#[rc_impl_gen_arc_impl]
265impl<T: Debug> Debug for RcVec<T> {
266    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
267        (**self).fmt(f)
268    }
269}
270
271#[rc_impl_gen_arc_impl]
272impl<T: Hash> Hash for RcVec<T> {
273    fn hash<H: hash::Hasher>(&self, state: &mut H) {
274        (**self).hash(state);
275    }
276}
277
278#[rc_impl_gen_arc_impl]
279impl<T: PartialOrd> PartialOrd for RcVec<T> {
280    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
281        (**self).partial_cmp(other)
282    }
283}
284
285#[rc_impl_gen_arc_impl]
286impl<T: Ord> Ord for RcVec<T> {
287    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
288        (**self).cmp(other)
289    }
290}
291
292#[rc_impl_gen_arc_impl]
293impl<T, I: SliceIndex<[T]>> Index<I> for RcVec<T> {
294    type Output = I::Output;
295
296    fn index(&self, index: I) -> &Self::Output {
297        &(**self)[index]
298    }
299}
300
301#[rc_impl_gen_arc_impl]
302impl<T, I: SliceIndex<[T]>> IndexMut<I> for RcVec<T> {
303    fn index_mut(&mut self, index: I) -> &mut Self::Output {
304        &mut (**self)[index]
305    }
306}
307
308#[rc_impl_gen_arc_impl]
309impl<'a, T> IntoIterator for &'a RcVec<T> {
310    type Item = &'a T;
311    type IntoIter = <&'a [T] as IntoIterator>::IntoIter;
312
313    fn into_iter(self) -> Self::IntoIter {
314        (**self).iter()
315    }
316}
317
318#[rc_impl_gen_arc_impl]
319impl<'a, T> IntoIterator for &'a mut RcVec<T> {
320    type Item = &'a mut T;
321    type IntoIter = <&'a mut [T] as IntoIterator>::IntoIter;
322
323    fn into_iter(self) -> Self::IntoIter {
324        (**self).iter_mut()
325    }
326}
327
328#[rc_impl_gen_arc_impl]
329impl<T> IntoIterator for RcVec<T> {
330    type Item = T;
331    type IntoIter = into_iter::RcVecIntoIter<T>;
332
333    fn into_iter(self) -> Self::IntoIter {
334        let len = self.len();
335        into_iter::RcVecIntoIter::new(self.into_raw_vec(), len)
336    }
337}
338
339#[rc_impl_gen_arc_impl]
340impl<T, const N: usize> TryFrom<RcVec<T>> for [T; N] {
341    type Error = RcVec<T>;
342
343    fn try_from(mut vec: RcVec<T>) -> Result<Self, Self::Error> {
344        if vec.len() != N {
345            return Err(vec);
346        }
347
348        unsafe { vec.set_len(0); }
349
350        let ptr = vec.as_ptr().cast::<[T; N]>();
351        let arr = unsafe { ptr.read() };
352        Ok(arr)
353    }
354}
355
356#[rc_impl_gen_arc_impl]
357impl<T, const N: usize> TryFrom<RcVec<T>> for Rc<[T; N]> {
358    type Error = RcVec<T>;
359
360    fn try_from(vec: RcVec<T>) -> Result<Self, Self::Error> {
361        if vec.len() != N {
362            return Err(vec);
363        }
364
365        let slice = Rc::<[T]>::from(vec);
366        Ok(slice.try_into().ok().unwrap())
367    }
368}
369
370#[cfg(feature = "std")]
371#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
372impl std::io::Write for RcVec<u8> {
373    #[inline]
374    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
375        self.extend_from_slice(buf);
376        Ok(buf.len())
377    }
378
379    #[inline]
380    fn write_vectored(&mut self, bufs: &[std::io::IoSlice<'_>]) -> std::io::Result<usize> {
381        let len = bufs.iter().map(|b| b.len()).sum();
382        self.reserve(len);
383        for buf in bufs {
384            self.extend_from_slice(buf);
385        }
386        Ok(len)
387    }
388
389    #[inline]
390    fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
391        self.extend_from_slice(buf);
392        Ok(())
393    }
394
395    #[inline]
396    fn flush(&mut self) -> std::io::Result<()> {
397        Ok(())
398    }
399}
rc_vec/trait_impls.rs

rc_vec/
trait_impls.rs
