Struct garage_table::crdt::LwwMap [−][src]
pub struct LwwMap<K, V> { /* fields omitted */ }
Expand description
Last Write Win Map
This types defines a CRDT for a map from keys to values.
The values have an associated timestamp, such that the last written value
takes precedence over previous ones. As for the simpler LWW
type, the value
type V
is also required to implement the CRDT trait.
We do not encourage mutating the values associated with a given key
without updating the timestamp, in fact at the moment we do not provide a .get_mut()
method that would allow that.
Internally, the map is stored as a vector of keys and values, sorted by ascending key order.
This is why the key type K
must implement Ord
(and also to ensure a unique serialization,
such that two values can be compared for equality based on their hashes). As a consequence,
insertions take O(n)
time. This means that LWWMap should be used for reasonably small maps.
However, note that even if we were using a more efficient data structure such as a BTreeMap
,
the serialization cost O(n)
would still have to be paid at each modification, so we are
actually not losing anything here.
Implementations
Used to migrate from a map defined in an incompatible format. This produces a map that contains a single item with the specified timestamp (copied from the incompatible format). Do this as many times as you have items to migrate, and put them all together using the CRDT merge operator.
Returns a map that contains a single mapping from the specified key to the specified value. This map is a mutator, or a delta-CRDT, such that when it is merged with the original map, the previous value will be replaced with the one specified here. The timestamp in the provided mutator is set to the maximum of the current system’s clock and 1 + the previous value’s timestamp (if there is one), so that the new value will always take precedence (LWW rule).
Typically, to update the value associated to a key in the map, you would do the following:
let my_update = my_crdt.update_mutator(key_to_modify, new_value);
my_crdt.merge(&my_update);
However extracting the mutator on its own and only sending that on the network is very interesting as it is much smaller than the whole map.
Takes all of the values of the map and returns them. The current map is reset to the empty map. This is very usefull to produce in-place a new map that contains only a delta that modifies a certain value:
let mut a = get_my_crdt_value();
let old_a = a.take_and_clear();
a.merge(&old_a.update_mutator(key_to_modify, new_value));
put_my_crdt_value(a);
Of course in this simple example we could have written simply
pyt_my_crdt_value(a.update_mutator(key_to_modify, new_value))
,
but in the case where the map is a field in a struct for instance (as is always the case),
this becomes very handy:
let mut a = get_my_crdt_value();
let old_a_map = a.map_field.take_and_clear();
a.map_field.merge(&old_a_map.update_mutator(key_to_modify, new_value));
put_my_crdt_value(a);
Gets a reference to all of the items, as a slice. Usefull to iterate on all map values. In most case you will want to ignore the timestamp (second item of the tuple).
Trait Implementations
impl<'de, K, V> Deserialize<'de> for LwwMap<K, V> where
K: Deserialize<'de>,
V: Deserialize<'de>,
impl<'de, K, V> Deserialize<'de> for LwwMap<K, V> where
K: Deserialize<'de>,
V: Deserialize<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<LwwMap<K, V>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<LwwMap<K, V>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
pub 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. Read more
Auto Trait Implementations
impl<K, V> RefUnwindSafe for LwwMap<K, V> where
K: RefUnwindSafe,
V: RefUnwindSafe,
impl<K, V> UnwindSafe for LwwMap<K, V> where
K: UnwindSafe,
V: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
pub fn vzip(self) -> V
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more