637 lines
22 KiB
Rust
637 lines
22 KiB
Rust
//! Decoder for the canonical materialized-state snapshot format.
|
|
//!
|
|
//! The operation layer owns this inverse because only it understands the
|
|
//! semantic types embedded in [`MaterializedState`](crate::MaterializedState).
|
|
//! Bundle storage deliberately treats snapshot payloads as opaque bytes.
|
|
|
|
use std::collections::BTreeMap;
|
|
|
|
use epiphany_core::{
|
|
CanonicalValue, MusicalPosition, OperationId, PitchId, PitchSpelling, RegionId, TypedObjectId,
|
|
};
|
|
use epiphany_determinism::CanonicalDecode;
|
|
|
|
use crate::{
|
|
ConflictId, ConflictKind, ConflictKindRegistryId, ConflictRecord, ConflictRegistry,
|
|
ConflictResolutionState, ExtensionPreconditionId, IntegrityAnomaly, IntegrityAnomalyKind,
|
|
IntegrityAnomalyRegistryId, MaterializedState, NoOpReason, ObjectKind, ObjectState,
|
|
OperationEffect, PendingReason, PreconditionFailureReason, PreconditionFailureRegistryId,
|
|
ReanchorReason, ReanchorReasonRegistryId, RepairKind, RepairKindRegistryId, RepairRecord,
|
|
ResolutionAction, ResolutionRegistryId, SerializedCanonicalInputs, TupletCompensationKind,
|
|
};
|
|
|
|
/// Failure to decode a canonical [`MaterializedState`] snapshot.
|
|
#[derive(Clone, PartialEq, Eq, Debug)]
|
|
pub enum MaterializedDecodeError {
|
|
/// A field ended before its declared or fixed width.
|
|
UnexpectedEof,
|
|
/// A length prefix cannot be represented safely by this process.
|
|
LengthOverflow,
|
|
/// A tagged union carried an unknown discriminant.
|
|
InvalidTag { kind: &'static str, tag: u8 },
|
|
/// A primitive value failed its own canonical decoder.
|
|
InvalidValue(&'static str),
|
|
/// A canonical boolean was not encoded as zero or one.
|
|
InvalidBoolean(u8),
|
|
/// A canonical text field was not UTF-8.
|
|
InvalidUtf8,
|
|
/// Bytes remained after the complete state was decoded.
|
|
TrailingBytes,
|
|
/// The bytes decoded structurally but were not in canonical order/form.
|
|
NonCanonical,
|
|
}
|
|
|
|
impl core::fmt::Display for MaterializedDecodeError {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
match self {
|
|
Self::UnexpectedEof => f.write_str("unexpected end of materialized-state bytes"),
|
|
Self::LengthOverflow => f.write_str("materialized-state length does not fit usize"),
|
|
Self::InvalidTag { kind, tag } => write!(f, "invalid {kind} tag {tag}"),
|
|
Self::InvalidValue(kind) => write!(f, "invalid canonical {kind}"),
|
|
Self::InvalidBoolean(value) => write!(f, "invalid canonical boolean {value}"),
|
|
Self::InvalidUtf8 => f.write_str("invalid UTF-8 in canonical text"),
|
|
Self::TrailingBytes => f.write_str("trailing bytes after materialized state"),
|
|
Self::NonCanonical => f.write_str("materialized-state bytes are not canonical"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl std::error::Error for MaterializedDecodeError {}
|
|
|
|
type Result<T> = core::result::Result<T, MaterializedDecodeError>;
|
|
|
|
struct Reader<'a> {
|
|
bytes: &'a [u8],
|
|
pos: usize,
|
|
}
|
|
|
|
impl<'a> Reader<'a> {
|
|
fn new(bytes: &'a [u8]) -> Self {
|
|
Self { bytes, pos: 0 }
|
|
}
|
|
|
|
fn take(&mut self, n: usize) -> Result<&'a [u8]> {
|
|
let end = self
|
|
.pos
|
|
.checked_add(n)
|
|
.ok_or(MaterializedDecodeError::LengthOverflow)?;
|
|
if end > self.bytes.len() {
|
|
return Err(MaterializedDecodeError::UnexpectedEof);
|
|
}
|
|
let out = &self.bytes[self.pos..end];
|
|
self.pos = end;
|
|
Ok(out)
|
|
}
|
|
|
|
fn byte(&mut self) -> Result<u8> {
|
|
Ok(self.take(1)?[0])
|
|
}
|
|
|
|
fn u32_le(&mut self) -> Result<u32> {
|
|
Ok(u32::from_le_bytes(
|
|
self.take(4)?.try_into().expect("fixed width"),
|
|
))
|
|
}
|
|
|
|
fn u64_le(&mut self) -> Result<u64> {
|
|
Ok(u64::from_le_bytes(
|
|
self.take(8)?.try_into().expect("fixed width"),
|
|
))
|
|
}
|
|
|
|
fn u128_be(&mut self) -> Result<u128> {
|
|
Ok(u128::from_be_bytes(
|
|
self.take(16)?.try_into().expect("fixed width"),
|
|
))
|
|
}
|
|
|
|
fn len(&mut self) -> Result<usize> {
|
|
usize::try_from(self.u32_le()?).map_err(|_| MaterializedDecodeError::LengthOverflow)
|
|
}
|
|
|
|
fn lp_bytes(&mut self) -> Result<&'a [u8]> {
|
|
let len = self.len()?;
|
|
self.take(len)
|
|
}
|
|
|
|
fn seq<T>(&mut self, mut decode: impl FnMut(&[u8]) -> Result<T>) -> Result<Vec<T>> {
|
|
let count = self.len()?;
|
|
let mut values = Vec::with_capacity(count.min(1024));
|
|
for _ in 0..count {
|
|
values.push(decode(self.lp_bytes()?)?);
|
|
}
|
|
Ok(values)
|
|
}
|
|
|
|
fn finish(self) -> Result<()> {
|
|
if self.pos == self.bytes.len() {
|
|
Ok(())
|
|
} else {
|
|
Err(MaterializedDecodeError::TrailingBytes)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn exact<T>(bytes: &[u8], decode: impl FnOnce(&mut Reader<'_>) -> Result<T>) -> Result<T> {
|
|
let mut reader = Reader::new(bytes);
|
|
let value = decode(&mut reader)?;
|
|
reader.finish()?;
|
|
Ok(value)
|
|
}
|
|
|
|
fn fixed<T: CanonicalDecode>(reader: &mut Reader<'_>, n: usize, name: &'static str) -> Result<T> {
|
|
T::decode_canonical(reader.take(n)?).map_err(|_| MaterializedDecodeError::InvalidValue(name))
|
|
}
|
|
|
|
fn operation_id(reader: &mut Reader<'_>) -> Result<OperationId> {
|
|
fixed(reader, 16, "OperationId")
|
|
}
|
|
|
|
fn typed_object_id(reader: &mut Reader<'_>) -> Result<TypedObjectId> {
|
|
let tag_bytes = reader
|
|
.bytes
|
|
.get(reader.pos..reader.pos.saturating_add(2))
|
|
.ok_or(MaterializedDecodeError::UnexpectedEof)?;
|
|
let tag = u16::from_be_bytes(tag_bytes.try_into().expect("two bytes"));
|
|
let width = if tag == 27 { 34 } else { 18 };
|
|
fixed(reader, width, "TypedObjectId")
|
|
}
|
|
|
|
fn musical_position(reader: &mut Reader<'_>) -> Result<MusicalPosition> {
|
|
let start = reader.pos;
|
|
reader.byte()?;
|
|
let numer_len = reader.len()?;
|
|
reader.take(numer_len)?;
|
|
let denom_len = reader.len()?;
|
|
reader.take(denom_len)?;
|
|
MusicalPosition::decode_canonical(&reader.bytes[start..reader.pos])
|
|
.map_err(|_| MaterializedDecodeError::InvalidValue("MusicalPosition"))
|
|
}
|
|
|
|
fn registry_id<T>(reader: &mut Reader<'_>, ctor: impl FnOnce(u128) -> T) -> Result<T> {
|
|
Ok(ctor(reader.u128_be()?))
|
|
}
|
|
|
|
fn object_state(reader: &mut Reader<'_>) -> Result<ObjectState> {
|
|
match reader.byte()? {
|
|
0 => Ok(ObjectState::Live),
|
|
1 => Ok(ObjectState::Tombstoned {
|
|
deleted_by: operation_id(reader)?,
|
|
minted_by: operation_id(reader)?,
|
|
}),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ObjectState",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn pending_reason(reader: &mut Reader<'_>) -> Result<PendingReason> {
|
|
let tag = reader.byte()?;
|
|
let blocker = operation_id(reader)?;
|
|
match tag {
|
|
0 => Ok(PendingReason::MissingCausalPredecessor { missing: blocker }),
|
|
1 => Ok(PendingReason::DependsOnEquivocated { on: blocker }),
|
|
2 => Ok(PendingReason::DependsOnExcluded { on: blocker }),
|
|
3 => Ok(PendingReason::DependsOnPending { on: blocker }),
|
|
4 => Ok(PendingReason::HaltedBySystemCollision { at: blocker }),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "PendingReason",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn precondition_reason(reader: &mut Reader<'_>) -> Result<PreconditionFailureReason> {
|
|
match reader.byte()? {
|
|
0 => Ok(PreconditionFailureReason::TargetMissing),
|
|
1 => Ok(PreconditionFailureReason::TargetTombstoned),
|
|
2 => Ok(PreconditionFailureReason::WrongRegionTimeModel),
|
|
3 => Ok(PreconditionFailureReason::TupletCompensationInvalid),
|
|
4 => Ok(PreconditionFailureReason::EventDurationInvalid),
|
|
5 => Ok(PreconditionFailureReason::PositionOutsideRegion),
|
|
6 => Ok(PreconditionFailureReason::PitchSpaceMismatch),
|
|
7 => Ok(PreconditionFailureReason::VoiceMissing),
|
|
8 => Ok(PreconditionFailureReason::ExtensionPrecondition(
|
|
registry_id(reader, ExtensionPreconditionId)?,
|
|
)),
|
|
9 => Ok(PreconditionFailureReason::Registered(registry_id(
|
|
reader,
|
|
PreconditionFailureRegistryId,
|
|
)?)),
|
|
10 => Ok(PreconditionFailureReason::ContainerNotEmpty),
|
|
11 => Ok(PreconditionFailureReason::TempoMapMalformed),
|
|
12 => Ok(PreconditionFailureReason::SystemDerivedContentImmutable),
|
|
13 => Ok(PreconditionFailureReason::RecreateContentMismatch),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "PreconditionFailureReason",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn no_op_reason(reader: &mut Reader<'_>) -> Result<NoOpReason> {
|
|
match reader.byte()? {
|
|
0 => Ok(NoOpReason::TargetTombstoned),
|
|
1 => Ok(NoOpReason::AlreadyApplied),
|
|
2 => Ok(NoOpReason::SupersededByLaterOperation {
|
|
superseder: operation_id(reader)?,
|
|
}),
|
|
3 => Ok(NoOpReason::PreconditionFailedUnderReduction {
|
|
reason: precondition_reason(reader)?,
|
|
}),
|
|
4 => Ok(NoOpReason::TransactionConflict),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "NoOpReason",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn reanchor_reason(reader: &mut Reader<'_>) -> Result<ReanchorReason> {
|
|
match reader.byte()? {
|
|
0 => Ok(ReanchorReason::SameVoiceNearer),
|
|
1 => Ok(ReanchorReason::SameStaffInstanceNearer),
|
|
2 => Ok(ReanchorReason::SameStaffNearer),
|
|
3 => Ok(ReanchorReason::SameRegionNearer),
|
|
4 => Ok(ReanchorReason::ExplicitFallback),
|
|
5 => Ok(ReanchorReason::DeclaredByExtension(registry_id(
|
|
reader,
|
|
ReanchorReasonRegistryId,
|
|
)?)),
|
|
6 => Ok(ReanchorReason::SameCanvasNearer),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ReanchorReason",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn repair_kind(reader: &mut Reader<'_>) -> Result<RepairKind> {
|
|
match reader.byte()? {
|
|
0 => Ok(RepairKind::Reanchored {
|
|
from: typed_object_id(reader)?,
|
|
to: typed_object_id(reader)?,
|
|
reason: reanchor_reason(reader)?,
|
|
}),
|
|
1 => Ok(RepairKind::SpannerTruncated {
|
|
removed_members: reader.seq(|bytes| exact(bytes, typed_object_id))?,
|
|
}),
|
|
2 => Ok(RepairKind::Orphaned),
|
|
3 => Ok(RepairKind::CascadeDeleted),
|
|
4 => Ok(RepairKind::AttachmentTombstoned),
|
|
5 => Ok(RepairKind::VoicePromoted {
|
|
from: fixed(reader, 16, "VoiceId")?,
|
|
to: fixed(reader, 16, "VoiceId")?,
|
|
}),
|
|
6 => {
|
|
let compensation_kind = match reader.byte()? {
|
|
0 => TupletCompensationKind::ReplaceWithRest,
|
|
1 => TupletCompensationKind::RewriteTuplets,
|
|
2 => TupletCompensationKind::CascadeDeleteTuplets,
|
|
tag => {
|
|
return Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "TupletCompensationKind",
|
|
tag,
|
|
})
|
|
}
|
|
};
|
|
Ok(RepairKind::TupletCompensated { compensation_kind })
|
|
}
|
|
7 => Ok(RepairKind::Registered(registry_id(
|
|
reader,
|
|
RepairKindRegistryId,
|
|
)?)),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "RepairKind",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn repair_record(reader: &mut Reader<'_>) -> Result<RepairRecord> {
|
|
Ok(RepairRecord {
|
|
kind: repair_kind(reader)?,
|
|
target: typed_object_id(reader)?,
|
|
})
|
|
}
|
|
|
|
fn operation_effect(reader: &mut Reader<'_>) -> Result<OperationEffect> {
|
|
match reader.byte()? {
|
|
0 => Ok(OperationEffect::Applied),
|
|
1 => Ok(OperationEffect::AppliedWithRepair {
|
|
repairs: reader.seq(|bytes| exact(bytes, repair_record))?,
|
|
}),
|
|
2 => Ok(OperationEffect::Conflicted {
|
|
conflict: ConflictId(reader.u128_be()?),
|
|
}),
|
|
3 => Ok(OperationEffect::TombstonedTarget {
|
|
target: typed_object_id(reader)?,
|
|
}),
|
|
4 => Ok(OperationEffect::NoOp {
|
|
reason: no_op_reason(reader)?,
|
|
}),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "OperationEffect",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn resolution_action(reader: &mut Reader<'_>) -> Result<ResolutionAction> {
|
|
match reader.byte()? {
|
|
0 => Ok(ResolutionAction::AcceptLoser),
|
|
1 => Ok(ResolutionAction::KeepWinner),
|
|
2 => Ok(ResolutionAction::Override {
|
|
override_operation: operation_id(reader)?,
|
|
}),
|
|
3 => Ok(ResolutionAction::Reanchor {
|
|
new_target: typed_object_id(reader)?,
|
|
}),
|
|
4 => Ok(ResolutionAction::Dismiss),
|
|
5 => Ok(ResolutionAction::Registered(registry_id(
|
|
reader,
|
|
ResolutionRegistryId,
|
|
)?)),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ResolutionAction",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn conflict_resolution(reader: &mut Reader<'_>) -> Result<ConflictResolutionState> {
|
|
match reader.byte()? {
|
|
0 => Ok(ConflictResolutionState::Unresolved),
|
|
1 => Ok(ConflictResolutionState::Resolved {
|
|
by: operation_id(reader)?,
|
|
action: resolution_action(reader)?,
|
|
}),
|
|
2 => Ok(ConflictResolutionState::Dismissed {
|
|
by: operation_id(reader)?,
|
|
}),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ConflictResolutionState",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn conflict_kind(reader: &mut Reader<'_>) -> Result<ConflictKind> {
|
|
match reader.byte()? {
|
|
0 => Ok(ConflictKind::StructuralFieldCollision {
|
|
winner: operation_id(reader)?,
|
|
loser: operation_id(reader)?,
|
|
field: crate::FieldPath(
|
|
std::str::from_utf8(reader.lp_bytes()?)
|
|
.map_err(|_| MaterializedDecodeError::InvalidUtf8)?
|
|
.to_owned(),
|
|
),
|
|
}),
|
|
1 => Ok(ConflictKind::TransactionConflict {
|
|
transaction: fixed(reader, 16, "TransactionId")?,
|
|
failed_members: reader.seq(|bytes| exact(bytes, operation_id))?,
|
|
}),
|
|
2 => Ok(ConflictKind::TombstonedTarget {
|
|
target: typed_object_id(reader)?,
|
|
operation: operation_id(reader)?,
|
|
}),
|
|
3 => Ok(ConflictKind::ReanchorFailure {
|
|
original_referent: typed_object_id(reader)?,
|
|
referencing_object: typed_object_id(reader)?,
|
|
}),
|
|
4 => Ok(ConflictKind::TimeModelMigrationFailure {
|
|
region: fixed(reader, 16, "RegionId")?,
|
|
incompatible_events: reader.seq(|bytes| exact(bytes, typed_object_id))?,
|
|
}),
|
|
5 => Ok(ConflictKind::ExtensionConflict {
|
|
kind_id: registry_id(reader, ConflictKindRegistryId)?,
|
|
details: reader.lp_bytes()?.to_vec(),
|
|
}),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ConflictKind",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn conflict_record(reader: &mut Reader<'_>) -> Result<ConflictRecord> {
|
|
let record = ConflictRecord {
|
|
id: ConflictId(reader.u128_be()?),
|
|
caused_by: reader.seq(|bytes| exact(bytes, operation_id))?,
|
|
kind: conflict_kind(reader)?,
|
|
affected_objects: reader.seq(|bytes| exact(bytes, typed_object_id))?,
|
|
resolution_state: conflict_resolution(reader)?,
|
|
};
|
|
let ordered_ops = record.caused_by.windows(2).all(|pair| pair[0] < pair[1]);
|
|
let ordered_objects = record
|
|
.affected_objects
|
|
.windows(2)
|
|
.all(|pair| pair[0] < pair[1]);
|
|
let expected_id =
|
|
crate::derive_conflict_id(&record.kind, &record.caused_by, &record.affected_objects);
|
|
if !ordered_ops || !ordered_objects || record.id != expected_id {
|
|
return Err(MaterializedDecodeError::NonCanonical);
|
|
}
|
|
Ok(record)
|
|
}
|
|
|
|
fn object_kind(reader: &mut Reader<'_>) -> Result<ObjectKind> {
|
|
match reader.byte()? {
|
|
0 => Ok(ObjectKind::Voice),
|
|
1 => Ok(ObjectKind::Pitch),
|
|
2 => Ok(ObjectKind::Registered(registry_id(
|
|
reader,
|
|
crate::OperationKindRegistryId,
|
|
)?)),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "ObjectKind",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn integrity_anomaly_kind(reader: &mut Reader<'_>) -> Result<IntegrityAnomalyKind> {
|
|
match reader.byte()? {
|
|
0 => Ok(IntegrityAnomalyKind::SystemIdentifierCollision {
|
|
kind: object_kind(reader)?,
|
|
colliding_counter: reader.u64_le()?,
|
|
input_set_a: SerializedCanonicalInputs(reader.lp_bytes()?.to_vec()),
|
|
input_set_b: SerializedCanonicalInputs(reader.lp_bytes()?.to_vec()),
|
|
}),
|
|
1 => Ok(IntegrityAnomalyKind::OperationSlotEquivocated {
|
|
operation_id: operation_id(reader)?,
|
|
}),
|
|
2 => Ok(IntegrityAnomalyKind::ReplicaStreamQuarantined {
|
|
replica: fixed(reader, 8, "ReplicaId")?,
|
|
first_bad_counter: reader.u64_le()?,
|
|
}),
|
|
3 => Ok(IntegrityAnomalyKind::Registered(registry_id(
|
|
reader,
|
|
IntegrityAnomalyRegistryId,
|
|
)?)),
|
|
tag => Err(MaterializedDecodeError::InvalidTag {
|
|
kind: "IntegrityAnomalyKind",
|
|
tag,
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn integrity_anomaly(reader: &mut Reader<'_>) -> Result<IntegrityAnomaly> {
|
|
let anomaly = IntegrityAnomaly {
|
|
id: fixed(reader, 16, "IntegrityAnomalyId")?,
|
|
kind: integrity_anomaly_kind(reader)?,
|
|
};
|
|
if IntegrityAnomaly::new(anomaly.kind.clone()).id != anomaly.id {
|
|
return Err(MaterializedDecodeError::NonCanonical);
|
|
}
|
|
Ok(anomaly)
|
|
}
|
|
|
|
pub(crate) fn decode_materialized_state(bytes: &[u8]) -> Result<MaterializedState> {
|
|
let mut reader = Reader::new(bytes);
|
|
|
|
let effect_count = reader.len()?;
|
|
let mut effects = Vec::with_capacity(effect_count.min(1024));
|
|
for _ in 0..effect_count {
|
|
let id = operation_id(&mut reader)?;
|
|
let effect = exact(reader.lp_bytes()?, operation_effect)?;
|
|
effects.push((id, effect));
|
|
}
|
|
|
|
let records = reader.seq(|bytes| exact(bytes, conflict_record))?;
|
|
let mut conflicts = ConflictRegistry::new();
|
|
for record in records {
|
|
conflicts.insert(record);
|
|
}
|
|
|
|
let anomaly_count = reader.len()?;
|
|
let mut anomalies = Vec::with_capacity(anomaly_count.min(1024));
|
|
for _ in 0..anomaly_count {
|
|
anomalies.push(exact(reader.lp_bytes()?, integrity_anomaly)?);
|
|
}
|
|
if !anomalies.windows(2).all(|pair| pair[0].id < pair[1].id) {
|
|
return Err(MaterializedDecodeError::NonCanonical);
|
|
}
|
|
|
|
let object_count = reader.len()?;
|
|
let mut objects = BTreeMap::new();
|
|
for _ in 0..object_count {
|
|
objects.insert(typed_object_id(&mut reader)?, object_state(&mut reader)?);
|
|
}
|
|
|
|
let spelling_count = reader.len()?;
|
|
let mut spellings = BTreeMap::new();
|
|
for _ in 0..spelling_count {
|
|
let pitch = fixed::<PitchId>(&mut reader, 16, "PitchId")?;
|
|
// The value is the full PitchSpelling (v1), encoded behind a u32 length
|
|
// prefix via its canonical value bytes.
|
|
let spelling = PitchSpelling::decode_canonical(reader.lp_bytes()?)
|
|
.map_err(|_| MaterializedDecodeError::InvalidValue("PitchSpelling"))?;
|
|
spellings.insert(pitch, spelling);
|
|
}
|
|
|
|
let break_count = reader.len()?;
|
|
let mut breaks = BTreeMap::new();
|
|
for _ in 0..break_count {
|
|
let region = fixed::<RegionId>(&mut reader, 16, "RegionId")?;
|
|
let anchor = musical_position(&mut reader)?;
|
|
let present = match reader.byte()? {
|
|
0 => false,
|
|
1 => true,
|
|
value => return Err(MaterializedDecodeError::InvalidBoolean(value)),
|
|
};
|
|
breaks.insert((region, anchor), present);
|
|
}
|
|
|
|
let page_break_count = reader.len()?;
|
|
let mut page_breaks = BTreeMap::new();
|
|
for _ in 0..page_break_count {
|
|
let region = fixed::<RegionId>(&mut reader, 16, "RegionId")?;
|
|
let anchor = musical_position(&mut reader)?;
|
|
let present = match reader.byte()? {
|
|
0 => false,
|
|
1 => true,
|
|
value => return Err(MaterializedDecodeError::InvalidBoolean(value)),
|
|
};
|
|
page_breaks.insert((region, anchor), present);
|
|
}
|
|
|
|
let pending_count = reader.len()?;
|
|
let mut pending = Vec::with_capacity(pending_count.min(1024));
|
|
for _ in 0..pending_count {
|
|
pending.push((operation_id(&mut reader)?, pending_reason(&mut reader)?));
|
|
}
|
|
if !pending.windows(2).all(|pair| pair[0].0 < pair[1].0) {
|
|
return Err(MaterializedDecodeError::NonCanonical);
|
|
}
|
|
reader.finish()?;
|
|
|
|
let state = MaterializedState {
|
|
effects,
|
|
conflicts,
|
|
anomalies,
|
|
objects,
|
|
spellings,
|
|
breaks,
|
|
page_breaks,
|
|
pending,
|
|
};
|
|
if state.canonical_bytes() != bytes {
|
|
return Err(MaterializedDecodeError::NonCanonical);
|
|
}
|
|
Ok(state)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use epiphany_determinism::fuzz::SplitMix64;
|
|
|
|
#[test]
|
|
fn reduced_states_decode_and_reencode() {
|
|
let mut rng = SplitMix64::new(0xDEC0_DED5);
|
|
for _ in 0..500 {
|
|
let envelopes = crate::fuzz::gen_envelope_set(&mut rng, 20);
|
|
let mut set = crate::OperationSet::new();
|
|
set.accept_all(envelopes);
|
|
let state = set.reduce();
|
|
let bytes = state.canonical_bytes();
|
|
let decoded = MaterializedState::decode_canonical(&bytes).unwrap();
|
|
assert_eq!(decoded.canonical_bytes(), bytes);
|
|
assert_eq!(decoded, state);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn pass12_appended_discriminants_decode() {
|
|
assert_eq!(
|
|
exact(&[12], precondition_reason).unwrap(),
|
|
PreconditionFailureReason::SystemDerivedContentImmutable
|
|
);
|
|
assert_eq!(
|
|
exact(&[13], precondition_reason).unwrap(),
|
|
PreconditionFailureReason::RecreateContentMismatch
|
|
);
|
|
assert_eq!(
|
|
exact(&[6], reanchor_reason).unwrap(),
|
|
ReanchorReason::SameCanvasNearer
|
|
);
|
|
// The vocabularies stay bounded: one past the append rejects.
|
|
assert!(exact(&[14], precondition_reason).is_err());
|
|
assert!(exact(&[7], reanchor_reason).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn decoder_rejects_truncation_and_trailing_bytes() {
|
|
let bytes = MaterializedState::default().canonical_bytes();
|
|
assert!(MaterializedState::decode_canonical(&bytes[..bytes.len() - 1]).is_err());
|
|
let mut trailing = bytes;
|
|
trailing.push(0);
|
|
assert_eq!(
|
|
MaterializedState::decode_canonical(&trailing),
|
|
Err(MaterializedDecodeError::TrailingBytes)
|
|
);
|
|
}
|
|
}
|