Enum Conflict 

#[non_exhaustive]
pub enum Conflict {
    StaleRevision {
        expected: u64,
        found: u64,
    },
    MissingTarget {
        edit: usize,
        id: EntityId,
    },
    IdAlreadyExists {
        edit: usize,
        id: EntityId,
    },
    DanglingReference {
        edit: usize,
        from: EntityId,
        slot: usize,
        target: EntityId,
    },
    RemovalWouldDangle {
        edit: usize,
        removed: EntityId,
        referrer: EntityId,
        slot: usize,
    },
}

A reason a transaction cannot be committed.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

StaleRevision

The model changed since the transaction was opened.

Optimistic concurrency: two editors read the same model, both plan edits, and the second to commit is working from a view that no longer exists. Rejecting is the only safe answer – the second editor’s preflight was computed against state that has since moved.

Fields

expected: u64

The revision the transaction was opened against.

found: u64

The revision the model is actually at.

MissingTarget

An edit names an entity that does not exist and is not being created.

Fields

edit: usize

Position of the offending edit within the transaction.

id: EntityId

The id it named.

IdAlreadyExists

An insert would overwrite an entity that already exists.

crate::Model::insert deliberately replaces, because a codec re-reading a file must be able to. A transaction refuses instead: an author who did not mean to destroy an entity gets told, rather than discovering it later in a diff.

Fields

edit: usize

Position of the offending edit.

id: EntityId

The id it tried to occupy.

DanglingReference

An edit writes a reference to an entity that will not exist.

Checked against the PROJECTED model, so referencing an entity the same transaction creates is fine, and referencing one it removes is not.

Fields

edit: usize

Position of the offending edit.

from: EntityId

The entity that would hold the bad reference.

slot: usize

The attribute slot it would sit in.

target: EntityId

The target that would not exist.

RemovalWouldDangle

A removal would leave a surviving entity pointing at nothing.

crate::Model::remove permits this and documents it; a transaction does not. Deleting a storey that walls still reference produces a file that parses and is wrong, which is worse than a refused edit.

The fix is to include the referrers’ updates in the same transaction, which is exactly what the projected check allows.

Fields

edit: usize

Position of the offending removal.

removed: EntityId

The entity being removed.

referrer: EntityId

A surviving entity that still references it.

slot: usize

The slot the surviving reference sits in.

Trait Implementations

impl Clone for Conflict

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Conflict

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

Formats the value using the given formatter.

impl Display for Conflict

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

Formats the value using the given formatter.

impl Eq for Conflict

impl Error for Conflict

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for Conflict

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Conflict