use crate::or_map_capnp;
use crate::or_set::ORSet;
use crate::traits::{Crdt, CrdtError, CrdtReader};
use crate::vector_clock::VectorClock;
use capnp::message::{Builder, HeapAllocator, ReaderOptions};
use capnp::serialize;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::hash::Hash;
use serde::de::DeserializeOwned;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(bound(
serialize = "K: Serialize + Eq + Hash + Ord, V: Serialize + Eq + Hash + Ord",
deserialize = "K: DeserializeOwned + Eq + Hash + Ord, V: DeserializeOwned + Eq + Hash + Ord"
))]
pub struct ORMap<K: Eq + Hash + Ord, V: Eq + Hash + Ord> {
pub elements: ORSet<(K, V)>,
pub vclock: VectorClock,
}
impl<K: Eq + Hash + Ord, V: Eq + Hash + Ord> Default for ORMap<K, V> {
fn default() -> Self {
Self {
elements: ORSet::new(),
vclock: VectorClock::new(),
}
}
}
impl<K, V> ORMap<K, V>
where
K: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
V: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
{
pub fn new() -> Self {
Self::default()
}
pub fn insert(&mut self, node_id: &str, key: K, value: V) {
self.remove(&key);
self.elements.insert(node_id, (key, value));
self.vclock.increment(node_id);
}
pub fn remove(&mut self, key: &K) {
let to_remove: Vec<_> = self
.elements
.iter()
.filter(|(k, _)| k == key)
.cloned()
.collect();
for item in to_remove {
self.elements.remove(&item);
}
}
pub fn get_concurrent(&self, key: &K) -> HashSet<V> {
self.elements
.iter()
.filter(|(k, _)| k == key)
.map(|(_, v)| v.clone())
.collect()
}
pub fn merge(&mut self, other: &Self) {
self.elements.merge(&other.elements);
self.vclock.merge(&other.vclock);
}
}
pub struct ORMapReader<'a, K: Eq + Hash + Ord, V: Eq + Hash + Ord> {
bytes: &'a [u8],
_phantom: std::marker::PhantomData<(K, V)>,
}
impl<'a, K, V> ORMapReader<'a, K, V>
where
K: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
V: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
{
pub fn new(bytes: &'a [u8]) -> Self {
Self {
bytes,
_phantom: std::marker::PhantomData,
}
}
fn to_map(&self) -> Result<ORMap<K, V>, CrdtError> {
let reader = serialize::read_message(self.bytes, ReaderOptions::new())
.map_err(|e: capnp::Error| CrdtError::Deserialization(e.to_string()))?;
let or_map = reader
.get_root::<or_map_capnp::or_map::Reader>()
.map_err(|e: capnp::Error| CrdtError::Deserialization(e.to_string()))?;
let orset_bytes = or_map
.get_elements()
.map_err(|e: capnp::Error| CrdtError::Deserialization(e.to_string()))?;
let elements = ORSet::merge_from_readers(&[crate::or_set::ORSetReader::new(orset_bytes)])?;
let vclock = if or_map.has_vclock() {
let vc_bytes = or_map
.get_vclock()
.map_err(|e: capnp::Error| CrdtError::Deserialization(e.to_string()))?;
VectorClock::merge_from_readers(&[crate::vector_clock::VectorClockReader::new(
vc_bytes,
)])?
} else {
VectorClock::new()
};
Ok(ORMap { elements, vclock })
}
}
impl<'a, K, V> CrdtReader<'a> for ORMapReader<'a, K, V>
where
K: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
V: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
{
fn is_empty(&self) -> Result<bool, CrdtError> {
Ok(self.to_map()?.elements.is_empty())
}
}
impl<K, V> Crdt for ORMap<K, V>
where
K: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
V: Clone + Eq + Hash + Serialize + DeserializeOwned + Default + Send + Sync + 'static + Ord,
{
type Reader<'a> = ORMapReader<'a, K, V>;
fn merge_from_readers(readers: &[Self::Reader<'_>]) -> Result<Self, CrdtError> {
let mut result = ORMap::new();
for reader in readers {
result.merge(&reader.to_map()?);
}
Ok(result)
}
fn to_capnp_bytes(&self) -> Vec<u8> {
let mut message = Builder::new(HeapAllocator::new());
{
let mut or_map = message.init_root::<or_map_capnp::or_map::Builder>();
or_map.set_elements(&self.elements.to_capnp_bytes());
or_map.set_vclock(&self.vclock.to_capnp_bytes());
}
let mut buf = Vec::new();
serialize::write_message(&mut buf, &message).expect("ORMap serialization fail");
buf
}
fn is_empty(&self) -> bool {
self.elements.is_empty()
}
fn validate(&self) -> Result<(), CrdtError> {
Ok(())
}
}