Struct RecordSet 

pub struct RecordSet { /* private fields */ }

The records one app process has open, and which is live. Owns per-record persistence and parking, not collaboration: routing a record’s deltas is the toolkit’s business, since a channel belongs to the connection.

Implementations

impl RecordSet

pub fn open(manifest_id: impl Into<String>) -> RecordSet

The launch-environment set: per-record documents under this package’s state directory. The host’s package id wins over manifest_id, as the workspace index does, or a package’s records would split from its index; the host’s workspace id scopes them.

pub fn open_in( store: Rc<dyn DurableStore>, package_id: impl Into<String>, home: impl Into<String>, ) -> RecordSet

The launch-environment set over an explicit store: each record is a shared-writer document in workspace home, and pre-workspace package records are imported into exactly one workspace on first open.

pub fn package_id(&self) -> &str

The package these records are stored under.

pub fn in_memory() -> RecordSet

A set that never touches the disk. For tests, for --shots, and for any run that must not leave state behind.

pub fn home(&self) -> &str

The workspace these records are opened in.

pub fn with_home(self, home: impl Into<String>) -> RecordSet

Name the workspace explicitly. Used by tests and by a host that opens records on behalf of a workspace other than its own launch environment.

pub fn active(&self) -> Option<&RecordId>

The record currently checked out, if any.

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

Every record this process has open, checked-out one included.

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

The bounded, validated names currently granted by the workspace index, without implying their documents are loaded, persisted or joined on the transport.

pub fn discover_workspace( &mut self, workspace: &AutoCommit, ) -> Vec<RecordCheckout>

Refresh the workspace-granted names without opening any: a removed or tombstoned entry disappears from future discovery, but open data stays in memory, since revocation cannot un-share bytes already received.

pub fn peek(&self, id: &RecordId) -> Option<&AutoCommit>

Read a parked record’s document without checking it out. None for the record currently checked out — its document is the live one.

pub fn checkout( &mut self, state: &mut State, workspace: Option<&mut AutoCommit>, want: &RecordCheckout, ) -> bool

Switch the live document to want: the outgoing one is parked and flushed, the incoming loaded (or created) and referenced into the workspace’s index. Returns whether anything changed, so a widget can declare its record every frame.

pub fn open_record( &mut self, want: &RecordCheckout, workspace: Option<&mut AutoCommit>, ) -> bool

Open want if it is not open already, loading its document from its own file and bringing it into the workspace’s index; returns whether it opened it.

pub fn document_mut(&mut self, id: &RecordId) -> Option<&mut AutoCommit>

An open record’s document, for a host showing several at once; None for a record not held here or the one checked out, whose live document is the toolkit’s.

pub fn document_and_history_mut( &mut self, id: &RecordId, ) -> Option<(&mut AutoCommit, &mut UndoLog)>

An open record’s document together with its history, so a caller driving undo can do both against the same record.

pub fn tick_open(&mut self) -> Result<(), String>

Offer every open record’s document to its own writer, the multi-record twin of Self::tick. # Errors A record’s cache reports that it could not take the document.

pub fn flush_open(&mut self) -> Result<(), String>

Write out every open record and wait for it to land, the multi-record twin of Self::flush. # Errors Each record’s writer that reports a storage failure, by record.

pub fn tick(&mut self, live: &mut AutoCommit)

Offer the live document to the active record’s writer. Cheap when nothing changed — a head comparison, no serialisation.

pub fn try_flush(&mut self, live: &mut AutoCommit) -> Result<(), String>

Flush active and parked records, reporting unavailable or failed writers. # Errors Returns record-specific persistence failures without discarding live bytes.

pub fn flush(&mut self, live: &mut AutoCommit) -> Result<(), String>

Write out everything still pending, the live document included, and wait for it to land. # Errors Each record’s writer that reports a storage failure, by record.