Struct Edits 

pub struct Edits<'a> { /* private fields */ }

The document as a host lends it to one pass that may change it: read freely, changed only through a typed action the action host applies (a resource’s dispatcher applies it), so every change is an action that is attributed, recorded in history and undone like any other. Direct CRDT mutation is rejected at the widget boundary:

use automerge::{ROOT, transaction::Transactable};
use tilo_ui::widget::Edits;
fn bypass(edits: &mut Edits<'_>) {
    edits.put(ROOT, "bypass", true).unwrap();
}

Implementations

impl<'a> Edits<'a>

pub fn doc(&self) -> &AutoCommit

The document as it stands, with what this pass applied.

pub fn reborrow(&mut self) -> Edits<'_>

The same document, lent on to a part of the pass.

Methods from Deref<Target = AutoCommit>

pub fn diff_opset(&self, other: &AutoCommit) -> Result<(), AutomergeError>

pub fn diff_cursor(&self) -> Vec<ChangeHash>

Returns the cursor set by Self::update_diff_cursor()

pub fn make_patches(&self, patch_log: &mut PatchLog) -> Vec<Patch>

Generate the patches recorded in patch_log

pub fn committed_document(&self) -> &Automerge

The committed document: everything but the changes of a transaction still open. Reads it without closing that transaction, so a holder of &self can read history; a host that commits before handing the document out sees all of it.

pub fn committed_heads(&self) -> Vec<ChangeHash>

The heads of the committed document (Self::committed_document), or of the isolated view when the document is isolated: what Self::get_heads answers once no transaction is open.

pub fn committed_fork_at( &self, heads: &[ChangeHash], ) -> Result<AutoCommit, AutomergeError>

A copy of the committed document (Self::committed_document) as it was at heads: what Self::fork_at makes, read from &self.

pub fn committed_diff( &self, before: &[ChangeHash], after: &[ChangeHash], ) -> Vec<Patch>

The patches from before to after in the committed document (Self::committed_document), without the diff cursor or cache Self::diff keeps.

pub fn get_actor(&self) -> &ActorId

pub fn get_actors_for_author(&self, author: &Author<'_>) -> Vec<ActorId>

pub fn get_author_for_actor(&self, actor: &ActorId) -> Option<Author<'_>>

pub fn get_author(&self) -> Option<&Author<'static>>

pub fn get_authors(&self) -> &[Author<'static>]

pub fn bundle<I>(&self, hashes: I) -> Result<Bundle, AutomergeError>

where I: IntoIterator<Item = ChangeHash>,

EXPERIMENTAL: Write the set of changes in hashes to a “bundle”

A “bundle” is a compact representation of a set of changes which uses the same compression tricks as the document encoding we use in Automerge::save.

This is an experimental API, the bundle format is still subject to change and so should not be used in production just yet.

pub fn is_empty(&self) -> bool

pub fn hash_for_opid(&self, opid: &ExId) -> Option<ChangeHash>

Get the hash of the change that contains the given opid.

Returns None if the opid:

• Is the root object id
• Does not exist in this document
• Is for an operation in a transaction

Trait Implementations

impl Deref for Edits<'_>

type Target = AutoCommit

The resulting type after dereferencing.

fn deref(&self) -> &<Edits<'_> as Deref>::Target

Dereferences the value.