Struct Entry

pub struct Entry<K, V, D = NoDiff> {
    pub key: K,
    pub value: Value<V>,
    pub deltas: Vec<Delta<D>>,
}

Entry type, describe a single {key,value} entry within indexed data-set.

Fields

key: K

value: Value<V>

deltas: Vec<Delta<D>>

Implementations

impl<K, V, D> Entry<K, V, D>

pub const ID: u32 = 1u32

impl<K, V, D> Entry<K, V, D>

pub fn new(key: K, value: V, seqno: u64) -> Entry<K, V, D>

pub fn new_deleted(key: K, seqno: u64) -> Entry<K, V, D>

pub fn insert(&mut self, value: V, seqn: u64)

where V: Clone + Diff<Delta = D>,

pub fn delete(&mut self, seqn: u64)

where V: Clone + Diff<Delta = D>, <V as Diff>::Delta: From<V>,

pub fn drain_deltas(&mut self)

impl<K, V, D> Entry<K, V, D>

pub fn to_seqno(&self) -> u64

pub fn to_key(&self) -> K

where K: Clone,

pub fn to_value(&self) -> Option<V>

where V: Clone,

pub fn as_key(&self) -> &K

pub fn borrow_key<Q>(&self) -> &Q

where K: Borrow<Q>,

pub fn is_deleted(&self) -> bool

pub fn to_values(&self) -> Vec<Value<V>>

where V: Diff<Delta = D> + Clone, D: Clone,

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

where V: Clone + PartialEq + Diff<Delta = D>, D: Clone,

pub fn merge(&self, other: &Self) -> Self

where K: PartialEq + Clone, V: Clone + Diff<Delta = D>, D: Clone + From<V>,

pub fn purge(self, cutoff: Cutoff) -> Option<Self>

where Self: Sized,

Trait Implementations

impl<K: Clone, V: Clone, D: Clone> Clone for Entry<K, V, D>

fn clone(&self) -> Entry<K, V, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, D: Debug> Debug for Entry<K, V, D>

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

Formats the value using the given formatter.

impl<K, V, D> From<(K, Vec<Value<V>>)> for Entry<K, V, D>

where V: Clone + Diff<Delta = D>, <V as Diff>::Delta: From<V>,

fn from((key, values): (K, Vec<Value<V>>)) -> Self

Converts to this type from the input type.

impl<K, V, D> FromCbor for Entry<K, V, D>

where K: FromCbor, V: FromCbor, D: FromCbor,

fn from_cbor(value: Cbor) -> Result<Entry<K, V, D>>

Convert value from Cbor into type’s value.

impl<K, V, D> IntoCbor for Entry<K, V, D>

where K: IntoCbor, V: IntoCbor, D: IntoCbor,

fn into_cbor(self) -> Result<Cbor>

Convert implementing type’s value into Cbor.

impl<K: PartialEq, V: PartialEq, D: PartialEq> PartialEq for Entry<K, V, D>

fn eq(&self, other: &Entry<K, V, D>) -> 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<K: Eq, V: Eq, D: Eq> Eq for Entry<K, V, D>

impl<K, V, D> StructuralPartialEq for Entry<K, V, D>