reifydb_core/value/index/
encoded.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright (c) 2025 ReifyDB
3
4use std::{
5	borrow::Borrow,
6	cmp::Ordering,
7	fmt,
8	hash::{Hash, Hasher},
9	mem,
10	ops::Deref,
11};
12
13use serde::{
14	de::{Deserialize, Deserializer},
15	ser::{Serialize, Serializer},
16};
17
18pub type EncodedIndexKeyIter = Box<dyn EncodedIndexKeyIterator>;
19
20pub trait EncodedIndexKeyIterator: Iterator<Item = EncodedIndexKey> {}
21
22impl<I: Iterator<Item = EncodedIndexKey>> EncodedIndexKeyIterator for I {}
23
24#[derive(Clone)]
25pub enum EncodedIndexKey {
26	Inline {
27		len: u8,
28		buf: [u8; 62],
29	},
30	Heap(Vec<u8>),
31}
32
33const _: () = assert!(mem::size_of::<EncodedIndexKey>() == 64);
34
35impl EncodedIndexKey {
36	const INLINE_CAP: usize = 62;
37
38	pub fn new(bytes: impl Into<Vec<u8>>) -> Self {
39		let vec = bytes.into();
40		if vec.len() <= Self::INLINE_CAP {
41			let len = vec.len() as u8;
42			let mut buf = [0u8; 62];
43			buf[..vec.len()].copy_from_slice(&vec);
44			EncodedIndexKey::Inline {
45				len,
46				buf,
47			}
48		} else {
49			EncodedIndexKey::Heap(vec)
50		}
51	}
52
53	pub fn from_bytes(bytes: &[u8]) -> Self {
54		Self::new(bytes.to_vec())
55	}
56
57	pub fn as_slice(&self) -> &[u8] {
58		match self {
59			EncodedIndexKey::Inline {
60				len,
61				buf,
62			} => &buf[..*len as usize],
63			EncodedIndexKey::Heap(v) => v.as_slice(),
64		}
65	}
66
67	pub fn make_mut(&mut self) -> &mut [u8] {
68		match self {
69			EncodedIndexKey::Inline {
70				len,
71				buf,
72			} => &mut buf[..*len as usize],
73			EncodedIndexKey::Heap(v) => v.as_mut_slice(),
74		}
75	}
76
77	#[inline]
78	pub fn is_defined(&self, index: usize) -> bool {
79		let byte = index / 8;
80		let bit = index % 8;
81		(self.as_slice()[byte] & (1 << bit)) != 0
82	}
83
84	pub(crate) fn set_valid(&mut self, index: usize, bitvec: bool) {
85		let byte = index / 8;
86		let bit = index % 8;
87		if bitvec {
88			self.make_mut()[byte] |= 1 << bit;
89		} else {
90			self.make_mut()[byte] &= !(1 << bit);
91		}
92	}
93}
94
95impl Deref for EncodedIndexKey {
96	type Target = [u8];
97
98	fn deref(&self) -> &[u8] {
99		self.as_slice()
100	}
101}
102
103impl AsRef<[u8]> for EncodedIndexKey {
104	fn as_ref(&self) -> &[u8] {
105		self.as_slice()
106	}
107}
108
109impl Borrow<[u8]> for EncodedIndexKey {
110	fn borrow(&self) -> &[u8] {
111		self.as_slice()
112	}
113}
114
115impl PartialEq for EncodedIndexKey {
116	fn eq(&self, other: &Self) -> bool {
117		self.as_slice() == other.as_slice()
118	}
119}
120
121impl Eq for EncodedIndexKey {}
122
123impl PartialOrd for EncodedIndexKey {
124	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
125		Some(self.cmp(other))
126	}
127}
128
129impl Ord for EncodedIndexKey {
130	fn cmp(&self, other: &Self) -> Ordering {
131		self.as_slice().cmp(other.as_slice())
132	}
133}
134
135impl Hash for EncodedIndexKey {
136	fn hash<H: Hasher>(&self, state: &mut H) {
137		self.as_slice().hash(state);
138	}
139}
140
141impl Serialize for EncodedIndexKey {
142	fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
143		self.as_slice().serialize(serializer)
144	}
145}
146
147impl<'de> Deserialize<'de> for EncodedIndexKey {
148	fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
149		let vec = Vec::<u8>::deserialize(deserializer)?;
150		Ok(EncodedIndexKey::new(vec))
151	}
152}
153
154impl fmt::Debug for EncodedIndexKey {
155	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
156		write!(f, "EncodedIndexKey({:02x?})", self.as_slice())
157	}
158}
reifydb_core/value/index/encoded.rs

reifydb_core/value/index/
encoded.rs
