1 use alloc::rc::Rc;
2 use alloc::vec;
3 use core::mem;
4 use core::panic::RefUnwindSafe;
5 use core::slice;
6 
7 pub(crate) struct RcVec<T> {
8     inner: Rc<Vec<T>>,
9 }
10 
11 pub(crate) struct RcVecBuilder<T> {
12     inner: Vec<T>,
13 }
14 
15 pub(crate) struct RcVecMut<'a, T> {
16     inner: &'a mut Vec<T>,
17 }
18 
19 #[derive(Clone)]
20 pub(crate) struct RcVecIntoIter<T> {
21     inner: vec::IntoIter<T>,
22 }
23 
24 impl<T> RcVec<T> {
is_empty(&self) -> bool25     pub fn is_empty(&self) -> bool {
26         self.inner.is_empty()
27     }
28 
len(&self) -> usize29     pub fn len(&self) -> usize {
30         self.inner.len()
31     }
32 
iter(&self) -> slice::Iter<T>33     pub fn iter(&self) -> slice::Iter<T> {
34         self.inner.iter()
35     }
36 
make_mut(&mut self) -> RcVecMut<T> where T: Clone,37     pub fn make_mut(&mut self) -> RcVecMut<T>
38     where
39         T: Clone,
40     {
41         RcVecMut {
42             inner: Rc::make_mut(&mut self.inner),
43         }
44     }
45 
get_mut(&mut self) -> Option<RcVecMut<T>>46     pub fn get_mut(&mut self) -> Option<RcVecMut<T>> {
47         let inner = Rc::get_mut(&mut self.inner)?;
48         Some(RcVecMut { inner })
49     }
50 
make_owned(mut self) -> RcVecBuilder<T> where T: Clone,51     pub fn make_owned(mut self) -> RcVecBuilder<T>
52     where
53         T: Clone,
54     {
55         let vec = if let Some(owned) = Rc::get_mut(&mut self.inner) {
56             mem::take(owned)
57         } else {
58             Vec::clone(&self.inner)
59         };
60         RcVecBuilder { inner: vec }
61     }
62 }
63 
64 impl<T> RcVecBuilder<T> {
new() -> Self65     pub fn new() -> Self {
66         RcVecBuilder { inner: Vec::new() }
67     }
68 
with_capacity(cap: usize) -> Self69     pub fn with_capacity(cap: usize) -> Self {
70         RcVecBuilder {
71             inner: Vec::with_capacity(cap),
72         }
73     }
74 
push(&mut self, element: T)75     pub fn push(&mut self, element: T) {
76         self.inner.push(element);
77     }
78 
extend(&mut self, iter: impl IntoIterator<Item = T>)79     pub fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
80         self.inner.extend(iter);
81     }
82 
as_mut(&mut self) -> RcVecMut<T>83     pub fn as_mut(&mut self) -> RcVecMut<T> {
84         RcVecMut {
85             inner: &mut self.inner,
86         }
87     }
88 
build(self) -> RcVec<T>89     pub fn build(self) -> RcVec<T> {
90         RcVec {
91             inner: Rc::new(self.inner),
92         }
93     }
94 }
95 
96 impl<'a, T> RcVecMut<'a, T> {
push(&mut self, element: T)97     pub fn push(&mut self, element: T) {
98         self.inner.push(element);
99     }
100 
extend(&mut self, iter: impl IntoIterator<Item = T>)101     pub fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
102         self.inner.extend(iter);
103     }
104 
pop(&mut self) -> Option<T>105     pub fn pop(&mut self) -> Option<T> {
106         self.inner.pop()
107     }
108 
as_mut(&mut self) -> RcVecMut<T>109     pub fn as_mut(&mut self) -> RcVecMut<T> {
110         RcVecMut { inner: self.inner }
111     }
112 }
113 
114 impl<T> Clone for RcVec<T> {
clone(&self) -> Self115     fn clone(&self) -> Self {
116         RcVec {
117             inner: Rc::clone(&self.inner),
118         }
119     }
120 }
121 
122 impl<T> IntoIterator for RcVecBuilder<T> {
123     type Item = T;
124     type IntoIter = RcVecIntoIter<T>;
125 
into_iter(self) -> Self::IntoIter126     fn into_iter(self) -> Self::IntoIter {
127         RcVecIntoIter {
128             inner: self.inner.into_iter(),
129         }
130     }
131 }
132 
133 impl<T> Iterator for RcVecIntoIter<T> {
134     type Item = T;
135 
next(&mut self) -> Option<Self::Item>136     fn next(&mut self) -> Option<Self::Item> {
137         self.inner.next()
138     }
139 
size_hint(&self) -> (usize, Option<usize>)140     fn size_hint(&self) -> (usize, Option<usize>) {
141         self.inner.size_hint()
142     }
143 }
144 
145 impl<T> RefUnwindSafe for RcVec<T> where T: RefUnwindSafe {}
146