rc_vec/
rc_vec.rs

1#[cfg(doc)]
2use alloc::{boxed::Box, vec::Vec};
3
4use alloc::{rc::Rc, sync::Arc};
5use core::{
6    cmp::max,
7    iter,
8    mem::MaybeUninit,
9    ops::{Deref, DerefMut, RangeBounds},
10    ptr, slice,
11};
12use rc_vec_proc_macro::rc_impl_gen_arc_impl;
13use unique_rc::{UniqArc, UniqRc};
14
15use crate::{
16    raw::{ArcRawVec, RcRawVec},
17    utils,
18};
19
20/// [`RcVec`] based on [`Rc`] and can be converted from Rc without allocation,
21/// just like [`Box`] is converted to [`Vec`]
22///
23/// # Examples
24///
25/// ```
26/// # use std::rc::Rc;
27/// use rc_vec::RcVec;
28///
29/// let rc: Rc<[i32]> = Rc::new([1, 2, 3]);
30/// let mut rc_vec = RcVec::from(rc);
31///
32/// assert_eq!(rc_vec, [1, 2, 3]);
33/// rc_vec.push(4);
34/// assert_eq!(rc_vec, [1, 2, 3, 4]);
35/// ```
36#[rc_impl_gen_arc_impl]
37pub struct RcVec<T> {
38    raw: RcRawVec<T>,
39    len: usize,
40}
41
42#[rc_impl_gen_arc_impl]
43impl<T> Deref for RcVec<T> {
44    type Target = [T];
45
46    fn deref(&self) -> &Self::Target {
47        let ptr = self.raw.as_ptr();
48        unsafe { slice::from_raw_parts(ptr, self.len) }
49    }
50}
51
52#[rc_impl_gen_arc_impl]
53impl<T> DerefMut for RcVec<T> {
54    fn deref_mut(&mut self) -> &mut Self::Target {
55        let ptr = self.raw.as_mut_ptr();
56        unsafe { slice::from_raw_parts_mut(ptr, self.len) }
57    }
58}
59
60#[rc_impl_gen_arc_impl]
61impl<T> Drop for RcVec<T> {
62    fn drop(&mut self) {
63        self.raw.drop_elems(self.len);
64    }
65}
66
67#[rc_impl_gen_arc_impl]
68impl<T> From<UniqRc<[T]>> for RcVec<T> {
69    fn from(value: UniqRc<[T]>) -> Self {
70        let len = value.len();
71        let raw = RcRawVec::from_uniq_slice(value);
72        Self { raw, len }
73    }
74}
75
76#[rc_impl_gen_arc_impl]
77impl<T> Default for RcVec<T> {
78    fn default() -> Self {
79        Self::new()
80    }
81}
82
83#[rc_impl_gen_arc_impl]
84impl<T> RcVec<T> {
85    /// Create a new [`RcVec`]
86    ///
87    /// # Examples
88    ///
89    /// ```
90    /// # use rc_vec::RcVec;
91    /// let mut vec = RcVec::new();
92    /// vec.push(3);
93    /// assert_eq!(vec, [3]);
94    /// ```
95    pub fn new() -> Self {
96        Self { raw: RcRawVec::new(), len: 0 }
97    }
98
99    /// Create a new [`RcVec`] Initial capacity of `capacity`
100    ///
101    /// # Examples
102    ///
103    /// ```
104    /// # use rc_vec::RcVec;
105    /// let vec = RcVec::with_capacity(176);
106    /// assert_eq!(vec.capacity(), 176);
107    /// assert_eq!(vec.len(), 0);
108    /// # assert_ne!(vec, [1]);
109    /// ```
110    pub fn with_capacity(capacity: usize) -> Self {
111        Self { raw: RcRawVec::with_capacity(capacity), len: 0 }
112    }
113
114    /// Readonly permission pointer
115    #[inline]
116    pub fn as_ptr(&self) -> *const T {
117        self.raw.as_ptr()
118    }
119
120    /// Read and Write permission pointer
121    ///
122    /// # Examples
123    ///
124    /// ```
125    /// # use rc_vec::rc_vec;
126    /// let mut vec = rc_vec![1, 2, 3];
127    /// assert_eq!(vec, [1, 2, 3]);
128    /// unsafe { *vec.as_mut_ptr() += 1 }
129    /// assert_eq!(vec, [2, 2, 3]);
130    /// ```
131    #[inline]
132    pub fn as_mut_ptr(&mut self) -> *mut T {
133        self.raw.as_mut_ptr()
134    }
135
136    /// Get initialized datas count
137    ///
138    /// # Examples
139    ///
140    /// ```
141    /// # use rc_vec::RcVec;
142    /// let mut vec = RcVec::with_capacity(4);
143    /// assert_eq!(vec.capacity(), 4);
144    ///
145    /// vec.push(2333);
146    ///
147    /// assert_eq!(vec.len(), 1);
148    /// assert_eq!(vec.capacity(), 4);
149    /// ```
150    #[inline]
151    pub fn len(&self) -> usize {
152        self.len
153    }
154
155    /// Like `.len() == 0`
156    #[inline]
157    pub fn is_empty(&self) -> bool {
158        self.len() == 0
159    }
160
161    /// Get allocated capacity
162    ///
163    /// # Examples
164    ///
165    /// ```
166    /// # use rc_vec::RcVec;
167    /// let vec = RcVec::with_capacity(176);
168    /// assert_eq!(vec.capacity(), 176);
169    /// assert_eq!(vec.len(), 0);
170    /// # assert_ne!(vec, [1]);
171    /// ```
172    #[inline]
173    pub fn capacity(&self) -> usize {
174        self.raw.capacity()
175    }
176
177    #[inline]
178    pub fn push(&mut self, value: T) {
179        if self.len == self.capacity() {
180            self.raw.reserve_for_push(self.len);
181        }
182
183        unsafe {
184            let end = self.as_mut_ptr().add(self.len);
185            end.write(value);
186            self.len += 1;
187        }
188    }
189
190    pub fn reserve(&mut self, additional: usize) {
191        self.raw.reserve(self.len, additional);
192    }
193
194    pub fn reserve_exact(&mut self, additional: usize) {
195        self.raw.reserve_exact(self.len, additional);
196    }
197
198    #[inline]
199    pub fn pop(&mut self) -> Option<T> {
200        if self.len == 0 {
201            None
202        } else {
203            unsafe {
204                self.len -= 1;
205                Some(self.as_ptr().add(self.len).read())
206            }
207        }
208    }
209
210    #[inline]
211    #[track_caller]
212    pub fn remove(&mut self, index: usize) -> T {
213        fn assert_failed(index: usize, len: usize) -> ! {
214            panic!("remove index (is {index}) should be < len (is {len})")
215        }
216
217        let len = self.len();
218        if index >= len {
219            assert_failed(index, len);
220        }
221
222        unsafe {
223            let ret;
224            {
225                let ptr = self.as_mut_ptr().add(index);
226                ret = ptr.read();
227                ptr::copy(ptr.add(1), ptr, len - index - 1);
228            }
229            self.set_len(len - 1);
230            ret
231        }
232    }
233
234    #[inline]
235    #[track_caller]
236    pub fn swap_remove(&mut self, index: usize) -> T {
237        fn assert_failed(index: usize, len: usize) -> ! {
238            panic!("swap_remove index (is {index}) should be < len (is {len})")
239        }
240
241        let len = self.len();
242        if index >= len {
243            assert_failed(index, len);
244        }
245
246        unsafe {
247            let value = self.as_ptr().add(index).read();
248            let ptr = self.as_mut_ptr();
249            ptr.add(index).copy_from(ptr.add(len-1), 1);
250            self.set_len(len-1);
251            value
252        }
253    }
254
255    /// Reallocate to remove excess capacity
256    ///
257    /// # Examples
258    ///
259    /// ```
260    /// # use rc_vec::RcVec;
261    /// let mut vec = RcVec::with_capacity(16);
262    /// vec.push(233);
263    /// assert_eq!(vec.len(), 1);
264    /// assert_eq!(vec.capacity(), 16);
265    ///
266    /// vec.shrink_to_fit();
267    /// assert_eq!(vec.len(), 1);
268    /// assert_eq!(vec.capacity(), 1);
269    /// ```
270    pub fn shrink_to_fit(&mut self) {
271        if self.capacity() > self.len() {
272            self.raw.shrink_to_fit(self.len());
273        }
274    }
275
276    /// Reallocate to max(`min_capacity`, `.len()`)
277    pub fn shrink_to(&mut self, min_capacity: usize) {
278        if self.capacity() > min_capacity {
279            self.raw.shrink_to_fit(max(self.len(), min_capacity));
280        }
281    }
282
283    /// Like [`Vec::set_len`]
284    ///
285    /// # Safety
286    /// See [`Vec::set_len`] for safety concerns and examples.
287    #[inline]
288    pub unsafe fn set_len(&mut self, new_len: usize) {
289        self.len = new_len;
290    }
291
292    /// Like [`Vec::spare_capacity_mut`]
293    ///
294    /// # Examples
295    ///
296    /// ```
297    /// # use rc_vec::RcVec;
298    /// # use std::mem::MaybeUninit;
299    /// let mut vec = RcVec::with_capacity(4);
300    ///
301    /// vec.push(0);
302    /// assert_eq!(*vec, [0]);
303    ///
304    /// let spare = vec.spare_capacity_mut();
305    /// assert_eq!(spare.len(), 3);
306    /// spare[0] = MaybeUninit::new(1);
307    /// assert_eq!(*vec, [0]);
308    ///
309    /// unsafe {
310    ///     // SAFETY: The initialized data has been written to spare
311    ///     vec.set_len(vec.len() + 1);
312    /// }
313    /// assert_eq!(*vec, [0, 1]);
314    /// ```
315    #[inline]
316    pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>] {
317        &mut self.raw.slice_mut()[self.len..]
318    }
319
320    unsafe fn split_at_spare_mut_with_len(
321        &mut self,
322    ) -> (&mut [T], &mut [MaybeUninit<T>], &mut usize) {
323        let (initialized, spare)
324            = self.raw.slice_mut().split_at_mut(self.len);
325        let initialized_ptr = initialized.as_mut_ptr().cast::<T>();
326        let initialized = slice::from_raw_parts_mut(initialized_ptr, self.len);
327
328        (initialized, spare, &mut self.len)
329    }
330
331    /// # Safety
332    /// `slice` `0..len` must be initialized
333    #[inline]
334    pub unsafe fn from_raw_uniq_slice(
335        slice: UniqRc<[MaybeUninit<T>]>,
336        len: usize,
337    ) -> Self {
338        Self { raw: RcRawVec::from_raw_uniq_slice(slice), len }
339    }
340
341    pub fn from_uniq_slice(slice: UniqRc<[T]>) -> Self {
342        slice.into()
343    }
344
345    #[inline]
346    pub fn into_raw_uniq_slice(mut self) -> UniqRc<[MaybeUninit<T>]> {
347        self.raw.take().into_rc()
348    }
349
350    #[inline]
351    pub fn into_raw_uniq_slice_optional(mut self) -> Option<UniqRc<[MaybeUninit<T>]>> {
352        self.raw.take().into_raw_rc()
353    }
354
355    #[inline]
356    pub fn into_uniq_slice(mut self) -> UniqRc<[T]> {
357        self.shrink_to_fit();
358        let len = self.len();
359        debug_assert_eq!(len, self.capacity());
360
361        let raw = UniqRc::into_raw(self.raw.take().into_rc());
362        let slice = ptr::slice_from_raw_parts_mut(raw.cast::<T>(), len);
363        unsafe { UniqRc::from_raw_unchecked(slice) }
364    }
365
366    #[inline]
367    pub fn into_rc_slice(self) -> Rc<[T]> {
368        self.into_uniq_slice().into()
369    }
370
371    #[inline]
372    pub(crate) fn into_raw_vec(mut self) -> RcRawVec<T> {
373        self.raw.take()
374    }
375
376    pub fn truncate(&mut self, len: usize) {
377        let old_len = self.len();
378
379        // NOTE: use `>`, reference from Vec::truncate
380        if len > old_len {
381            return;
382        }
383
384        unsafe {
385            self.set_len(len);
386            self.raw.drop_elems_from_range(len..old_len);
387        }
388    }
389
390    #[inline]
391    pub fn clear(&mut self) {
392        let old_len = self.len();
393        unsafe {
394            self.set_len(0);
395            self.raw.drop_elems(old_len);
396        }
397    }
398
399    pub fn resize_with<F>(&mut self, new_len: usize, f: F)
400    where F: FnMut() -> T,
401    {
402        let len = self.len();
403
404        if new_len > len {
405            self.extend(iter::repeat_with(f).take(new_len-len));
406        } else {
407            self.truncate(len);
408        }
409    }
410
411    pub fn leak(mut self) -> &'static mut [T] {
412        let len = self.len();
413
414        if len == 0 {
415            return Default::default();
416        }
417
418        self.raw.take()
419            .into_raw_rc()
420            .map(UniqRc::into_raw)
421            .map(|raw| {
422                unsafe { slice::from_raw_parts_mut(raw.cast::<T>(), len) }
423            })
424            .unwrap_or_default()
425    }
426
427    pub fn iter(&self) -> slice::Iter<'_, T> {
428        self.into_iter()
429    }
430
431    pub fn iter_mut(&mut self) -> slice::IterMut<'_, T> {
432        self.into_iter()
433    }
434}
435
436#[rc_impl_gen_arc_impl]
437impl<T: Clone> RcVec<T> {
438    pub fn resize(&mut self, new_len: usize, value: T) {
439        let len = self.len();
440
441        if new_len > len {
442            self.extend(iter::repeat_n(value, new_len-len));
443        } else {
444            self.truncate(len);
445        }
446    }
447
448    pub fn extend_from_slice(&mut self, buf: &[T]) {
449        self.reserve(buf.len());
450
451        for ele in buf {
452            let len = self.len();
453            let ele = ele.clone();
454
455            unsafe {
456                self.as_mut_ptr().add(len).write(ele);
457                self.set_len(len + 1);
458            }
459        }
460    }
461
462    pub fn extend_from_within<R>(&mut self, src: R)
463    where R: RangeBounds<usize>,
464    {
465        let range = utils::range(src, ..self.len());
466        self.reserve(range.len());
467
468        let (this, spare, len) = unsafe {
469            self.split_at_spare_mut_with_len()
470        };
471
472        let to_clone = unsafe { this.get_unchecked(range) };
473
474        to_clone.iter().zip(spare)
475            .map(|(src, dst)| dst.write(src.clone()))
476            .for_each(|_| *len += 1);
477    }
478}
479
480#[rc_impl_gen_arc_impl]
481impl<T> RcVec<T> {
482    /// Macro support
483    #[doc(hidden)]
484    #[allow(unused)]
485    pub fn from_elem(elem: T, len: usize) -> Self
486    where T: Clone,
487    {
488        Self::from_iter(iter::repeat_n(elem, len))
489    }
490
491    /// Macro support
492    #[doc(hidden)]
493    #[allow(unused)]
494    pub fn from_array<const N: usize>(arr: [T; N]) -> Self {
495        arr.into()
496    }
497}
rc_vec/rc_vec.rs

rc_vec/
rc_vec.rs
