Struct Entry 

pub struct Entry {
    pub did: Did,
    pub data: Vec<Encoded>,
    pub kind: EntryKind,
    pub crdt: EntryCrdt,
}

A DHT storage entry with an EntryKind and a ring key represented as Did.

An Entry is data stored by ChordStorage. It is not a Chord node and does not participate in successor, predecessor, or finger-table membership.

The Did of an Entry is in the following format:

• If kind value is EntryKind::Data, it’s sha1 of data topic.
• If kind value is EntryKind::RelayMessage, it’s the destination Did of message plus 1 (to ensure that the message is sent to the successor of destination), thus while destination node going online, it will sync message from its successor.

Fields

did: Did

The ring key of this entry. It has the same representation as a node DID, but a different domain meaning.

data: Vec<Encoded>

The data entity of Entry, encoded by Encoder.

kind: EntryKind

The type indicates how the data is encoded and how the Did is generated.

crdt: EntryCrdt

CRDT metadata that makes replicated merge a join-semilattice operation.

Implementations

impl Entry

pub fn new(did: Did, data: Vec<Encoded>, kind: EntryKind) -> Entry

Construct an entry with empty CRDT metadata.

pub fn gen_did(topic: &str) -> Result<Did, Error>

Generate did from topic.

impl Entry

pub fn join(&self, other: Entry) -> Result<Entry, Error>

Merge two entries from the same replicated carrier.

Law: for a fixed (did, kind) carrier, this is the state-based CRDT join. Data entries are bounded LWW element sets with an LWW overwrite register; relay entries are two-phase sets whose remove side is carried by tombstones.

pub fn affine(&self, scalar: u16) -> Result<Vec<Entry>, Error>

Affine Transport entry to a list of affined did

pub fn clone_with_did(&self, did: Did) -> Entry

Clone and setup with new DID

pub fn try_into_storage_entry(self) -> Result<Entry, Error>

Normalize an entry immediately before it is persisted.

Post: normalization uses the same carrier materialization as Self::join; there is no second cap strategy outside the CRDT. Post: result.data.len() <= ENTRY_DATA_MAX_LEN. Post: result.data.len() == result.crdt.dots.len() for Data and RelayMessage entries.

pub fn operate(&self, op: EntryOperation, actor: Did) -> Result<Entry, Error>

The entry point of EntryOperation. Will dispatch to different operation handlers according to the variant.

pub fn overwrite(&self, other: Entry, actor: Did) -> Result<Entry, Error>

Overwrite current data with new data.

Preservation: the replacement is represented as a CRDT join. A newly stamped overwrite carries a reset floor, and materialization keeps only dots at or after that floor, so older payload dots are removed without a non-monotone assignment.

The handler of EntryOperation::Overwrite.

pub fn extend(&self, other: Entry, actor: Did) -> Result<Entry, Error>

This method is used to extend data to a Data kind Entry. The handler of EntryOperation::Extend.

pub fn touch(&self, other: Entry, actor: Did) -> Result<Entry, Error>

This method is used to extend data to a Data kind Entry uniquely. If any element is already existed, move it to the end of the data vector. The handler of EntryOperation::Touch.

pub fn tombstone(&self, other: Entry) -> Result<Entry, Error>

Tombstone observed data or relay-message payloads.

Pre: self and other are the same data or relay-message carrier. Post: every removed payload is represented by an add-dot tombstone, so future joins with stale add replicas cannot resurrect it.

pub fn compact_data(&self, removals: Entry, actor: Did) -> Result<Entry, Error>

Compact a Data kind entry using the receiver’s current visible payloads.

Pre: removals names the same Data carrier as self. Post: every current visible payload not listed in removals is preserved under the greatest observed register floor, and older tombstone metadata is pruned by that floor.

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<(), Error>

Formats the value using the given formatter.

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

fn deserialize<__D>( __deserializer: __D, ) -> Result<Entry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Entry

impl PartialEq for Entry

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Entry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Entry

impl TryFrom<(String, Encoded)> for Entry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(_: (String, Encoded)) -> Result<Entry, Error>

Performs the conversion.

impl TryFrom<(String, String)> for Entry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(_: (String, String)) -> Result<Entry, Error>

Performs the conversion.

impl TryFrom<MessagePayload> for Entry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(msg: MessagePayload) -> Result<Entry, Error>

Performs the conversion.

impl TryFrom<String> for Entry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(topic: String) -> Result<Entry, Error>

Performs the conversion.