reifydb_type/value/container/
row.rs

1// SPDX-License-Identifier: MIT
2// Copyright (c) 2025 ReifyDB
3
4use std::{
5	fmt::{self, Debug},
6	ops::Deref,
7	result::Result as StdResult,
8};
9
10use serde::{Deserialize, Deserializer, Serialize, Serializer};
11
12use crate::{
13	Result,
14	storage::{Cow, DataBitVec, DataVec, Storage},
15	util::cowvec::CowVec,
16	value::{Value, row_number::RowNumber, r#type::Type},
17};
18
19pub struct RowNumberContainer<S: Storage = Cow> {
20	data: S::Vec<RowNumber>,
21}
22
23impl<S: Storage> Clone for RowNumberContainer<S> {
24	fn clone(&self) -> Self {
25		Self {
26			data: self.data.clone(),
27		}
28	}
29}
30
31impl<S: Storage> Debug for RowNumberContainer<S>
32where
33	S::Vec<RowNumber>: Debug,
34{
35	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
36		f.debug_struct("RowNumberContainer").field("data", &self.data).finish()
37	}
38}
39
40impl<S: Storage> PartialEq for RowNumberContainer<S>
41where
42	S::Vec<RowNumber>: PartialEq,
43{
44	fn eq(&self, other: &Self) -> bool {
45		self.data == other.data
46	}
47}
48
49impl Serialize for RowNumberContainer<Cow> {
50	fn serialize<Ser: Serializer>(&self, serializer: Ser) -> StdResult<Ser::Ok, Ser::Error> {
51		#[derive(Serialize)]
52		struct Helper<'a> {
53			data: &'a CowVec<RowNumber>,
54		}
55
56		Helper {
57			data: &self.data,
58		}
59		.serialize(serializer)
60	}
61}
62
63impl<'de> Deserialize<'de> for RowNumberContainer<Cow> {
64	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
65		#[derive(Deserialize)]
66		struct Helper {
67			data: CowVec<RowNumber>,
68		}
69		let h = Helper::deserialize(deserializer)?;
70		Ok(RowNumberContainer {
71			data: h.data,
72		})
73	}
74}
75
76impl<S: Storage> Deref for RowNumberContainer<S> {
77	type Target = [RowNumber];
78
79	fn deref(&self) -> &Self::Target {
80		self.data.as_slice()
81	}
82}
83
84impl RowNumberContainer<Cow> {
85	pub fn new(data: Vec<RowNumber>) -> Self {
86		Self {
87			data: CowVec::new(data),
88		}
89	}
90
91	pub fn with_capacity(capacity: usize) -> Self {
92		Self {
93			data: CowVec::with_capacity(capacity),
94		}
95	}
96
97	pub fn from_vec(data: Vec<RowNumber>) -> Self {
98		Self {
99			data: CowVec::new(data),
100		}
101	}
102}
103
104impl<S: Storage> RowNumberContainer<S> {
105	pub fn from_parts(data: S::Vec<RowNumber>) -> Self {
106		Self {
107			data,
108		}
109	}
110
111	pub fn len(&self) -> usize {
112		DataVec::len(&self.data)
113	}
114
115	pub fn capacity(&self) -> usize {
116		DataVec::capacity(&self.data)
117	}
118
119	pub fn is_empty(&self) -> bool {
120		DataVec::is_empty(&self.data)
121	}
122
123	pub fn push(&mut self, value: RowNumber) {
124		DataVec::push(&mut self.data, value);
125	}
126
127	pub fn push_default(&mut self) {
128		DataVec::push(&mut self.data, RowNumber::default());
129	}
130
131	pub fn get(&self, index: usize) -> Option<&RowNumber> {
132		if index < self.len() {
133			DataVec::get(&self.data, index)
134		} else {
135			None
136		}
137	}
138
139	pub fn is_defined(&self, idx: usize) -> bool {
140		idx < self.len()
141	}
142
143	pub fn data(&self) -> &S::Vec<RowNumber> {
144		&self.data
145	}
146
147	pub fn data_mut(&mut self) -> &mut S::Vec<RowNumber> {
148		&mut self.data
149	}
150
151	pub fn as_string(&self, index: usize) -> String {
152		if index < self.len() {
153			self.data[index].to_string()
154		} else {
155			"none".to_string()
156		}
157	}
158
159	pub fn get_value(&self, index: usize) -> Value {
160		if index < self.len() {
161			Value::Uint8(self.data[index].value())
162		} else {
163			Value::none_of(Type::Uint8)
164		}
165	}
166
167	pub fn extend(&mut self, other: &Self) -> Result<()> {
168		DataVec::extend_iter(&mut self.data, other.data.iter().cloned());
169		Ok(())
170	}
171
172	pub fn iter(&self) -> impl Iterator<Item = Option<RowNumber>> + '_ {
173		self.data.iter().map(|&v| Some(v))
174	}
175
176	pub fn slice(&self, start: usize, end: usize) -> Self {
177		let count = (end - start).min(self.len().saturating_sub(start));
178		let mut new_data = DataVec::spawn(&self.data, count);
179		for i in start..(start + count) {
180			DataVec::push(&mut new_data, self.data[i].clone());
181		}
182		Self {
183			data: new_data,
184		}
185	}
186
187	pub fn filter(&mut self, mask: &S::BitVec) {
188		let mut new_data = DataVec::spawn(&self.data, DataBitVec::count_ones(mask));
189
190		for (i, keep) in DataBitVec::iter(mask).enumerate() {
191			if keep && i < self.len() {
192				DataVec::push(&mut new_data, self.data[i].clone());
193			}
194		}
195
196		self.data = new_data;
197	}
198
199	pub fn reorder(&mut self, indices: &[usize]) {
200		let mut new_data = DataVec::spawn(&self.data, indices.len());
201
202		for &idx in indices {
203			if idx < self.len() {
204				DataVec::push(&mut new_data, self.data[idx].clone());
205			} else {
206				DataVec::push(&mut new_data, RowNumber::default());
207			}
208		}
209
210		self.data = new_data;
211	}
212
213	pub fn take(&self, num: usize) -> Self {
214		Self {
215			data: DataVec::take(&self.data, num),
216		}
217	}
218}
219
220impl Default for RowNumberContainer<Cow> {
221	fn default() -> Self {
222		Self::with_capacity(0)
223	}
224}
reifydb_type/value/container/row.rs

reifydb_type/value/container/
row.rs
