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::Subring, it’s sha1 of Subring name.
• 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; subring entries are grow-only member sets; 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 join_subring(&self, did: Did) -> Result<Entry, Error>

This method is used to join a subring. The handler of EntryOperation::JoinSubring.

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

Tombstone observed relay messages.

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

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

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 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.

impl TryFrom<Subring> for Entry

type Error = Error

The type returned in the event of a conversion error.

fn try_from(ring: Subring) -> Result<Entry, Error>

Performs the conversion.