use std::ops::Bound;
use storekey::{BorrowDecode, BorrowReader, DecodeError, EscapedSlice};
use super::number::NumberKind;
use super::{
Bytes, Closure, Date, Datetime, Duration, File, Geometry, Interval, Number, RecordId, Regex,
Set, TableName, Time, Timestamp, Uuid,
};
pub struct KeyIdRead;
impl<'de> BorrowDecode<'de, ()> for KeyIdRead {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
<KeyId<'de> as BorrowDecode<'de, ()>>::borrow_decode(reader)?;
Ok(Self)
}
}
pub enum KeyIdRef<'a> {
Number(i64),
String(&'a EscapedSlice),
Uuid(Uuid),
Other,
}
impl<'de> BorrowDecode<'de, ()> for KeyIdRef<'de> {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
Ok(match <KeyId<'de> as BorrowDecode<'de, ()>>::borrow_decode(reader)? {
KeyId::Number(n) => Self::Number(n),
KeyId::String(text) => Self::String(text.0),
KeyId::Uuid(uuid) => Self::Uuid(uuid),
KeyId::Array(_) | KeyId::Object(_) | KeyId::Range(_) => Self::Other,
})
}
}
pub struct KeyText<'a>(&'a EscapedSlice);
impl<'a> KeyText<'a> {
pub fn escaped(&self) -> &'a EscapedSlice {
self.0
}
}
impl<'de> BorrowDecode<'de, ()> for KeyText<'de> {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
Text::borrow_decode(reader).map(|text| Self(text.0))
}
}
#[derive(BorrowDecode)]
#[storekey(format = "()")]
#[expect(
dead_code,
reason = "an id other than a number or a string is read to be validated and dropped unread"
)]
enum KeyId<'a> {
Number(i64),
String(Text<'a>),
Uuid(Uuid),
Array(Elements),
Object(Entries),
Range(Box<KeyIdRange<'a>>),
}
#[derive(BorrowDecode)]
#[storekey(format = "()")]
#[expect(dead_code, reason = "a range is read to be validated and dropped unread")]
struct KeyIdRange<'a> {
start: Bound<KeyId<'a>>,
end: Bound<KeyId<'a>>,
}
#[derive(BorrowDecode)]
#[storekey(format = "()")]
#[expect(dead_code, reason = "a value is read to be validated and dropped unread")]
enum Element<'a> {
None,
Null,
Bool(bool),
Number(KeyNumber),
String(Text<'a>),
Duration(Duration),
Datetime(Datetime),
Uuid(Uuid),
Array(Elements),
Set(Set),
Object(Entries),
Geometry(Geometry),
Bytes(Bytes),
Table(TableName),
RecordId(RecordId),
File(File),
Regex(Regex),
Range(Box<Span<'a>>),
Closure(Box<Closure>),
Date(Date),
Time(Time),
Timestamp(Timestamp),
Interval(Interval),
}
#[derive(BorrowDecode)]
#[storekey(format = "()")]
#[expect(dead_code, reason = "a range is read to be validated and dropped unread")]
struct Span<'a> {
start: Bound<Element<'a>>,
end: Bound<Element<'a>>,
}
struct Text<'a>(&'a EscapedSlice);
impl<'de> BorrowDecode<'de, ()> for Text<'de> {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
let escaped = reader.read_escaped_slice()?;
if is_utf8(escaped) {
Ok(Self(escaped))
} else {
Err(DecodeError::Utf8)
}
}
}
fn is_utf8(escaped: &EscapedSlice) -> bool {
let bytes = escaped.as_bytes();
let raw = bytes.get(..bytes.len().saturating_sub(1)).unwrap_or(&[]);
if !raw.contains(&1) {
return std::str::from_utf8(raw).is_ok();
}
let mut window = [0u8; 64];
let mut carried = 0;
let mut rest = escaped.iter().copied();
loop {
let mut filled = carried;
while let Some(slot) = window.get_mut(filled) {
let Some(byte) = rest.next() else {
break;
};
*slot = byte;
filled += 1;
}
let last = filled < window.len();
let Some(held) = window.get(..filled) else {
return false;
};
match std::str::from_utf8(held) {
Ok(_) => carried = 0,
Err(error) if error.error_len().is_none() && !last => {
let from = error.valid_up_to();
window.copy_within(from..filled, 0);
carried = filled - from;
}
Err(_) => return false,
}
if last {
return true;
}
}
}
const DECIMAL_BUFFER: usize = 64;
struct KeyNumber;
impl<'de> BorrowDecode<'de, ()> for KeyNumber {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
let escaped = reader.read_escaped_slice()?;
let kind: NumberKind = BorrowDecode::<'de, ()>::borrow_decode(reader)?;
let mut stack = [0u8; DECIMAL_BUFFER];
let mut length = 0;
for &byte in escaped.iter() {
let Some(slot) = stack.get_mut(length) else {
let heap: Vec<u8> = escaped.iter().copied().collect();
return Number::from_decimal_buf_kind(&heap, kind)
.map(|_| Self)
.map_err(|_| DecodeError::InvalidFormat);
};
*slot = byte;
length += 1;
}
Number::from_decimal_buf_kind(&stack[..length], kind)
.map(|_| Self)
.map_err(|_| DecodeError::InvalidFormat)
}
}
struct Elements;
impl<'de> BorrowDecode<'de, ()> for Elements {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
while !reader.read_terminal()? {
<Element<'de> as BorrowDecode<'de, ()>>::borrow_decode(reader)?;
}
Ok(Self)
}
}
struct Entries;
impl<'de> BorrowDecode<'de, ()> for Entries {
fn borrow_decode(reader: &mut BorrowReader<'de>) -> Result<Self, DecodeError> {
let mut previous: Option<Text<'de>> = None;
while !reader.read_terminal()? {
let key = Text::borrow_decode(reader)?;
if previous.as_ref().is_some_and(|before| key.0.iter().cmp(before.0.iter()).is_le()) {
return Err(DecodeError::InvalidFormat);
}
<Element<'de> as BorrowDecode<'de, ()>>::borrow_decode(reader)?;
previous = Some(key);
}
Ok(Self)
}
}