Struct automerge_persistent::PersistentAutoCommit

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

A wrapper for a persister and an automerge document.

Implementations

impl<P> PersistentAutoCommit<P>where P: Persister + 'static,

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

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

UNSAFE: this may lead to changes not being immediately persisted

pub fn transact<F: FnOnce(&mut AutoCommit) -> Result<O, E>, O, E>( &mut self, f: F ) -> Result<O, E>

Make changes to the document but don’t immediately persist changes.

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 = PersistentAutoCommit::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.

doc.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 = doc.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 flush(&mut self) -> Result<usize, Error<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_transaction(&mut self) -> Result<(), Error<P::Error>>

Close any current transaction and write out the changes to disk.

pub fn close(self) -> Result<P, Error<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 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 PersistentAutoCommit<P>

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

Formats the value using the given formatter.