176 lines
3.4 KiB
Rust
176 lines
3.4 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
|
|
use garage_util::data::*;
|
|
|
|
pub trait CRDT {
|
|
fn merge(&mut self, other: &Self);
|
|
}
|
|
|
|
impl<T> CRDT for T
|
|
where T: Ord + Clone {
|
|
fn merge(&mut self, other: &Self) {
|
|
if other > self {
|
|
*self = other.clone();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- LWW Register ----
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct LWW<T>
|
|
{
|
|
ts: u64,
|
|
v: T,
|
|
}
|
|
|
|
impl<T> LWW<T>
|
|
where T: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + PartialEq + Ord
|
|
{
|
|
pub fn new(value: T) -> Self {
|
|
Self {
|
|
ts: now_msec(),
|
|
v: value,
|
|
}
|
|
}
|
|
pub fn migrate_from_raw(ts: u64, value: T) -> Self {
|
|
Self {
|
|
ts,
|
|
v: value,
|
|
}
|
|
}
|
|
pub fn update(&mut self, new_value: T) {
|
|
self.ts = std::cmp::max(self.ts + 1, now_msec());
|
|
self.v = new_value;
|
|
}
|
|
pub fn get(&self) -> &T {
|
|
&self.v
|
|
}
|
|
}
|
|
|
|
impl<T> CRDT for LWW<T>
|
|
where T: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + PartialEq + CRDT
|
|
{
|
|
fn merge(&mut self, other: &Self) {
|
|
if other.ts > self.ts {
|
|
self.ts = other.ts;
|
|
self.v = other.v.clone();
|
|
} else if other.ts == self.ts {
|
|
self.v.merge(&other.v);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ---- Boolean (true as absorbing state) ----
|
|
|
|
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct Bool(bool);
|
|
|
|
impl Bool {
|
|
pub fn new(b: bool) -> Self {
|
|
Self(b)
|
|
}
|
|
pub fn set(&mut self) {
|
|
self.0 = true;
|
|
}
|
|
pub fn get(&self) -> bool {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
impl CRDT for Bool {
|
|
fn merge(&mut self, other: &Self) {
|
|
self.0 = self.0 || other.0;
|
|
}
|
|
}
|
|
|
|
|
|
// ---- LWW Map ----
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct LWWMap<K, V>
|
|
{
|
|
vals: Vec<(K, u64, V)>,
|
|
}
|
|
|
|
impl<K, V> LWWMap<K, V>
|
|
where K: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + PartialEq + Ord,
|
|
V: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + PartialEq + Ord,
|
|
{
|
|
pub fn new() -> Self {
|
|
Self{
|
|
vals: vec![],
|
|
}
|
|
}
|
|
pub fn migrate_from_raw_item(k: K, ts: u64, v: V) -> Self {
|
|
Self{
|
|
vals: vec![(k, ts, v)],
|
|
}
|
|
}
|
|
pub fn take_and_clear(&mut self) -> Self {
|
|
let vals = std::mem::replace(&mut self.vals, vec![]);
|
|
Self{vals}
|
|
}
|
|
pub fn clear(&mut self) {
|
|
self.vals.clear();
|
|
}
|
|
pub fn update_mutator(&self, k: K, new_v: V) -> Self {
|
|
let new_vals = match self
|
|
.vals
|
|
.binary_search_by(|(k2, _, _)| k2.cmp(&k))
|
|
{
|
|
Ok(i) => {
|
|
let (_, old_ts, _) = self.vals[i];
|
|
let new_ts = std::cmp::max(old_ts+1, now_msec());
|
|
vec![(k, new_ts, new_v)]
|
|
}
|
|
Err(_) => {
|
|
vec![(k, now_msec(), new_v)]
|
|
}
|
|
};
|
|
Self{
|
|
vals: new_vals,
|
|
}
|
|
}
|
|
pub fn get(&self, k: &K) -> Option<&V> {
|
|
match self
|
|
.vals
|
|
.binary_search_by(|(k2, _, _)| k2.cmp(&k))
|
|
{
|
|
Ok(i) => Some(&self.vals[i].2),
|
|
Err(_) => None
|
|
}
|
|
}
|
|
pub fn items(&self) -> &[(K, u64, V)] {
|
|
&self.vals[..]
|
|
}
|
|
}
|
|
|
|
impl<K, V> CRDT for LWWMap<K, V>
|
|
where K: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + Ord,
|
|
V: Serialize + for<'de> Deserialize<'de> + Clone + core::fmt::Debug + CRDT,
|
|
{
|
|
fn merge(&mut self, other: &Self) {
|
|
for (k, ts2, v2) in other.vals.iter() {
|
|
match self
|
|
.vals
|
|
.binary_search_by(|(k2, _, _)| k2.cmp(&k))
|
|
{
|
|
Ok(i) => {
|
|
let (_, ts1, v1) = &self.vals[i];
|
|
if ts2 > ts1 {
|
|
self.vals[i].1 = *ts2;
|
|
self.vals[i].2 = v2.clone();
|
|
} else if ts1 == ts2 {
|
|
self.vals[i].2.merge(&v2);
|
|
}
|
|
}
|
|
Err(i) => {
|
|
self.vals.insert(i, (k.clone(), *ts2, v2.clone()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|