Struct sn_client::RegisterOffline

pub struct RegisterOffline { /* private fields */ }

Ops made to an offline Register instance are applied locally only, and accumulated till the user explicitly calls ‘sync’. The user can switch back to sync with the network for every op by invoking online API.

Implementations

impl RegisterOffline

pub fn create(client: Client, name: XorName, tag: u64) -> Result<Self, Error>

Create a new Register offline.

pub async fn online(self) -> Result<Register, Error>

Switch to ‘online’ mode where each op made locally is immediatelly pushed to the network.

pub fn policy(&self) -> &Policy

Return the Policy of the Register.

pub fn name(&self) -> &XorName

Return the XorName of the Register.

pub fn tag(&self) -> u64

Return the tag value of the Register.

pub fn size(&self) -> u64

Return the number of items held in the register

pub fn get(&self, hash: EntryHash) -> Result<&Entry, Error>

Return a value corresponding to the provided ‘hash’, if present.

pub fn read(&self) -> BTreeSet<(EntryHash, Entry)>

Read the last entry, or entries when there are branches, if the register is not empty.

pub fn write(&mut self, entry: &[u8]) -> Result<(), Error>

Write a new value onto the Register atop latest value. It returns an error if it finds branches in the content/entries; if it is required to merge/resolve the branches, invoke the write_merging_branches API.

pub fn write_merging_branches(&mut self, entry: &[u8]) -> Result<(), Error>

Write a new value onto the Register atop latest value. If there are branches of content/entries, it automatically merges them all leaving the new value as a single latest value of the Register. Note you can use write API instead if you need to handle content/entries branches in a diffeerent way.

pub fn write_atop( &mut self, entry: &[u8], children: BTreeSet<EntryHash> ) -> Result<(), Error>

Write a new value onto the Register atop the set of braches/entries referenced by the provided list of their corresponding entry hash. Note you can use write_merging_branches API instead if you want to write atop all exiting branches/entries.

pub async fn sync(&mut self) -> Result<(), Error>

Sync this Register with the replicas on the network.

pub async fn push(&mut self) -> Result<(), Error>

Push all operations made locally to the replicas of this Register on the network.