syn_sem/ds/
vec.rs

1use my_utils::ds::OptVec;
2use std::{
3    fmt::{self, Debug},
4    ops::{Deref, DerefMut},
5};
6
7#[derive(Debug, Clone)]
8pub struct GenOptVec<T> {
9    inner: OptVec<GenValue<T>>,
10    gen_: u64,
11}
12
13impl GenOptVec<()> {
14    const GEN_IGNORE: u64 = 0;
15}
16
17impl<T> GenOptVec<T> {
18    pub fn new() -> Self {
19        Self {
20            inner: OptVec::new(),
21            gen_: 1,
22        }
23    }
24
25    pub fn len(&self) -> usize {
26        // Number of occupied slots
27        self.inner.len()
28    }
29
30    pub fn is_empty(&self) -> bool {
31        self.len() == 0
32    }
33
34    pub fn truncate(&mut self, len: usize) {
35        self.inner.truncate(len);
36    }
37
38    pub fn next_index(&self) -> GenIndex {
39        GenIndex {
40            index: self.inner.next_index(),
41            gen_: self.gen_,
42        }
43    }
44
45    pub fn add(&mut self, value: T) -> GenIndex {
46        let gen_ = self.gen_;
47        self.gen_ += 1;
48
49        let gen_value = GenValue { value, gen_ };
50
51        let index = self.inner.add(gen_value);
52        GenIndex { index, gen_ }
53    }
54
55    pub fn take(&mut self, index: GenIndex) -> Option<T> {
56        let GenIndex {
57            index,
58            gen_: in_gen,
59        } = index;
60        let gv = self.inner.take(index)?;
61
62        if in_gen == gv.gen_ || in_gen == GenOptVec::GEN_IGNORE {
63            Some(gv.value)
64        } else {
65            self.inner.set(index, Some(gv));
66            None
67        }
68    }
69
70    pub fn get(&self, index: GenIndex) -> Option<&T> {
71        let GenIndex {
72            index,
73            gen_: in_gen,
74        } = index;
75        let gv = self.inner.get(index)?;
76
77        if in_gen == gv.gen_ || in_gen == GenOptVec::GEN_IGNORE {
78            Some(&gv.value)
79        } else {
80            None
81        }
82    }
83
84    pub fn get_mut(&mut self, index: GenIndex) -> Option<&mut T> {
85        let GenIndex {
86            index,
87            gen_: in_gen,
88        } = index;
89        let gv = self.inner.get_mut(index)?;
90
91        if in_gen == gv.gen_ || in_gen == GenOptVec::GEN_IGNORE {
92            Some(&mut gv.value)
93        } else {
94            None
95        }
96    }
97}
98
99impl<T> Default for GenOptVec<T> {
100    fn default() -> Self {
101        Self::new()
102    }
103}
104
105#[derive(Debug, Clone)]
106struct GenValue<T> {
107    value: T,
108    gen_: u64,
109}
110
111#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
112pub struct GenIndex {
113    index: usize,
114    gen_: u64,
115}
116
117impl GenIndex {
118    pub const fn ignore_gen(index: usize) -> Self {
119        Self {
120            index,
121            gen_: GenOptVec::GEN_IGNORE,
122        }
123    }
124
125    pub const fn into_inner(self) -> usize {
126        self.index
127    }
128}
129
130#[derive(Default, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)]
131pub struct BoxedSlice<T>(Vec<T>);
132
133impl<T> Deref for BoxedSlice<T> {
134    type Target = [T];
135
136    fn deref(&self) -> &Self::Target {
137        self.0.as_slice()
138    }
139}
140
141impl<T> DerefMut for BoxedSlice<T> {
142    fn deref_mut(&mut self) -> &mut Self::Target {
143        self.0.as_mut_slice()
144    }
145}
146
147impl<T: Debug> Debug for BoxedSlice<T> {
148    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
149        self.0.as_slice().fmt(f)
150    }
151}
152
153impl<Item> FromIterator<Item> for BoxedSlice<Item> {
154    fn from_iter<T: IntoIterator<Item = Item>>(iter: T) -> Self {
155        let vec = Vec::from_iter(iter);
156        Self(vec)
157    }
158}
159
160impl<T> IntoIterator for BoxedSlice<T> {
161    type Item = T;
162    type IntoIter = std::vec::IntoIter<T>;
163
164    fn into_iter(self) -> Self::IntoIter {
165        self.0.into_iter()
166    }
167}
168
169impl<'a, T> IntoIterator for &'a BoxedSlice<T> {
170    type Item = &'a T;
171    type IntoIter = std::slice::Iter<'a, T>;
172
173    fn into_iter(self) -> Self::IntoIter {
174        self.0.iter()
175    }
176}
177
178impl<T, const N: usize> From<[T; N]> for BoxedSlice<T> {
179    fn from(value: [T; N]) -> Self {
180        let vec = Vec::from(value);
181        Self(vec)
182    }
183}
184
185impl<T> From<Vec<T>> for BoxedSlice<T> {
186    fn from(value: Vec<T>) -> Self {
187        Self(value)
188    }
189}
syn_sem/ds/vec.rs

syn_sem/ds/
vec.rs
