/rust/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro2-1.0.103/src/rcvec.rs

Source
use alloc::rc::Rc;
use alloc::vec;
use core::mem;
use core::panic::RefUnwindSafe;
use core::slice;

pub(crate) struct RcVec<T> {
    inner: Rc<Vec<T>>,
}

pub(crate) struct RcVecBuilder<T> {
    inner: Vec<T>,
}

pub(crate) struct RcVecMut<'a, T> {
    inner: &'a mut Vec<T>,
}

#[derive(Clone)]
pub(crate) struct RcVecIntoIter<T> {
    inner: vec::IntoIter<T>,
}

impl<T> RcVec<T> {
    pub(crate) fn is_empty(&self) -> bool {
        self.inner.is_empty()
    }

    pub(crate) fn len(&self) -> usize {
        self.inner.len()
    }

    pub(crate) fn iter(&self) -> slice::Iter<T> {
        self.inner.iter()
    }

    pub(crate) fn make_mut(&mut self) -> RcVecMut<T>
    where
        T: Clone,
    {
        RcVecMut {
            inner: Rc::make_mut(&mut self.inner),
        }
    }

    pub(crate) fn get_mut(&mut self) -> Option<RcVecMut<T>> {
        let inner = Rc::get_mut(&mut self.inner)?;
        Some(RcVecMut { inner })
    }

    pub(crate) fn make_owned(mut self) -> RcVecBuilder<T>
    where
        T: Clone,
    {
        let vec = if let Some(owned) = Rc::get_mut(&mut self.inner) {
            mem::take(owned)
        } else {
            Vec::clone(&self.inner)
        };
        RcVecBuilder { inner: vec }
    }
}

impl<T> RcVecBuilder<T> {
    pub(crate) fn new() -> Self {
        RcVecBuilder { inner: Vec::new() }
    }

    pub(crate) fn with_capacity(cap: usize) -> Self {
        RcVecBuilder {
            inner: Vec::with_capacity(cap),
        }
    }

    pub(crate) fn push(&mut self, element: T) {
        self.inner.push(element);
    }

    pub(crate) fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
        self.inner.extend(iter);
    }

    pub(crate) fn as_mut(&mut self) -> RcVecMut<T> {
        RcVecMut {
            inner: &mut self.inner,
        }
    }

    pub(crate) fn build(self) -> RcVec<T> {
        RcVec {
            inner: Rc::new(self.inner),
        }
    }
}

impl<'a, T> RcVecMut<'a, T> {
    pub(crate) fn push(&mut self, element: T) {
        self.inner.push(element);
    }

    pub(crate) fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
        self.inner.extend(iter);
    }

    pub(crate) fn as_mut(&mut self) -> RcVecMut<T> {
        RcVecMut { inner: self.inner }
    }

    pub(crate) fn take(self) -> RcVecBuilder<T> {
        let vec = mem::take(self.inner);
        RcVecBuilder { inner: vec }
    }
}

impl<T> Clone for RcVec<T> {
    fn clone(&self) -> Self {
        RcVec {
            inner: Rc::clone(&self.inner),
        }
    }
}

impl<T> IntoIterator for RcVecBuilder<T> {
    type Item = T;
    type IntoIter = RcVecIntoIter<T>;

    fn into_iter(self) -> Self::IntoIter {
        RcVecIntoIter {
            inner: self.inner.into_iter(),
        }
    }
}

impl<T> Iterator for RcVecIntoIter<T> {
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.inner.size_hint()
    }
}

impl<T> RefUnwindSafe for RcVec<T> where T: RefUnwindSafe {}

Line	Count	Source
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> {
25	0	pub(crate) fn is_empty(&self) -> bool {
26	0	self.inner.is_empty()
27	0	}
28
29	0	pub(crate) fn len(&self) -> usize {
30	0	self.inner.len()
31	0	}
32
33	0	pub(crate) fn iter(&self) -> slice::Iter<T> {
34	0	self.inner.iter()
35	0	}
36
37	0	pub(crate) fn make_mut(&mut self) -> RcVecMut<T>
38	0	where
39	0	T: Clone,
40		{
41	0	RcVecMut {
42	0	inner: Rc::make_mut(&mut self.inner),
43	0	}
44	0	}
45
46	1.01M	pub(crate) fn get_mut(&mut self) -> Option<RcVecMut<T>> {
47	1.01M	let inner = Rc::get_mut(&mut self.inner)?;
48	1.01M	Some(RcVecMut { inner })
49	1.01M	}
50
51	0	pub(crate) fn make_owned(mut self) -> RcVecBuilder<T>
52	0	where
53	0	T: Clone,
54		{
55	0	let vec = if let Some(owned) = Rc::get_mut(&mut self.inner) {
56	0	mem::take(owned)
57		} else {
58	0	Vec::clone(&self.inner)
59		};
60	0	RcVecBuilder { inner: vec }
61	0	}
62		}
63
64		impl<T> RcVecBuilder<T> {
65	8.98M	pub(crate) fn new() -> Self {
66	8.98M	RcVecBuilder { inner: Vec::new() }
67	8.98M	}
68
69	11.1k	pub(crate) fn with_capacity(cap: usize) -> Self {
70	11.1k	RcVecBuilder {
71	11.1k	inner: Vec::with_capacity(cap),
72	11.1k	}
73	11.1k	}
74
75	11.1M	pub(crate) fn push(&mut self, element: T) {
76	11.1M	self.inner.push(element);
77	11.1M	}
78
79	0	pub(crate) fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
80	0	self.inner.extend(iter);
81	0	}
82
83	0	pub(crate) fn as_mut(&mut self) -> RcVecMut<T> {
84	0	RcVecMut {
85	0	inner: &mut self.inner,
86	0	}
87	0	}
88
89	516k	pub(crate) fn build(self) -> RcVec<T> {
90	516k	RcVec {
91	516k	inner: Rc::new(self.inner),
92	516k	}
93	516k	}
94		}
95
96		impl<'a, T> RcVecMut<'a, T> {
97	0	pub(crate) fn push(&mut self, element: T) {
98	0	self.inner.push(element);
99	0	}
100
101	0	pub(crate) fn extend(&mut self, iter: impl IntoIterator<Item = T>) {
102	0	self.inner.extend(iter);
103	0	}
104
105	0	pub(crate) fn as_mut(&mut self) -> RcVecMut<T> {
106	0	RcVecMut { inner: self.inner }
107	0	}
108
109	1.01M	pub(crate) fn take(self) -> RcVecBuilder<T> {
110	1.01M	let vec = mem::take(self.inner);
111	1.01M	RcVecBuilder { inner: vec }
112	1.01M	}
113		}
114
115		impl<T> Clone for RcVec<T> {
116	0	fn clone(&self) -> Self {
117	0	RcVec {
118	0	inner: Rc::clone(&self.inner),
119	0	}
120	0	}
121		}
122
123		impl<T> IntoIterator for RcVecBuilder<T> {
124		type Item = T;
125		type IntoIter = RcVecIntoIter<T>;
126
127	1.01M	fn into_iter(self) -> Self::IntoIter {
128	1.01M	RcVecIntoIter {
129	1.01M	inner: self.inner.into_iter(),
130	1.01M	}
131	1.01M	}
132		}
133
134		impl<T> Iterator for RcVecIntoIter<T> {
135		type Item = T;
136
137	8.67M	fn next(&mut self) -> Option<Self::Item> {
138	8.67M	self.inner.next()
139	8.67M	}
140
141	0	fn size_hint(&self) -> (usize, Option<usize>) {
142	0	self.inner.size_hint()
143	0	}
144		}
145
146		impl<T> RefUnwindSafe for RcVec<T> where T: RefUnwindSafe {}

Coverage Report

Created: 2025-12-14 06:12