Struct sn_client::ClientRegister

pub struct ClientRegister { /* 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 ClientRegister

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

Create a new Register Locally.

pub async fn create_public_online( client: Client, meta: XorName, verify_store: bool ) -> Result<Self, Error>

Create a new public Register (Anybody can write to it) and send it so the Network. This will optionally verify the Register was stored on the network.

pub async fn create_online( client: Client, meta: XorName, verify_store: bool ) -> Result<Self, Error>

Create a new Register and send it to the Network.

pub fn address(&self) -> &RegisterAddress

pub fn owner(&self) -> PublicKey

Return the Owner of the Register.

pub fn permissions(&self) -> &Permissions

Return the Permissions 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, verify_store: bool) -> Result<(), Error>

Sync this Register with the replicas on the network. This will optionally verify the stored Register on the network is the same as the local one.

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

Push all operations made locally to the replicas of this Register on the network. This optionally verifies that the stored Register is the same as our local register

pub async fn write_online( &mut self, entry: &[u8], verify_store: bool ) -> 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 async fn write_merging_branches_online( &mut self, entry: &[u8], verify_store: bool ) -> 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 async fn write_atop_online( &mut self, entry: &[u8], children: BTreeSet<EntryHash>, verify_store: bool ) -> 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.