Struct ActionCx 

pub struct ActionCx { /* private fields */ }

Deterministic services available while an action applies.

Everything here is a pure function of the action and the document it was authored against, so the origin and every replaying replica compute the same ids and see the same time.

Implementations

impl ActionCx

pub fn for_apply(doc: &AutoCommit, payload: &[u8], now_ms: i64) -> ActionCx

A context seeded from the document’s heads and actor (both pinned by the executor) and the action’s own payload.

Inside an ActionGroup the group’s seed and the member’s position stand in for the heads, which a member cannot read without committing the members before it as separate changes.

pub fn for_write(doc: &AutoCommit, payload: &[u8]) -> ActionCx

A context for ids minted part-way through an action that has already written: seeded like Self::for_apply but from the heads the action started from, so reading them does not commit its writes so far as a separate change.

pub fn id(&mut self) -> Id

A fresh id, unique to this action and stable under replay.

pub fn uuid(&mut self) -> Uuid

A fresh UUID, unique to this action and stable under replay.

pub fn for_person(&self) -> Option<String>

The person the invoker acted for (an agent’s or a Shortcut’s person), as the envelope pinned it; None when someone acted for themselves.

pub fn appearance(&self) -> Option<Appearance>

The name and avatar a bot showed for this action instead of its own, as the envelope pinned it; None for anyone else’s action.

pub fn actor_kind(&self) -> Option<ActorKind>

What kind of actor invoked the action (a person, an agent, a Shortcut), as the envelope pinned it.

pub fn now_ms(&self) -> i64

When the action was authored, in milliseconds since the Unix epoch, as read once on the origin.

pub fn author(&self) -> Option<&str>

Who the action is by: the person or agent that invoked it, the same id that participant’s own views read as me. Pinned with the action like its time, so every replica reads the same author; the payload need not carry it. None for an action applied with no invoker (an edit written straight into a document outside the host).

pub const fn invocation(&self) -> Option<InvocationId>

The invocation admitted by the action door, pinned in the action envelope so origin and replay observe the same correlation identity. This is not caller authority; use Self::author for that.

pub fn content(&self) -> Option<ContentStore>

The content store of the window applying the action, where the bytes the record names by hash are kept: the one the host lent that window, which carries them on the record’s route. Content is not replayed — a replica that applies the action reads the bytes through its own window’s store. None where no window applies it (a tool writing a document directly).

Trait Implementations

impl Debug for ActionCx

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

Formats the value using the given formatter.