Enum DocumentState 

pub enum DocumentState {
    Draft,
    Review,
    Frozen,
    Published,
}

Document lifecycle state.

Documents progress through states that determine what operations are allowed and what integrity guarantees are enforced.

Variants

Draft

Active editing state.

• Content can be freely modified
• Document ID may be “pending”
• No signatures required

Review

Review/approval state.

• Content can still be modified
• Document ID should be computed
• Signatures optional

Frozen

Immutable state.

• Content cannot be modified
• Document ID must be computed and valid
• At least one signature required
• Lineage required (parent required only if forked)

Published

Distribution state.

• Same immutability as frozen
• Indicates document is ready for public distribution
• At least one signature required
• Lineage required (parent required only if forked)

Implementations

impl DocumentState

pub const fn is_editable(&self) -> bool

Returns whether the document content can be modified in this state.

pub const fn is_immutable(&self) -> bool

Returns whether the document is immutable in this state.

pub const fn requires_signature(&self) -> bool

Returns whether signatures are required in this state.

pub const fn requires_lineage(&self) -> bool

Returns whether lineage may be required in this state.

Per spec, lineage is mandatory for forked documents (those with a parent) in Frozen/Published states. Root documents can transition to these states without lineage. This method indicates the state where lineage requirements apply; actual enforcement depends on whether the document is forked.

pub const fn requires_computed_id(&self) -> bool

Returns whether the document ID must be computed (not “pending”).

pub const fn requires_precise_layout(&self) -> bool

Returns whether a precise layout is required in this state.

Frozen and published documents require at least one precise layout to ensure exact visual reproduction as part of the immutable record.

pub const fn can_transition_to(&self, target: Self) -> bool

Check if transitioning to the target state is valid.

pub const fn valid_transitions(&self) -> &'static [DocumentState]

Get all valid target states from the current state.

Trait Implementations

impl Clone for DocumentState

fn clone(&self) -> DocumentState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DocumentState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DocumentState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DocumentState

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

Formats the value using the given formatter.

impl FromStr for DocumentState

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DocumentState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DocumentState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DocumentState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for DocumentState

impl Eq for DocumentState

impl StructuralPartialEq for DocumentState