Struct Unit 

pub struct Unit { /* private fields */ }

A single unit of compacted context, addressed by its derivation.

Constructed only by Unit::seal or by admitting a RawUnit. Serialises (so it can be stored and hashed) but does not deserialise (so the admission boundary cannot be walked around).

Implementations

impl Unit

pub fn seal( op: Op, source: &[u8], span: Span, root: ContentId, ) -> Result<Self, SealError>

Seal one unit over SOURCE material.

The source bytes are required — not a convenience, the whole point. A unit cannot be minted without the material it addresses, so there is no way to produce one whose elided claim was never computed from anything.

Errors

SealError::NotMintableInV0 for any operation other than Op::Elide; SealError::UnaddressedSpan for a span covering no bytes; SealError::SpanOutOfSource when the span runs past the source.

pub const fn derivation(&self) -> &Derivation

The addressed fact this unit’s identity is computed over.

pub fn id(&self) -> Result<UnitId, ContentError>

This unit’s address: the id of its Derivation.

Errors

Propagates an encoding failure from the canonical form.

pub const fn op(&self) -> Op

What was done to the source material.

pub const fn depth(&self) -> u32

Generation provenance depth: 0 for source material, one more per generation.

pub const fn root(&self) -> ContentId

The root event this unit is caused by.

pub const fn life(&self) -> Life

The lifecycle of this unit’s root.

pub const fn is_well_formed(&self) -> bool

The depth bound: depth <= 1.

pub const fn evictable(&self) -> bool

A unit is freely evictable when its root is no longer live.

Deterministic: no grounding check, no model call, no judgement.

pub const fn with_life(self, life: Life) -> Self

Mark this unit’s root as no longer live.

Deliberately does not change Unit::id: lifecycle is a fact about a derivation, not a different derivation.

pub const fn to_raw(&self) -> RawUnit

The transparent form, for encoding to bytes another process will decode.

Trait Implementations

impl Clone for Unit

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ContentAddressable for Unit

fn canonical_form(&self) -> Result<Vec<u8>, ContentError>

The canonical form is the derivation’s, so a unit’s bytes and its id agree with Unit::id.

fn content_id(&self) -> Result<ContentId, ContentError>

Compute this value’s ContentId.

fn verify(&self, expected: &ContentId) -> Result<bool, ContentError>

Check whether this value’s content id matches an expected id.

fn ensure_content_id(&self, expected: &ContentId) -> Result<(), ContentError>

Verify, returning an error on mismatch instead of Ok(false).

impl Copy for Unit

impl Debug for Unit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Unit

impl PartialEq for Unit

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Unit

A Unit encodes exactly as its RawUnit, so what this process writes is what another process decodes — and what it decodes must then pass admission. Written by hand rather than derived: #[serde(flatten)] over the derivation would be a second, silently different layout, and deny_unknown_fields does not compose with it.

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Unit

impl TryFrom<RawUnit> for Unit

fn try_from(raw: RawUnit) -> Result<Self, Self::Error>

The only way in from foreign bytes.

Errors

See AdmitError. Span-versus-source is checked by crate::verify, which needs the bytes this function does not have.

type Error = AdmitError

The type returned in the event of a conversion error.