Struct Entry 

pub struct Entry {
    pub hash: String,
    pub id: String,
    pub payload: String,
    pub next: Vec<String>,
    pub v: u32,
    pub clock: LamportClock,
    pub identity: Option<Arc<Identity>>,
}

An entry containing data payload, a hash to locate it in IPFS, and pointers to its parents.

Fields

hash: String

id: String

payload: String

next: Vec<String>

v: u32

clock: LamportClock

identity: Option<Arc<Identity>>

Implementations

impl Entry

pub fn create( ipfs: &IpfsClient, identity: Identity, log_id: &str, data: &str, nexts: &[EntryOrHash<'_>], clock: Option<LamportClock>, ) -> Arc<Entry>

Locally creates an entry owned by identity .

The created entry is part of the log with the id log_id, holds payload of data and can be assigned to point to at most two parents with their hashes in nexts. Providing a Lamport clock via clock is optional.

Returns a reference-counting pointer to the created entry.

pub async fn multihash( ipfs: &IpfsClient, entry: &Entry, ) -> Result<String, Error>

Stores entry in the IPFS client ipfs and returns a future containing its multihash.

N.B. At the moment stores the entry as JSON, not CBOR DAG.

pub async fn from_multihash( ipfs: &IpfsClient, hash: &str, ) -> Result<Entry, Error>

Returns the future containing the entry stored in the IPFS client ipfs with the multihash hash.

N.B. At the moment converts the entry from JSON, not CBOR DAG.

pub fn fetch_entries(ipfs: &IpfsClient, hashes: &[String]) -> Vec<Entry>

Fetches all the entries with the hashes in hashes and all their parents from the IPFS client ipfs.

Returns a vector of entries.

pub fn hash(&self) -> &str

Returns the hash of the entry.

pub fn set_hash(&mut self, hash: &str)

Sets the hash of the entry.

pub fn id(&self) -> &str

Returns the identifier of the entry that is the same as of the containing log.

pub fn payload(&self) -> &str

Returns the data payload of the entry.

pub fn next(&self) -> &[String]

Returns the hashes of the parents.

The length of the returned slice is either:

• 0 — no parents
• 2 — two identical strings for one parent, two distinct strings for two different parents

pub fn clock(&self) -> &LamportClock

Returns the Lamport clock of the entry.

pub fn is_parent(e1: &Entry, e2: &Entry) -> bool

Returns true if e1 is the parent of e2, otherwise returns false.

pub fn find_children(entry: &Entry, entries: &[Arc<Entry>]) -> Vec<Arc<Entry>>

Returns a vector of pointers to all direct and indirect children of entry in entries.

pub fn last_write_wins(a: &Entry, b: &Entry) -> Ordering

A sorting function to pick the more recently written entry.

Uses sort_step_by_step, resolving unsorted cases in the manner defined in it.

Returns an ordering.

pub fn sort_by_entry_hash(a: &Entry, b: &Entry) -> Ordering

A sorting function to pick the entry with the greater hash.

Uses sort_step_by_step, resolving unsorted cases in the manner defined in it.

Returns an ordering.

pub fn sort_step_by_step<F>(resolve: F) -> impl Fn(&Entry, &Entry) -> Ordering

where F: 'static + Fn(&Entry, &Entry) -> Ordering,

A sorting helper function to

1. first try to sort the two entries using resolve,
2. if still unsorted (equal), try to sort based on the Lamport clock identifiers of the respective entries,
3. sort by the Lamport clocks of the respective entries.

Returns a closure that can be used as a sorting function.

pub fn sort_by_clocks<F>(resolve: F) -> impl Fn(&Entry, &Entry) -> Ordering

where F: 'static + Fn(&Entry, &Entry) -> Ordering,

A sorting helper function to sort by the Lamport clocks of the respective entries. In the case the Lamport clocks are equal, tries to sort using resolve.

Returns a closure that can be used as a sorting function.

pub fn sort_by_clock_ids<F>(resolve: F) -> impl Fn(&Entry, &Entry) -> Ordering

where F: 'static + Fn(&Entry, &Entry) -> Ordering,

A sorting helper function to sort by the Lamport clock identifiers of the respective entries. In the case the Lamport clocks identifiers are equal, tries to sort using resolve.

Returns a closure that can be used as a sorting function.

pub fn no_zeroes<F>(sort_fn: F) -> impl Fn(&Entry, &Entry) -> Ordering

where F: 'static + Fn(&Entry, &Entry) -> Ordering,

A sorting helper function that forbids the sorting function sort_fn from producing unsorted (equal) cases.

Returns a closure that behaves in the same way as sort_fn but panics if the two entries given as input are equal.

Trait Implementations

impl Clone for Entry

fn clone(&self) -> Entry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Entry

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

Formats the value using the given formatter.

impl Default for Entry

fn default() -> Entry

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Entry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl LogEntry for Entry

fn get_payload(&self) -> &[u8]

fn get_identity(&self) -> &Identity

impl Ord for Entry

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Entry

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Entry

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Entry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Entry

impl Send for Entry

impl Sync for Entry