Struct PersistentAutomerge 

pub struct PersistentAutomerge<P> { /* private fields */ }

A wrapper for a persister and an automerge document.

Implementations

impl<P> PersistentAutomerge<P>

where P: Persister + 'static,

pub const fn document(&self) -> &Automerge

pub fn document_mut(&mut self) -> &mut Automerge

pub fn transact<F, O, E>( &mut self, f: F, ) -> TransactionResult<O, (), E, P::Error>

where F: FnOnce(&mut Transaction<'_, UnObserved>) -> Result<O, E>,

pub fn transact_with<F, O, E, C, Obs>( &mut self, c: C, f: F, ) -> TransactionResult<O, Obs, E, P::Error>

where F: FnOnce(&mut Transaction<'_, Observed<Obs>>) -> Result<O, E>, C: FnOnce(&O) -> CommitOptions, Obs: OpObserver + BranchableObserver + Default,

pub fn apply_changes( &mut self, changes: impl IntoIterator<Item = Change>, ) -> Result<(), Error<P::Error>>

Apply changes to this document.

pub fn apply_changes_with<I: IntoIterator<Item = Change>, Obs: OpObserver>( &mut self, changes: I, op_observer: Option<&mut Obs>, ) -> Result<(), Error<P::Error>>

pub fn load(persister: P) -> Result<Self, Error<P::Error>>

Load the persisted changes (both individual changes and a document) from storage and rebuild the Document.

let persister = MemoryPersister::default();
let doc = PersistentAutomerge::load(persister).unwrap();

pub fn compact(&mut self, old_peer_ids: &[&[u8]]) -> Result<(), Error<P::Error>>

Compact the storage.

This first obtains the changes currently in the document, saves the document and persists the saved document. We then can remove the previously obtained changes one by one.

It also clears out the storage used up by old sync states for peers by removing those given in old_peers.

document.compact(&[]).unwrap();

pub fn generate_sync_message( &mut self, peer_id: Vec<u8>, ) -> Result<Option<Message>, Error<P::Error>>

Generate a sync message to be sent to a peer document.

Peer id is intentionally low level and up to the user as it can be a DNS name, IP address or something else.

This internally retrieves the previous sync state from storage and saves the new one afterwards.

let message = document.generate_sync_message(vec![]).unwrap();

pub fn receive_sync_message( &mut self, peer_id: Vec<u8>, message: Message, ) -> Result<(), Error<P::Error>>

Receive a sync message from a peer document.

Peer id is intentionally low level and up to the user as it can be a DNS name, IP address or something else.

This internally retrieves the previous sync state from storage and saves the new one afterwards.

pub fn receive_sync_message_with<Obs: OpObserver>( &mut self, peer_id: Vec<u8>, message: Message, op_observer: &mut Obs, ) -> Result<(), Error<P::Error>>

Receive a sync message from a peer document.

Peer id is intentionally low level and up to the user as it can be a DNS name, IP address or something else.

This internally retrieves the previous sync state from storage and saves the new one afterwards.

pub fn flush(&mut self) -> Result<usize, P::Error>

Flush any data out to storage returning the number of bytes flushed.

Errors

Returns the error returned by the persister during flushing.

pub fn close(self) -> Result<P, P::Error>

Close the document.

This calls flush on the persister and returns it for potential use in other documents.

Errors

Returns the error from flushing.

pub const fn persister(&self) -> &P

Obtain a reference to the persister.

pub fn persister_mut(&mut self) -> &mut P

Obtain a mut reference to the persister.

pub fn reset_sync_state(&mut self, peer_id: &[u8]) -> Result<(), P::Error>

Reset the sync state for a peer.

This is typically used when a peer disconnects, we need to reset the sync state for them as they may come back up with different state.

Trait Implementations

impl<P: Debug> Debug for PersistentAutomerge<P>

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

Formats the value using the given formatter.