Trait Model

pub trait Model: Sized + 'static {
    type Paths<R>: Clone;

    const SHAPE: Shape = crate::Shape::Value;
    const CHECKS: bool = false;
    const OPS: bool = false;
    const NULLABLE: bool = false;
    const SCALAR: bool = false;
    const TABLE: &'static ModelTable = _;
Show 23 methods
    // Required methods
    fn paths_at<R>(path: Path<R, Self>) -> Self::Paths<R>;
    fn to_json(&self) -> Value;
    fn from_json(value: &Value) -> Result<Self, ModelError>;
    fn load(
        doc: &AutoCommit,
        value: &Value<'_>,
        id: &ExId,
    ) -> Result<Self, ModelError>;
    fn store(
        &self,
        doc: &mut AutoCommit,
        slot: Slot<'_>,
    ) -> Result<(), ModelError>;

    // Provided methods
    fn edit(
        doc: &mut AutoCommit,
        slot: Slot<'_>,
        path: &[Segment],
        op: &EditOp,
        cx: &mut ActionCx,
    ) -> Result<(), ModelError> { ... }
    fn diff<R>(&self, after: &Self, path: &[Segment], out: &mut Vec<Edit<R>>) { ... }
    fn nested_collections(&self) -> Vec<ItemCollection> { ... }
    fn value_schema() -> Value { ... }
    fn read_whole(&mut self, doc: &AutoCommit) -> Result<(), ModelError> { ... }
    fn check(&self) -> Result<(), Refusal> { ... }
    fn label(&self) -> Option<String> { ... }
    fn op_coalesces(
        path: &[Segment],
        previous: &Value,
        next: &Value,
    ) -> Option<bool> { ... }
    fn op_continuable(path: &[Segment], op: &Value) -> Option<bool> { ... }
    fn op_describe(path: &[Segment], op: &Value) -> Option<OpDescription> { ... }
    fn op_lands(&self, path: &[Segment], op: &Value) -> Option<Place> { ... }
    fn op_schemas(prefix: &str, out: &mut Vec<(String, Value)>) { ... }
    fn get_at(&self, path: &[Segment]) -> Option<&(dyn Any + 'static)>
       where Self: 'static { ... }
    fn missing() -> Result<Self, ModelError> { ... }
    fn stores_as(&self, before: &Self) -> bool { ... }
    fn store_changed(
        &self,
        before: &Self,
        doc: &mut AutoCommit,
        slot: Slot<'_>,
        dirty: &Delta,
    ) -> Result<(), ModelError> { ... }
    fn refresh(
        &mut self,
        doc: &AutoCommit,
        value: &Value<'_>,
        id: &ExId,
        delta: &Delta,
    ) -> Result<(), ModelError> { ... }
    fn collect_text(&self, _out: &mut Vec<String>) { ... }
}

Expand description

A typed value stored in a CRDT document. See the module docs.

Provided Associated Constants§

const SHAPE: Shape = crate::Shape::Value

How the value is laid out in the document; see Shape. Types written whole keep the default.

const CHECKS: bool = false

Whether this type or any value inside it has a #[model(check)] invariant; Self::check has nothing to do otherwise.

const OPS: bool = false

Whether this type or a value inside it has a vocabulary of its own (Operations, rich text’s): a record routes those edits’ gestures, landing places and schemas only into such fields, and never instantiates the routing for the others.

const NULLABLE: bool = false

Whether null is a value of the type: an absent Option. A field edit setting any other type to null is refused.

const SCALAR: bool = false

Whether store writes one scalar, with nothing inside it that a concurrent writer could add to. A record made just now leaves out such a field holding its missing value: an absent key reads as it. An object (text, a map, a list) is always made with its record, so two writers fill the same one.

const TABLE: &'static ModelTable = _

The type’s functions as data, which a record holding it reaches it through ([crate::table]): by default its own functions, erased.

Required Associated Types§

type Paths<R>: Clone

The typed paths into a value of this type, rooted in the record R: a struct of field paths for a record, the Path itself for a value edited whole or through its own operations.

Required Methods§

fn paths_at<R>(path: Path<R, Self>) -> Self::Paths<R>

The paths of the value at path.

fn to_json(&self) -> Value

The value as JSON: what [EditOp::Set] carries and history shows.

fn from_json(value: &Value) -> Result<Self, ModelError>

A value from its Self::to_json form.

§Errors

Returns [ModelError] when value has another shape.

fn load( doc: &AutoCommit, value: &Value<'_>, id: &ExId, ) -> Result<Self, ModelError>

Read from the value a parent found in its slot.

§Errors

Returns [ModelError] when the stored value has another shape.

fn store(&self, doc: &mut AutoCommit, slot: Slot<'_>) -> Result<(), ModelError>

Write self into slot, changing only what differs from what the slot already holds.

§Errors

Returns the document’s write error.

Provided Methods§

fn edit( doc: &mut AutoCommit, slot: Slot<'_>, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path, below the value in slot, touching only what it changes, then run the invariants of the values it touched. The default edits a value only as a whole.

§Errors

Returns why the path or operation does not fit, or a refusal.

fn diff<R>(&self, after: &Self, path: &[Segment], out: &mut Vec<Edit<R>>)

The field edits that turn self into after, at path below the record: what a surface that edited a local copy submits. The default sets the value whole when it changed; containers and records edit only what differs, item by item and field by field.

fn nested_collections(&self) -> Vec<ItemCollection>

The item collections inside this value, when it is an item of a collection itself (a slide’s elements); #[derive(Model)] lists a record’s, the default has none.

fn value_schema() -> Value

The JSON Schema of this value’s JSON form (Self::to_json), as the published field edit describes what a path takes; the default accepts any value.

fn read_whole(&mut self, doc: &AutoCommit) -> Result<(), ModelError>

Read everything this value holds, for a field marked #[model(whole)]: a value read lazily (rich text reads its paragraphs as views ask for them) reads all of it, so every reader of the record — a verb, search, read_content — sees all of it. The default has nothing more to read.

§Errors

Returns [ModelError] when the document no longer holds the value.

fn check(&self) -> Result<(), Refusal>

Run every #[model(check)] invariant of this value and the values inside it.

§Errors

Returns the first refusal.

fn label(&self) -> Option<String>

What names this value for people (#[model(label)]): history, search, agents and item resources use it.

fn op_coalesces( path: &[Segment], previous: &Value, next: &Value, ) -> Option<bool>

Whether two edits in the own vocabulary of the value at path below this type are one gesture (Operations); None when nothing there has one.

fn op_continuable(path: &[Segment], op: &Value) -> Option<bool>

Whether a gesture may go on after the edit op at path.

fn op_describe(path: &[Segment], op: &Value) -> Option<OpDescription>

What the edit op at path below this type did, in the history entry’s terms (Operations::describe).

fn op_lands(&self, path: &[Segment], op: &Value) -> Option<Place>

Where the actor of the edit op at path below this value is after it applied.

fn op_schemas(prefix: &str, out: &mut Vec<(String, Value)>)

The schemas of the own vocabularies of the values below this type, by path pattern from prefix (* for every item).

fn get_at(&self, path: &[Segment]) -> Option<&(dyn Any + 'static)>
where Self: 'static,

The value at path below this one, if it is there. A value with nothing inside it is found only at the empty path.

fn missing() -> Result<Self, ModelError>

The value of an absent slot. Types with a natural empty value return it, so a field added to a schema reads older documents without migration.

§Errors

Returns [ModelError::Missing] for types without an empty value.

fn stores_as(&self, before: &Self) -> bool

Whether writing self over a slot that holds before, as a store left it, would change nothing: an in-memory comparison, so an action that changed one item of a long collection does not visit the others. Must only answer true when store would write no operation; the default answers false (unknown).

fn store_changed( &self, before: &Self, doc: &mut AutoCommit, slot: Slot<'_>, dirty: &Delta, ) -> Result<(), ModelError>

Write self into slot, which holds before: exactly the operations store would write, found by comparing with before where store would read the document.

before is what load reads from the slot now, and the slot is as a store left it except where dirty (changes written by someone else since) says otherwise: a slot dirty touched is written as store would. The default is store. An action’s write is replayed on every replica, so an override that writes anything else forks the document.

§Errors

Returns the document’s write error.

fn refresh( &mut self, doc: &AutoCommit, value: &Value<'_>, id: &ExId, delta: &Delta, ) -> Result<(), ModelError>

Bring a value read earlier up to date after the changes in delta, re-reading only what they touched. value and id are what the parent’s slot holds now — the same object as when self was read, or the parent would have read it anew. The default reads the value again, which is right for scalars and short values.