Struct mergable::Dict

pub struct Dict<K, V, Seq> { /* private fields */ }

A mergable dictionary.

This dict must contain a Mergable value. This determines the semantics on conflict. For example if the value is a Cell then last-write-wins semantics will be used. However if the value is a Bag then multiple values inserted into the same key will be kept. If the value is a Counter than conflicting values will be summed.

Implementations

impl<K: Clone + Eq + Hash, V: Mergable, SF: SequenceFactory> Dict<K, V, Sequence<SF>>

pub fn entry(&mut self, key: K) -> DictEntry<'_, K, V, SF>

pub fn get<Q: Hash + Eq>(&self, k: &Q) -> Option<&V>where K: Borrow<Q>,

pub fn get_mut<Q: Hash + Eq>(&mut self, k: &Q) -> Option<&mut V>where K: Borrow<Q>,

pub fn insert(&mut self, ctx: &mut Context<SF>, k: K, v: V)

Insert a value into the map.

• Note that if the value is already in the map the two values will be merged. If you do not want this to occur delete the value first.

• Also note that this updates the key’s creation time meaning that deletes on the previous key will no longer be respected.

• TODO: Weird revival stuff.

pub fn remove<Q>(&mut self, ctx: &mut Context<SF>, k: K) -> Option<V>where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Remove a value from the map.

Note that the semantics of this operation can be confusing read the description carefully.

This removes the known version of the element in the map and all older versions. Unknown modifications will not prevent deletion but if the element has been inserted again after the version that we are aware of that insert will be preserved. Also note that due to merging semantics that may result in values from the known version “reappearing”.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> DictIter<'_, K, V, Sequence<SF>>

Trait Implementations

impl<K: Clone, V: Clone, Seq: Clone> Clone for Dict<K, V, Seq>

fn clone(&self) -> Dict<K, V, Seq>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, Seq> Debug for Dict<K, V, Seq>

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

Formats the value using the given formatter.

impl<K, V, SF> Default for Dict<K, V, SF>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, K: Clone + Eq + Hash, V: Mergable, SF: SequenceFactory> IntoIterator for &'a Dict<K, V, Sequence<SF>>

type IntoIter = DictIter<'a, K, V, Sequence<SF>>

Which kind of iterator are we turning this into?

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Clone + Eq + Hash, V: Mergable, SF: SequenceFactory> IntoIterator for Dict<K, V, Sequence<SF>>

type IntoIter = DictIntoIter<K, V, Sequence<SF>>

Which kind of iterator are we turning this into?

type Item = (K, V)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K: Clone + Eq + Hash, V: Clone + Mergable<Seq = Sequence<SF>>, SF: SequenceFactory> Mergable for Dict<K, V, Sequence<SF>>

type Diff = DictDiff<K, V, Sequence<SF>>

type Seq = Sequence<SF>

fn merge(&mut self, that: Self)

fn diff(&self, that: &Self) -> Self::Diff

Produce a diff.

fn apply(&mut self, diff: Self::Diff) -> Result<(), ApplyError>

fn clean(&mut self, cutoff: &Self::Seq)

Clean up history.

impl<K: Eq + Hash, V: PartialEq, Seq> PartialEq<Dict<K, V, Seq>> for Dict<K, V, Seq>

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

This method tests for self and other values to be equal, and is used by ==.

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

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