reifydb_value/value/container/
temporal.rs

1// SPDX-License-Identifier: MIT
2// Copyright (c) 2026 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, is::IsTemporal},
17};
18
19pub struct TemporalContainer<T, S: Storage = Cow>
20where
21	T: IsTemporal,
22{
23	data: S::Vec<T>,
24}
25
26impl<T: IsTemporal, S: Storage> Clone for TemporalContainer<T, S> {
27	fn clone(&self) -> Self {
28		Self {
29			data: self.data.clone(),
30		}
31	}
32}
33
34impl<T: IsTemporal + Debug, S: Storage> Debug for TemporalContainer<T, S>
35where
36	S::Vec<T>: Debug,
37{
38	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
39		f.debug_struct("TemporalContainer").field("data", &self.data).finish()
40	}
41}
42
43impl<T: IsTemporal, S: Storage> PartialEq for TemporalContainer<T, S>
44where
45	S::Vec<T>: PartialEq,
46{
47	fn eq(&self, other: &Self) -> bool {
48		self.data == other.data
49	}
50}
51
52impl<T: IsTemporal + Serialize> Serialize for TemporalContainer<T, Cow> {
53	fn serialize<Ser: Serializer>(&self, serializer: Ser) -> StdResult<Ser::Ok, Ser::Error> {
54		#[derive(Serialize)]
55		struct Helper<'a, T: Clone + PartialEq + Serialize> {
56			data: &'a CowVec<T>,
57		}
58		Helper {
59			data: &self.data,
60		}
61		.serialize(serializer)
62	}
63}
64
65impl<'de, T: IsTemporal + Deserialize<'de>> Deserialize<'de> for TemporalContainer<T, Cow> {
66	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
67		#[derive(Deserialize)]
68		struct Helper<T: Clone + PartialEq> {
69			data: CowVec<T>,
70		}
71		let h = Helper::deserialize(deserializer)?;
72		Ok(TemporalContainer {
73			data: h.data,
74		})
75	}
76}
77
78impl<T: IsTemporal, S: Storage> Deref for TemporalContainer<T, S> {
79	type Target = [T];
80
81	fn deref(&self) -> &Self::Target {
82		self.data.as_slice()
83	}
84}
85
86impl<T> TemporalContainer<T, Cow>
87where
88	T: IsTemporal + Clone + Debug + Default,
89{
90	pub fn new(data: Vec<T>) -> Self {
91		Self {
92			data: CowVec::new(data),
93		}
94	}
95
96	pub fn with_capacity(capacity: usize) -> Self {
97		Self {
98			data: CowVec::with_capacity(capacity),
99		}
100	}
101
102	pub fn from_vec(data: Vec<T>) -> Self {
103		Self {
104			data: CowVec::new(data),
105		}
106	}
107}
108
109impl<T, S: Storage> TemporalContainer<T, S>
110where
111	T: IsTemporal + Clone + Debug + Default,
112{
113	pub fn from_parts(data: S::Vec<T>) -> Self {
114		Self {
115			data,
116		}
117	}
118
119	pub fn len(&self) -> usize {
120		DataVec::len(&self.data)
121	}
122
123	pub fn capacity(&self) -> usize {
124		DataVec::capacity(&self.data)
125	}
126
127	pub fn is_empty(&self) -> bool {
128		DataVec::is_empty(&self.data)
129	}
130
131	pub fn clear(&mut self) {
132		DataVec::clear(&mut self.data);
133	}
134
135	pub fn push(&mut self, value: T) {
136		DataVec::push(&mut self.data, value);
137	}
138
139	pub fn push_default(&mut self) {
140		DataVec::push(&mut self.data, T::default());
141	}
142
143	pub fn get(&self, index: usize) -> Option<&T> {
144		if index < self.len() {
145			DataVec::get(&self.data, index)
146		} else {
147			None
148		}
149	}
150
151	pub fn is_defined(&self, idx: usize) -> bool {
152		idx < self.len()
153	}
154
155	pub fn is_fully_defined(&self) -> bool {
156		true
157	}
158
159	pub fn data(&self) -> &S::Vec<T> {
160		&self.data
161	}
162
163	pub fn data_mut(&mut self) -> &mut S::Vec<T> {
164		&mut self.data
165	}
166
167	pub fn as_string(&self, index: usize) -> String {
168		if index < self.len() {
169			self.data[index].to_string()
170		} else {
171			"none".to_string()
172		}
173	}
174
175	pub fn get_value(&self, index: usize) -> Value {
176		if index < self.len() {
177			self.data[index].to_value()
178		} else {
179			Value::none()
180		}
181	}
182
183	pub fn extend(&mut self, other: &Self) -> Result<()> {
184		DataVec::extend_iter(&mut self.data, other.data.iter().cloned());
185		Ok(())
186	}
187
188	pub fn iter(&self) -> impl Iterator<Item = Option<T>> + '_
189	where
190		T: Copy,
191	{
192		self.data.iter().map(|&v| Some(v))
193	}
194
195	pub fn slice(&self, start: usize, end: usize) -> Self {
196		let count = (end - start).min(self.len().saturating_sub(start));
197		let mut new_data = DataVec::spawn(&self.data, count);
198		for i in start..(start + count) {
199			DataVec::push(&mut new_data, self.data[i].clone());
200		}
201		Self {
202			data: new_data,
203		}
204	}
205
206	pub fn filter(&mut self, mask: &S::BitVec) {
207		let mut new_data = DataVec::spawn(&self.data, DataBitVec::count_ones(mask));
208
209		for (i, keep) in DataBitVec::iter(mask).enumerate() {
210			if keep && i < self.len() {
211				DataVec::push(&mut new_data, self.data[i].clone());
212			}
213		}
214
215		self.data = new_data;
216	}
217
218	pub fn reorder(&mut self, indices: &[usize]) {
219		let mut new_data = DataVec::spawn(&self.data, indices.len());
220
221		for &idx in indices {
222			if idx < self.len() {
223				DataVec::push(&mut new_data, self.data[idx].clone());
224			} else {
225				DataVec::push(&mut new_data, T::default());
226			}
227		}
228
229		self.data = new_data;
230	}
231
232	pub fn take(&self, num: usize) -> Self {
233		Self {
234			data: DataVec::take(&self.data, num),
235		}
236	}
237}
238
239impl<T> Default for TemporalContainer<T, Cow>
240where
241	T: IsTemporal + Clone + Debug + Default,
242{
243	fn default() -> Self {
244		Self::with_capacity(0)
245	}
246}
247
248#[cfg(test)]
249pub mod tests {
250	use super::*;
251	use crate::value::{date::Date, datetime::DateTime, duration::Duration, time::Time};
252
253	#[test]
254	fn test_date_container() {
255		let dates = vec![
256			Date::from_ymd(2023, 1, 1).unwrap(),
257			Date::from_ymd(2023, 6, 15).unwrap(),
258			Date::from_ymd(2023, 12, 31).unwrap(),
259		];
260		let container = TemporalContainer::from_vec(dates.clone());
261
262		assert_eq!(container.len(), 3);
263		assert_eq!(container.get(0), Some(&dates[0]));
264		assert_eq!(container.get(1), Some(&dates[1]));
265		assert_eq!(container.get(2), Some(&dates[2]));
266
267		for i in 0..3 {
268			assert!(container.is_defined(i));
269		}
270	}
271
272	#[test]
273	fn test_datetime_container() {
274		let datetimes = vec![
275			DateTime::from_timestamp(1000000000).unwrap(),
276			DateTime::from_timestamp(2000000000).unwrap(),
277		];
278		let container = TemporalContainer::from_vec(datetimes.clone());
279
280		assert_eq!(container.len(), 2);
281		assert_eq!(container.get(0), Some(&datetimes[0]));
282		assert_eq!(container.get(1), Some(&datetimes[1]));
283	}
284
285	#[test]
286	fn test_time_container() {
287		let times = vec![
288			Time::from_hms(9, 0, 0).unwrap(),
289			Time::from_hms(12, 30, 45).unwrap(),
290			Time::from_hms(23, 59, 59).unwrap(),
291		];
292		let container = TemporalContainer::from_vec(times.clone());
293
294		assert_eq!(container.len(), 3);
295		assert_eq!(container.get(0), Some(&times[0]));
296		assert_eq!(container.get(1), Some(&times[1]));
297		assert_eq!(container.get(2), Some(&times[2]));
298	}
299
300	#[test]
301	fn test_interval_container() {
302		let durations = vec![Duration::from_days(30).unwrap(), Duration::from_hours(24).unwrap()];
303		let container = TemporalContainer::from_vec(durations.clone());
304
305		assert_eq!(container.len(), 2);
306		assert_eq!(container.get(0), Some(&durations[0]));
307		assert_eq!(container.get(1), Some(&durations[1]));
308	}
309
310	#[test]
311	fn test_with_capacity() {
312		let container: TemporalContainer<Date> = TemporalContainer::with_capacity(10);
313		assert_eq!(container.len(), 0);
314		assert!(container.is_empty());
315		assert!(container.capacity() >= 10);
316	}
317
318	#[test]
319	fn test_push_with_default() {
320		let mut container: TemporalContainer<Date> = TemporalContainer::with_capacity(3);
321
322		container.push(Date::from_ymd(2023, 1, 1).unwrap());
323		container.push_default();
324		container.push(Date::from_ymd(2023, 12, 31).unwrap());
325
326		assert_eq!(container.len(), 3);
327		assert_eq!(container.get(0), Some(&Date::from_ymd(2023, 1, 1).unwrap()));
328		assert_eq!(container.get(1), Some(&Date::default())); // push_default pushes default
329		assert_eq!(container.get(2), Some(&Date::from_ymd(2023, 12, 31).unwrap()));
330
331		assert!(container.is_defined(0));
332		assert!(container.is_defined(1));
333		assert!(container.is_defined(2));
334	}
335
336	#[test]
337	fn test_extend() {
338		let mut container1 = TemporalContainer::from_vec(vec![
339			Date::from_ymd(2023, 1, 1).unwrap(),
340			Date::from_ymd(2023, 6, 15).unwrap(),
341		]);
342		let container2 = TemporalContainer::from_vec(vec![Date::from_ymd(2023, 12, 31).unwrap()]);
343
344		container1.extend(&container2).unwrap();
345
346		assert_eq!(container1.len(), 3);
347	}
348
349	#[test]
350	fn test_iter() {
351		let dates = vec![
352			Date::from_ymd(2023, 1, 1).unwrap(),
353			Date::from_ymd(2023, 6, 15).unwrap(),
354			Date::from_ymd(2023, 12, 31).unwrap(),
355		];
356		let container = TemporalContainer::new(dates.clone());
357
358		let collected: Vec<Option<Date>> = container.iter().collect();
359		assert_eq!(collected, vec![Some(dates[0]), Some(dates[1]), Some(dates[2])]);
360	}
361
362	#[test]
363	fn testault() {
364		let container: TemporalContainer<Date> = TemporalContainer::default();
365		assert_eq!(container.len(), 0);
366		assert!(container.is_empty());
367	}
368}
reifydb_value/value/container/temporal.rs

reifydb_value/value/container/
temporal.rs
