Struct Replica 

pub struct Replica<R>
where
    R: Resource,
{ /* private fields */ }

One replica of an R resource. See the module docs.

Implementations

impl<R> Replica<R>

where R: Resource,

pub fn new() -> Replica<R>

A new resource, initialized as a new record would be.

Panics

Panics when Resource::initialize fails, which is a bug in the resource type under test.

pub fn from_doc(doc: AutoCommit) -> Replica<R>

A replica of an existing document.

pub fn load(bytes: &[u8]) -> Result<Replica<R>, ModelError>

A replica of a document saved as bytes: a file’s contents.

Errors

Returns [ModelError::Automerge] when the bytes hold no document.

pub fn save(&mut self) -> Vec<u8>

The document as bytes, for a file that carries the resource whole.

pub fn as_author(self, author: &str) -> Replica<R>

Attribute later actions to author, as the host does for a signed-in collaborator.

pub fn as_invoker(self, author: &str) -> Replica<R>

Attribute later actions to author invoking from this replica, as the host does for a person at one of their devices: what a verb reads as ActionCx::author, while the changes stay this replica’s own, so the same person on two replicas makes changes that merge.

pub fn as_agent_for(self, agent: &str, person: &str) -> Replica<R>

Attribute later actions to the agent agent acting for person, as a host does for an agent’s calls.

pub fn as_bot_for(self, installation: &str, installer: &str) -> Replica<R>

Attribute later actions to the bot installation installation acting for installer, as a bot host does for a bot’s calls.

pub fn showing(self, appearance: Appearance) -> Replica<R>

Show appearance for the bot’s later actions, as a bot host admits a bridge’s post under another name.

pub fn in_app(self, id: &str, label: &str) -> Replica<R>

Name id (labelled label) as the app later actions are in, as the host running the app does: every member decides them against that app’s surface.

pub fn set_now_ms(&mut self, now_ms: i64)

Set the origin clock later actions are stamped with.

pub fn published(&self) -> Result<Resource, ModelError>

The tree the resource publishes now: what the door resolves against.

Errors

Returns [ModelError] when the document does not hold the resource.

pub fn apply( &mut self, invoke: impl Into<Invoke<R>>, ) -> Result<&ActionEnvelope, DoorError>

Invoke a published action exactly as a control, the palette, an agent or a script does: through the door, which refuses one that asks for confirmation (Self::apply_confirmed).

Errors

Returns the door’s refusal: unknown, unavailable, invalid arguments, confirmation required, or the action’s own refusal.

pub fn apply_confirmed( &mut self, invoke: impl Into<Invoke<R>>, ) -> Result<&ActionEnvelope, DoorError>

Self::apply after the person confirmed it.

Errors

As Self::apply, without asking for confirmation.

pub fn apply_action( &mut self, action: &<R as Resource>::Action, ) -> Result<&ActionEnvelope, DoorError>

Apply one typed action value, the path a custom surface takes once its person confirmed what it does: the generic APPLY action, through the door.

Errors

Returns the door’s refusal or the action’s own.

pub fn replay(&mut self, envelope: &ActionEnvelope) -> Result<(), ActionError>

Replay an envelope authored on another replica.

Errors

Returns a decode or apply error.

pub fn state(&self) -> Result<<R as Resource>::State, ModelError>

The current state.

Errors

Returns [ModelError] when the document does not hold the resource.

pub fn live(&mut self) -> Result<&<R as Resource>::State, ModelError>

The state as a view sees it: read once, then kept current by applying only what each change touched (Resource::refresh) and reading what is demanded (Resource::load). A test comparing it with Self::state proves the resource’s incremental reads exact.

Errors

Returns [ModelError] when the document does not hold the resource.

pub fn demand( &mut self, demand: Demand, ) -> Result<&<R as Resource>::State, ModelError>

where <R as Resource>::State: Clone,

Ask the view state of Self::live for the parts demand names.

Errors

Returns [ModelError] when the document does not hold the resource.

pub fn fork(&mut self) -> Replica<R>

A second replica sharing this one’s history, as a collaborator who just joined would hold.

pub fn sync_with(&mut self, other: &mut Replica<R>) -> Result<(), ModelError>

Exchange every change with other, as sync does.

Errors

Returns a document error.

pub fn log(&self) -> &[ActionEnvelope]

Every envelope applied or replayed here, in order.

pub fn doc(&self) -> &AutoCommit

pub fn doc_mut(&mut self) -> &mut AutoCommit

The document, for a test that changes it the way something outside the resource’s actions would (a restore, a raw merge).

pub fn heads(&mut self) -> Vec<ChangeHash>

pub fn versions(&mut self) -> Vec<Version>

The version history.

pub fn state_at( &mut self, heads: &[ChangeHash], ) -> Result<<R as Resource>::State, ModelError>

The state as of heads.

Errors

Returns [ModelError] when that version does not hold the resource.

Trait Implementations

impl<R> Default for Replica<R>

where R: Resource,

fn default() -> Replica<R>

Returns the “default value” for a type.