Struct PersonRecords 

pub struct PersonRecords { /* private fields */ }

Where one app keeps the person’s records on this device. Cloning shares the open records.

Implementations

impl PersonRecords

pub fn open( owners: &mut RecordOwners, package_id: &str, author: UserId, ) -> Result<PersonRecords, RecordOpenError>

package_id’s records of the person author, kept in owners.

Errors

Rejects an invalid package.

pub fn replica( package_id: &str, author: UserId, ) -> Result<PersonRecords, RecordOpenError>

Records that store nothing on this device, for a window whose app already holds the stored ones elsewhere (the same app open in another window): they converge with that window over the record’s route.

Errors

Rejects an invalid package.

pub fn of_package( &self, package_id: &str, ) -> Result<PersonRecords, RecordOpenError>

The person’s records package_id keeps, held in this app’s store beside its own. In one host, these use the original profile-scoped owner registry; another mounted app never opens a second writer or empty fallback replica for the same record. Separate hosts/devices converge over the record’s route, which a record of the person’s own scope names in their own cluster. Sharing an owner adds no editor permission; the framework enforces the resource’s editor list.

Errors

Rejects an invalid package.

pub fn in_workspace( &self, workspace: &str, ) -> Result<PersonRecords, RecordOpenError>

The app’s own records of a kind in the workspace workspace, kept where these are: one per kind and member (RecordId::of_member), the same on each of the author’s devices, synced on the ordinary route of a record of the app in that workspace and read or changed by the author’s devices alone. They are kept apart from the store of the record the app shows, so an edit of one while that one is being changed waits for nothing. An author without a root identity is a member of no workspace: theirs stay on this device.

Errors

Rejects an invalid workspace.

pub fn sharing(self, others: &PersonRecords) -> PersonRecords

These records, with the person’s records of other apps (Self::of_package) opened where others keeps them: the host holds those itself and lends them to every app it shows in its process, so the process has one copy of each.

pub fn shared_by_host(&self) -> bool

Whether a host keeps the person’s shared records and lends them to these (Self::sharing): those this app owns are then the host’s too, so the process has one writer of each.

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

Write out what is not stored yet, as closing the window does.

The records are the store’s once written: a store whose host commits in its own time (the page’s, through IndexedDB) says “not yet” for every write it took, which is not a record that could not be stored.

Errors

The records’ writer reports a storage failure.

pub fn author(&self) -> &UserId

pub fn open_record( &self, kind: RecordKind, initialize: &dyn Fn(&mut AutoCommit) -> Result<(), String>, ) -> Result<StoredRecord, RecordOpenError>

Open the person’s record of kind, created with initialize — its genesis, the same change on every device — when nothing holds it yet. When another window of the app keeps it, this window opens a replica that stores nothing and follows that window’s.

Errors

The record could not be read, created or replicated.

pub fn open_existing_record( &self, kind: RecordKind, ) -> Result<Option<StoredRecord>, RecordOpenError>

The person’s record of kind when it exists, without creating it: what a reader opens, leaving creation to the first write (Self::open_record).

Errors

The record could not be read or replicated.

pub fn open_original_record( &self, kind: RecordKind, initialize: impl Fn(&mut AutoCommit) -> Result<(), String>, ) -> Result<StoredRecord, RecordOpenError>

Open the original writer for a host-owned canonical edit. Unlike the readable replica path, this must observe and edit the actual owner: a busy/missing writer is never replaced by an empty local replica.

Trait Implementations

impl Clone for PersonRecords

fn clone(&self) -> PersonRecords

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.