use crate::bridge::SerdeCapnpBridge;
use crate::traits::{Crdt, CrdtError};
use crate::enums::CrdtType;
use crate::*;
use serde_json::Value;
pub fn compact_json_values(crdt_type: CrdtType, values: &[Value]) -> Result<Value, CrdtError> {
SerdeCapnpBridge::merge_json_values(crdt_type, values)
}
pub fn compact_capnp_bytes(crdt_type: CrdtType, buffers: &[&[u8]]) -> Result<Vec<u8>, CrdtError> {
if buffers.is_empty() {
return Ok(Vec::new());
}
match crdt_type {
CrdtType::GCounter => {
let readers: Vec<_> = buffers.iter().map(|b| GCounterReader::new(b)).collect();
let merged = GCounter::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::PNCounter => {
let readers: Vec<_> = buffers.iter().map(|b| PNCounterReader::new(b)).collect();
let merged = PNCounter::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::GSet => {
let readers: Vec<_> = buffers
.iter()
.map(|b| GSetReader::<String>::new(b))
.collect();
let merged = GSet::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::ORSet => {
let readers: Vec<_> = buffers
.iter()
.map(|b| ORSetReader::<String>::new(b))
.collect();
let merged = ORSet::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::LWWRegister => {
let readers: Vec<_> = buffers
.iter()
.map(|b| LWWRegisterReader::<String>::new(b))
.collect();
let merged = LWWRegister::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::FWWRegister => {
let readers: Vec<_> = buffers
.iter()
.map(|b| FWWRegisterReader::<String>::new(b))
.collect();
let merged = FWWRegister::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::MVRegister => {
let readers: Vec<_> = buffers
.iter()
.map(|b| MVRegisterReader::<String>::new(b))
.collect();
let merged = MVRegister::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::LWWMap => {
let readers: Vec<_> = buffers
.iter()
.map(|b| LWWMapReader::<String, String>::new(b))
.collect();
let merged = LWWMap::<String, String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::ORMap => {
let readers: Vec<_> = buffers
.iter()
.map(|b| ORMapReader::<String, String>::new(b))
.collect();
let merged = ORMap::<String, String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
CrdtType::LWWSet => {
let readers: Vec<_> = buffers
.iter()
.map(|b| LWWSetReader::<String>::new(b))
.collect();
let merged = LWWSet::<String>::merge_from_readers(&readers)?;
Ok(merged.to_capnp_bytes())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn test_compact_json_gcounter() {
let values = vec![
json!({"counters": {"node_a": 10}, "vclock": {"clocks": {"node_a": [1, 100]}}}),
json!({"counters": {"node_b": 20}, "vclock": {"clocks": {"node_b": [1, 100]}}}),
];
let result = compact_json_values(CrdtType::GCounter, &values).unwrap();
assert!(result.get("counters").is_some());
}
#[test]
fn test_compact_capnp_gcounter() {
let mut gc1 = GCounter::new();
gc1.increment("node_a", 10);
let bytes1 = gc1.to_capnp_bytes();
let mut gc2 = GCounter::new();
gc2.increment("node_b", 20);
let bytes2 = gc2.to_capnp_bytes();
let compacted = compact_capnp_bytes(CrdtType::GCounter, &[&bytes1, &bytes2]).unwrap();
assert!(!compacted.is_empty());
let reader = GCounterReader::new(&compacted);
let merged = GCounter::merge_from_readers(&[reader]).unwrap();
assert_eq!(merged.value(), 30);
}
#[test]
fn test_compact_empty() {
let result = compact_json_values(CrdtType::GCounter, &[]).unwrap();
assert_eq!(result, Value::Null);
let bytes = compact_capnp_bytes(CrdtType::GCounter, &[]).unwrap();
assert!(bytes.is_empty());
}
}