Struct PortableStorage 

pub struct PortableStorage { /* private fields */ }

Clone one cache throughout a browser host. Hydrate before opening its owners; only acknowledge writes after the external storage transaction commits.

Implementations

impl PortableStorage

pub fn new(profile: &str, device: &str) -> Result<PortableStorage, String>

pub fn record_owner<Owner>( &self, package: &str, workspace: &str, ) -> Option<Rc<Owner>>

where Owner: 'static,

The live record store registered for package in workspace, if it is an Owner.

pub fn register_record_owner<Owner>( &self, package: &str, workspace: &str, owner: &Rc<Owner>, )

where Owner: 'static,

Register owner as the record store of package in workspace while it lives.

pub fn namespace(&self) -> &ProfileNamespace

pub fn records(&self, package: &str, workspace: &str) -> Vec<String>

The record component of every cached record of package in workspace, sorted, as durable_store::DurableStore::records lists a store’s.

pub fn get(&self, key: &StorageKey) -> Option<CachedBytes>

pub fn document_heads( &self, key: &StorageKey, ) -> Option<Result<Vec<ChangeHash>, ()>>

Decode the current cached document without asserting that it is durable.

pub fn hydrate( &self, key: StorageKey, bytes: Vec<u8>, actor: Option<Vec<u8>>, ) -> Result<(), String>

Initial durable bytes. Existing entries may never be replaced through hydration.

pub fn claim(&self, key: &StorageKey, actor: Vec<u8>) -> Result<(), String>

Write key’s document under actor from now on, replacing the writer its last save was made by.

A writer identity belongs to one live writer: two pages that each write a row saved by the other would write its sequences twice. The page that opens a row writes it under an actor it minted itself, and claims the row here, so a save, its acknowledgement and the next hydration all see that actor.

pub fn put( &self, key: StorageKey, bytes: Vec<u8>, actor: Option<Vec<u8>>, ) -> Result<(), String>

pub fn put_document( &self, key: StorageKey, doc: &mut AutoCommit, actor: Option<Vec<u8>>, ) -> Result<(), String>

Serialize a canonical document and queue its bytes through the ordinary persistence path. Callers cannot supply detached or unverified heads.

pub fn pending_writes(&self) -> Vec<PendingWrite>

pub fn watch_durability( &self, key: &StorageKey, wake: Arc<dyn Fn() + Send + Sync>, )

Call wake each time what Self::flush says of key may have changed without input: when the host acknowledges its current bytes, or new bytes are durable at once (Self::durability_changed). How a window showing “Saving…” hears it saved; the same wake (durable_store::waiting::same_wake) given again is kept once.

pub fn durability_changed(&self, key: &StorageKey)

Call everyone watching key’s durability.

pub fn acknowledge( &self, write: &PendingWrite, result: Result<(), String>, ) -> Result<(), String>

Acknowledging an old revision never makes newer bytes durable.

pub fn status(&self, key: &StorageKey) -> Option<StorageStatus>

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

Trait Implementations

impl Clone for PortableStorage

fn clone(&self) -> PortableStorage

Returns a duplicate of the value.

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

Performs copy-assignment from source.