1use crate::{EntitySchema, Error, Timestamp, codec::Decoder};
4
5#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub enum ManagedTimestamp {
8 CreatedAt,
10 UpdatedAt,
12}
13
14impl ManagedTimestamp {
15 pub(crate) const fn slot(self) -> usize {
16 match self {
17 Self::CreatedAt => 0,
18 Self::UpdatedAt => 1,
19 }
20 }
21}
22
23#[doc(hidden)]
24pub fn validate_order(values: [Option<Timestamp>; 2]) -> Result<(), Error> {
25 if matches!(values, [Some(created), Some(updated)] if created > updated) {
26 return Err(Error::Corrupt);
27 }
28 Ok(())
29}
30
31fn positions(
34 schema: &EntitySchema,
35 bytes: &[u8],
36) -> Result<[Option<(usize, Timestamp)>; 2], Error> {
37 let mut reader = Decoder::new(bytes)?;
38 let mut values = [None; 2];
39 for field in schema.fields {
40 if field.optional && !reader.boolean()? {
41 continue;
42 }
43 if let Some(managed) = field.managed {
44 let offset = reader.position();
45 values[managed.slot()] = Some((offset, reader.timestamp()?));
46 } else {
47 reader.skip(field.value)?;
48 }
49 }
50 reader.finish()?;
51 Ok(values)
52}
53
54pub(crate) fn values(schema: &EntitySchema, bytes: &[u8]) -> Result<[Option<Timestamp>; 2], Error> {
56 Ok(positions(schema, bytes)?.map(|entry| entry.map(|(_, value)| value)))
57}
58
59pub(crate) fn validate_insert(
60 schema: &EntitySchema,
61 bytes: &[u8],
62 now: Timestamp,
63) -> Result<(), Error> {
64 if positions(schema, bytes)?
65 .into_iter()
66 .flatten()
67 .any(|(_, value)| value != now)
68 {
69 return Err(Error::ManagedField);
70 }
71 Ok(())
72}
73
74pub(crate) fn replace(
75 schema: &EntitySchema,
76 bytes: &mut [u8],
77 old: &[u8],
78 now: Timestamp,
79) -> Result<bool, Error> {
80 let before = positions(schema, old)?;
81 validate_order(before.map(|entry| entry.map(|(_, value)| value)))?;
82 if bytes == old {
83 return Ok(false);
84 }
85 let after = positions(schema, bytes)?;
86 for (previous, supplied) in before.iter().zip(&after) {
87 if previous.map(|(_, value)| value) != supplied.map(|(_, value)| value) {
88 return Err(Error::ManagedField);
89 }
90 }
91 if before.into_iter().flatten().any(|(_, value)| now < value) {
92 return Err(Error::TimestampRegression);
93 }
94 if let Some((offset, _)) = after[1] {
95 bytes
96 .get_mut(offset..offset + 8)
97 .ok_or(Error::Corrupt)?
98 .copy_from_slice(&now.as_millis().to_le_bytes());
99 }
100 Ok(true)
101}