Struct Peermerge

pub struct Peermerge<T, U>
where
    T: RandomAccess + Debug + Send,
    U: FeedPersistence,
{ /* private fields */ }

Peermerge is the main abstraction and a store for multiple documents.

Implementations

impl<T, U> Peermerge<T, U>

where T: RandomAccess + Debug + Send + 'static, U: FeedPersistence,

pub fn peer_id(&self) -> PeerId

Get my peer id

pub async fn peer_ids( &self, document_id: &DocumentId, ) -> Result<Vec<PeerId>, PeermergeError>

Get all known peer ids in a document

pub fn default_peer_header(&self) -> NameDescription

Get my default peer header given to a new document

pub async fn peer_header( &self, document_id: &DocumentId, peer_id: &PeerId, ) -> Result<Option<NameDescription>, PeermergeError>

Get the current peer header value in a new document

pub async fn set_state_event_sender( &mut self, state_event_sender: Option<UnboundedSender<StateEvent>>, ) -> Result<(), PeermergeError>

Add or change the state event sender. The sender can already be given when peermerge is created but sometimes it’s more convinient to set it later.

pub async fn transact<F, O>( &self, document_id: &DocumentId, cb: F, ) -> Result<O, PeermergeError>

where F: FnOnce(&AutomergeDoc) -> Result<O, AutomergeError>,

Read from a document in a single transaction

pub async fn transact_mut<F, O>( &mut self, document_id: &DocumentId, cb: F, change_id: Option<Vec<u8>>, ) -> Result<O, PeermergeError>

where F: FnOnce(&mut AutomergeDoc) -> Result<O, AutomergeError>,

Read and write to a document in a single transaction. change_id is an optional parameter that will be returned in the corresponding DocumentChanged StateEvent.

pub async fn watch( &mut self, document_id: &DocumentId, ids: Option<Vec<ObjId>>, ) -> Result<(), PeermergeError>

Set watching to list of Automerge object ids so that DocumentChanged StateEvents are returned only from changes to those objects. None means sending events of all changes which is the default.

pub async fn reserve_object<O: AsRef<ObjId>>( &mut self, document_id: &DocumentId, obj: O, ) -> Result<(), PeermergeError>

Reserve a given object for only local changes, preventing any peers from making changes to it at the same time before unreserve_object has been called. Useful especially when editing a text to avoid having to update remote changes to the field while typing. Reserve is not persisted to storage.

pub async fn unreserve_object<O: AsRef<ObjId>>( &mut self, document_id: &DocumentId, obj: O, ) -> Result<(), PeermergeError>

Un-reserve a given object previously reserved with reserve_object.

pub async fn sharing_info( &self, document_id: &DocumentId, ) -> Result<DocumentSharingInfo, PeermergeError>

Get sharing information about a document.

pub async fn document_secret( &self, document_id: &DocumentId, ) -> Result<Option<String>, PeermergeError>

Get the document secret from a given document_id.

pub async fn reattach_secret( &self, document_id: &DocumentId, ) -> Result<String, PeermergeError>

Get the reattach secret of a given document_id. Useful only for in-memory storage.

pub async fn protocol_ids(&self) -> Result<Vec<Vec<u8>>, PeermergeError>

Get all connected protocol ids

pub async fn disconnect_protocol( &mut self, protocol_id: &[u8], ) -> Result<bool, PeermergeError>

Disconnect protocol by id, returns if protocol with id was found

pub async fn disconnect_all_protocols( &mut self, ) -> Result<usize, PeermergeError>

Disconnect all protocols, returns total number of protocols disconnected

impl Peermerge<RandomAccessMemory, FeedMemoryPersistence>

pub async fn new_memory( options: PeermergeMemoryOptions, ) -> Result<Self, PeermergeError>

Create a new memory Peermerge

pub async fn create_new_document_memory<F, O>( &mut self, options: CreateNewDocumentMemoryOptions, init_cb: F, change_id: Option<Vec<u8>>, ) -> Result<(DocumentInfo, O), PeermergeError>

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

Create a new document in-memory

pub async fn attach_document_memory( &mut self, options: AttachDocumentMemoryOptions, ) -> Result<DocumentInfo, PeermergeError>

Attach an existing document in-memory

pub async fn connect_protocol_memory<T>( &mut self, protocol_id: &[u8], protocol: &mut FeedProtocol<T>, ) -> Result<(), PeermergeError>

where T: IO,

Connect peer protocol in-memory

impl Peermerge<RandomAccessDisk, FeedDiskPersistence>

pub async fn new_disk( options: PeermergeDiskOptions, ) -> Result<Self, PeermergeError>

Create a new disk Peermerge

pub async fn document_infos_disk( data_root_dir: &Path, ) -> Result<Option<Vec<DocumentInfo>>, PeermergeError>

Get information about possible documents stored to a given root directory

pub async fn open_disk(options: OpenDiskOptions) -> Result<Self, PeermergeError>

Open peermerge stored to disk

pub async fn create_new_document_disk<F, O>( &mut self, options: CreateNewDocumentDiskOptions, init_cb: F, change_id: Option<Vec<u8>>, ) -> Result<(DocumentInfo, O), PeermergeError>

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

Create a new document on disk

pub async fn attach_document_disk( &mut self, options: AttachDocumentDiskOptions, ) -> Result<DocumentInfo, PeermergeError>

Attach existing document to disk

pub async fn connect_protocol_disk<T>( &mut self, protocol_id: &[u8], protocol: &mut FeedProtocol<T>, ) -> Result<(), PeermergeError>

where T: IO,

Connect peer protocol to disk

Trait Implementations

impl<T, U> Clone for Peermerge<T, U>

where T: RandomAccess + Debug + Send, U: FeedPersistence,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> Debug for Peermerge<T, U>

where T: RandomAccess + Debug + Send + Debug, U: FeedPersistence + Debug,

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

Formats the value using the given formatter.