mod gcounter;
mod lww_register;
mod pncounter;
mod replica_id;
use serde::{de::DeserializeOwned, Serialize};
use std::{
error::Error,
fmt::{Display, Formatter},
};
pub use gcounter::GCounter;
pub use lww_register::LwwRegister;
pub use pncounter::PNCounter;
pub use replica_id::ReplicaId;
pub trait Crdt {
fn merge(&mut self, other: &Self) -> bool;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CrdtDecodeConfig {
pub max_encoded_bytes: usize,
}
impl Default for CrdtDecodeConfig {
fn default() -> Self {
Self {
max_encoded_bytes: 1024 * 1024,
}
}
}
#[derive(Debug)]
pub enum CrdtError {
EmptyReplicaId,
CounterOverflow,
ValueOverflow,
EncodedValueTooLarge { limit: usize, actual: usize },
Serialization(serde_json::Error),
Deserialization(serde_json::Error),
}
impl Display for CrdtError {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
Self::EmptyReplicaId => write!(f, "replica id must not be empty"),
Self::CounterOverflow => write!(f, "counter component overflow"),
Self::ValueOverflow => write!(f, "CRDT value overflow"),
Self::EncodedValueTooLarge { limit, actual } => write!(
f,
"encoded CRDT value too large: {actual} bytes exceeds limit {limit} bytes"
),
Self::Serialization(err) => write!(f, "CRDT serialization error: {err}"),
Self::Deserialization(err) => write!(f, "CRDT deserialization error: {err}"),
}
}
}
impl Error for CrdtError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Serialization(err) | Self::Deserialization(err) => Some(err),
_ => None,
}
}
}
pub fn encode_crdt<T: Serialize>(value: &T) -> Result<Vec<u8>, CrdtError> {
serde_json::to_vec(value).map_err(CrdtError::Serialization)
}
pub fn decode_crdt<T: DeserializeOwned>(
bytes: &[u8],
config: CrdtDecodeConfig,
) -> Result<T, CrdtError> {
if bytes.len() > config.max_encoded_bytes {
return Err(CrdtError::EncodedValueTooLarge {
limit: config.max_encoded_bytes,
actual: bytes.len(),
});
}
serde_json::from_slice(bytes).map_err(CrdtError::Deserialization)
}