use crate::{EntitySchema, Error, Timestamp, codec::Decoder};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ManagedTimestamp {
CreatedAt,
UpdatedAt,
}
impl ManagedTimestamp {
pub(crate) const fn slot(self) -> usize {
match self {
Self::CreatedAt => 0,
Self::UpdatedAt => 1,
}
}
}
#[doc(hidden)]
pub fn validate_order(values: [Option<Timestamp>; 2]) -> Result<(), Error> {
if matches!(values, [Some(created), Some(updated)] if created > updated) {
return Err(Error::Corrupt);
}
Ok(())
}
fn positions(
schema: &EntitySchema,
bytes: &[u8],
) -> Result<[Option<(usize, Timestamp)>; 2], Error> {
let mut reader = Decoder::new(bytes)?;
let mut values = [None; 2];
for field in schema.fields {
if field.optional && !reader.boolean()? {
continue;
}
if let Some(managed) = field.managed {
let offset = reader.position();
values[managed.slot()] = Some((offset, reader.timestamp()?));
} else {
reader.skip(field.value)?;
}
}
reader.finish()?;
Ok(values)
}
pub(crate) fn values(schema: &EntitySchema, bytes: &[u8]) -> Result<[Option<Timestamp>; 2], Error> {
Ok(positions(schema, bytes)?.map(|entry| entry.map(|(_, value)| value)))
}
pub(crate) fn validate_insert(
schema: &EntitySchema,
bytes: &[u8],
now: Timestamp,
) -> Result<(), Error> {
if positions(schema, bytes)?
.into_iter()
.flatten()
.any(|(_, value)| value != now)
{
return Err(Error::ManagedField);
}
Ok(())
}
pub(crate) fn replace(
schema: &EntitySchema,
bytes: &mut [u8],
old: &[u8],
now: Timestamp,
) -> Result<bool, Error> {
let before = positions(schema, old)?;
validate_order(before.map(|entry| entry.map(|(_, value)| value)))?;
if bytes == old {
return Ok(false);
}
let after = positions(schema, bytes)?;
for (previous, supplied) in before.iter().zip(&after) {
if previous.map(|(_, value)| value) != supplied.map(|(_, value)| value) {
return Err(Error::ManagedField);
}
}
if before.into_iter().flatten().any(|(_, value)| now < value) {
return Err(Error::TimestampRegression);
}
if let Some((offset, _)) = after[1] {
bytes
.get_mut(offset..offset + 8)
.ok_or(Error::Corrupt)?
.copy_from_slice(&now.as_millis().to_le_bytes());
}
Ok(true)
}