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 (tilo_ui::App re-announces its channel on checkout), since a channel is a property of 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 always wins over manifest_id (as in crate::persist::open_room) — resolving it differently here would split a package’s records from its room index.

The process environment names the package and room, and the native store (app_state::DocStore::native_store) holds the documents; see Self::open_in. Hosts with an explicit profile open records through RecordOwners instead.

The host’s workspace (else cluster) id scopes the records.

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 room home, and pre-room package records are imported into exactly one room 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 room these records are opened in.

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

Name the room explicitly. Used by tests and by a host that opens records on behalf of a room 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 room index. Unlike Self::open_records, this does not imply their documents were loaded, persisted, or joined on the collaboration transport.

pub fn discover_room(&mut self, room: &AutoCommit) -> Vec<RecordCheckout>

Refresh the room-granted record names without opening any of them. A removed/tombstoned index entry disappears from future discovery, but already-open data remains in memory: revocation stops future access; it cannot un-share bytes the process has 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, room: Option<&mut AutoCommit>, want: &RecordCheckout, ) -> bool

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

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

Open want if it is not open already, loading its document from its own file and bringing it into room’s index. Returns whether this 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 currently checked out (the 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)

Offer every open record’s document to its own writer. The multi-record twin of Self::tick, for a host with no single live document to hand in.

pub fn flush_open(&mut self)

Write out every open record and wait for it to land. The multi-record twin of Self::flush.

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)

Write out everything still pending, live document included, and wait for it to land.