fenris_nested_vec/
lib.rs

1use serde::{Deserialize, Serialize};
2use std::fmt;
3use std::fmt::Debug;
4use std::ops::Range;
5
6// TODO: Manually implement Deserialize to avoid soundness hole
7#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
8pub struct NestedVec<T> {
9    data: Vec<T>,
10    offsets_begin: Vec<usize>,
11    offsets_end: Vec<usize>,
12}
13
14impl<T: Debug> Debug for NestedVec<T> {
15    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
16        f.debug_list().entries(self.iter()).finish()
17    }
18}
19
20impl<T> Default for NestedVec<T> {
21    fn default() -> Self {
22        Self::new()
23    }
24}
25
26impl<T> NestedVec<T> {
27    pub fn new() -> Self {
28        Self {
29            data: Vec::new(),
30            offsets_begin: Vec::new(),
31            offsets_end: Vec::new(),
32        }
33    }
34
35    /// Return a data structure that can be used for appending single elements to the same array.
36    /// When the returned data structure is dropped, the result is equivalent to
37    /// adding the array at once with `CompactArrayStorage::push`.
38    ///
39    /// TODO: Need better name
40    pub fn begin_array<'a>(&'a mut self) -> ArrayAppender<'a, T> {
41        let initial_count = self.data.len();
42        ArrayAppender {
43            initial_count,
44            data: &mut self.data,
45            offsets_begin: &mut self.offsets_begin,
46            offsets_end: &mut self.offsets_end,
47        }
48    }
49
50    pub fn iter<'a>(&'a self) -> impl 'a + Iterator<Item = &'a [T]> {
51        (0..self.len()).map(move |i| self.get(i).unwrap())
52    }
53
54    pub fn len(&self) -> usize {
55        self.offsets_begin.len()
56    }
57
58    /// Returns an iterator over all elements inside all arrays.
59    pub fn iter_array_elements<'a>(&'a self) -> impl 'a + Iterator<Item = &'a T> {
60        self.iter().flatten()
61    }
62
63    pub fn total_num_elements(&self) -> usize {
64        self.offsets_begin
65            .iter()
66            .zip(&self.offsets_end)
67            .map(|(begin, end)| end - begin)
68            .sum()
69    }
70
71    pub fn get(&self, index: usize) -> Option<&[T]> {
72        let range = self.get_index_range(index)?;
73        self.data.get(range)
74    }
75
76    pub fn get_mut(&mut self, index: usize) -> Option<&mut [T]> {
77        let range = self.get_index_range(index)?;
78        self.data.get_mut(range)
79    }
80
81    fn get_index_range(&self, index: usize) -> Option<Range<usize>> {
82        let begin = *self.offsets_begin.get(index)?;
83        let end = *self.offsets_end.get(index)?;
84        Some(begin..end)
85    }
86
87    pub fn first(&self) -> Option<&[T]> {
88        self.get(0)
89    }
90
91    pub fn first_mut(&mut self) -> Option<&mut [T]> {
92        self.get_mut(0)
93    }
94
95    fn get_last_range(&self) -> Option<Range<usize>> {
96        let begin = *self.offsets_begin.last()?;
97        let end = *self.offsets_end.last()?;
98        Some(begin..end)
99    }
100
101    pub fn last(&self) -> Option<&[T]> {
102        let range = self.get_last_range()?;
103        self.data.get(range)
104    }
105
106    pub fn last_mut(&mut self) -> Option<&mut [T]> {
107        let range = self.get_last_range()?;
108        self.data.get_mut(range)
109    }
110
111    pub fn clear(&mut self) {
112        self.offsets_end.clear();
113        self.offsets_begin.clear();
114        self.data.clear();
115    }
116}
117
118#[derive(Debug)]
119pub struct ArrayAppender<'a, T> {
120    data: &'a mut Vec<T>,
121    offsets_begin: &'a mut Vec<usize>,
122    offsets_end: &'a mut Vec<usize>,
123    initial_count: usize,
124}
125
126impl<'a, T> ArrayAppender<'a, T> {
127    pub fn push_single(&mut self, element: T) -> &mut Self {
128        self.data.push(element);
129        self
130    }
131
132    pub fn count(&self) -> usize {
133        self.data.len() - self.initial_count
134    }
135}
136
137impl<'a, T> Drop for ArrayAppender<'a, T> {
138    fn drop(&mut self) {
139        self.offsets_begin.push(self.initial_count);
140        self.offsets_end.push(self.data.len());
141    }
142}
143
144impl<T: Clone> NestedVec<T> {
145    pub fn push(&mut self, array: &[T]) {
146        self.offsets_begin.push(self.data.len());
147        self.data.extend_from_slice(array);
148        self.offsets_end.push(self.data.len());
149    }
150}
151
152impl<'a, T: Clone> From<&'a Vec<Vec<T>>> for NestedVec<T> {
153    fn from(nested_vec: &'a Vec<Vec<T>>) -> Self {
154        let mut result = Self::new();
155        for vec in nested_vec {
156            result.push(vec);
157        }
158        result
159    }
160}
161
162impl<T: Clone> From<Vec<Vec<T>>> for NestedVec<T> {
163    fn from(vec_vec: Vec<Vec<T>>) -> Self {
164        Self::from(&vec_vec)
165    }
166}
167
168impl<'a, T: Clone> From<&'a NestedVec<T>> for Vec<Vec<T>> {
169    fn from(nested: &NestedVec<T>) -> Self {
170        nested.iter().map(|slice| slice.to_vec()).collect()
171    }
172}
173
174impl<'a, T: Clone> From<NestedVec<T>> for Vec<Vec<T>> {
175    fn from(nested: NestedVec<T>) -> Self {
176        Self::from(&nested)
177    }
178}
fenris_nested_vec/lib.rs

fenris_nested_vec/
lib.rs
