Struct AttachedView 

pub struct AttachedView { /* private fields */ }

One record held in its app’s view, attached and never drawn. See the module docs.

Implementations

impl AttachedView

pub fn open( definition: &'static ApplicationDefinition, workspace: &str, checkout: RecordCheckout, document: Vec<u8>, me: &str, permissions: PermissionContext, created: bool, ) -> Result<Self, String>

Mount definition’s view over the record document holds in workspace, for me with permissions. created when me just created the record, so the first Self::take_changes sends it whole.

pub fn open_for( definition: &'static ApplicationDefinition, workspace: &str, checkout: RecordCheckout, document: Vec<u8>, invoker: &ActionInvoker, permissions: PermissionContext, created: bool, ) -> Result<Self, String>

Self::open for invoker — an agent, say, which may act for a person — rather than a person by their id alone. Its changes are written under the record writer’s actor for its handle on this host.

Errors

As Self::open.

pub fn opening<'a>( definition: &'static ApplicationDefinition, workspace: &'a str, checkout: RecordCheckout, document: Vec<u8>, ) -> OpenView<'a>

The view of definition over the record document holds in workspace, to open once said for whom, with what and what the host lends it (OpenView).

pub const fn definition(&self) -> &'static ApplicationDefinition

The app whose view this is.

pub const fn checkout(&self) -> &RecordCheckout

pub fn me(&self) -> &str

Who acts through the view.

pub fn set_permissions(&mut self, permissions: PermissionContext)

The participant’s permissions changed: a role granted or taken away.

pub fn resources(&self) -> Vec<ResourceSpec>

The tree the view publishes, as the participant may reach it.

pub fn operations(&self) -> Vec<ActionDescriptor>

Every document operation the participant may perform through the view now, with its typed parameters.

pub fn invoke( &mut self, address: &ActionAddress, arguments: &Map<String, Value>, confirmed: bool, ) -> Result<ActionOutput, DoorError>

Perform the operation address names through the view, for the participant: permission, confirmation and strict argument binding exactly as for a person’s click (confirmed when the person it acts for confirmed it). The change it made leaves with Self::take_changes.

pub fn invoke_appearing( &mut self, address: &ActionAddress, arguments: &Map<String, Value>, confirmed: bool, appearance: Option<Appearance>, ) -> Result<ActionOutput, DoorError>

Self::invoke showing appearance, which the door already admitted for this one invocation. None clears any appearance the view’s context carried: only a door sets one.

Errors

As Self::invoke.

pub fn invoker_appearing(&self, appearance: Option<Appearance>) -> ActionInvoker

Whom Self::invoke_appearing admits an operation for: the participant, or the person the task says it acts for now, showing appearance.

pub fn invoke_as( &mut self, invoker: ActionInvoker, address: &ActionAddress, arguments: &Map<String, Value>, confirmed: bool, ) -> Result<ActionOutput, DoorError>

Self::invoke for invoker, whom the host admitted for this one invocation (an agent’s, delivered to the app that owns the record): the operation and every edit it makes are theirs. Any operation the view offers — a document action, or an edit at the invoker’s own caret.

Errors

As Self::invoke.

pub fn invoke_as_awaiting( &mut self, invoker: ActionInvoker, address: &ActionAddress, arguments: &Map<String, Value>, confirmed: bool, within: Duration, ) -> Result<ActionOutput, DoorError>

Self::invoke_as, waiting up to within for an operation that runs as a job (rendering a picture, exporting a file’s worth) to end and answering with what it ended as, where Self::invoke_as answers a job at once with nothing: for a host that hands an effect’s result back to whoever asked, an agent planning its next step on it. A job still running when within is up is cancelled.

Errors

As Self::invoke_as; the job’s failure or cancellation, or that it did not end in time.

pub fn invoke_typed<R: Resource>( &mut self, invoke: &Invoke<R>, confirmed: bool, ) -> Result<ActionOutput, DoorError>

Perform invoke, an action of the record’s resource R built from its typed reference (Note::EDIT.with(..), Invoke::edit(..)), through the view as Self::invoke does.

Errors

As Self::invoke, and when invoke does not bind or the view publishes no R.

pub fn invoke_at( &mut self, place: &Place, address: &ActionAddress, arguments: &Map<String, Value>, confirmed: bool, ) -> Result<ActionOutput, DoorError>

Self::invoke acting at place instead of at the participant’s caret: place is given as the operation’s place parameter (#[param(place)]), and the participant lands there.

Errors

As Self::invoke; refused as invalid arguments when the operation takes no place.

pub fn set_context(&mut self, context: Option<ActionContext>)

The task the participant carries out from now on (None: none), recorded with each thing it does.

pub const fn context(&self) -> Option<&ActionContext>

The task the participant carries out, when it has one.

pub fn record_run( &mut self, label: &str, issued_by: Option<&str>, decision: Option<&str>, steps: &[RunStep], ) -> bool

Record one instruction that changed several records as one run in this record’s history: a marker, no content. Leaves with Self::take_changes; whether anything was recorded.

pub fn landed(&self) -> Option<ActionEnvelope>

The last action the view applied for the participant’s latest invocation: where its presence shows.

pub fn read<R>(&self, read: impl FnOnce(&AutoCommit) -> R) -> Option<R>

Read the record’s document.

pub fn take_changes(&mut self) -> Option<DocumentMutation>

The participant’s changes since the last call, or None. The first call on a record the participant created returns it whole.

pub fn merge(&mut self, mutation: &DocumentMutation) -> Result<bool, String>

Merge a peer’s change into the view’s record. Incremental changes that build on nothing this record holds belong to another record (or arrived ahead of what they build on) and are left alone: Ok(false).

pub fn chains(&self) -> Vec<RecordCheckout>

The chains of records the app keeps beside its own (Chain), as the view publishes them: each chain’s id and the kind of its parts.

pub fn beside(&self, record: &RecordId) -> Option<RecordCheckout>

record as the view holds it beside its own: a part of one of the app’s chains (Self::chains), of that chain’s kind. None for any other record.

pub fn records_beside(&self) -> Vec<RecordCheckout>

The records the view holds beside its own: the parts of the app’s chains (Self::chains) open here, as they sync on routes of their own.

pub fn read_record<R>( &self, record: &RecordId, read: impl FnOnce(&AutoCommit) -> R, ) -> Option<R>

pub fn take_record_changes( &mut self, record: &RecordId, ) -> Option<DocumentMutation>

The participant’s changes to record, one the view holds beside its own (Self::records_beside), since the last call: the whole record the first time, for one the participant started.

pub fn merge_record( &mut self, record: &RecordId, mutation: &DocumentMutation, ) -> Result<bool, String>

Merge a peer’s change into record, a part of one of the app’s chains (Self::beside), opening it first when the view holds it not yet (a part another device started). Changes that build on nothing the part holds are left alone: Ok(false). Whether it changed.