automerge-rb 0.1.1

data/vendor/automerge-rust/automerge/src/columnar/encoding/rle.rs

@@ -0,0 +1,239 @@
+use std::{
+    borrow::{Borrow, Cow},
+    fmt::Debug,
+};
+
+use super::{raw, Decodable, Encodable, RawDecoder, Sink};
+
+pub(crate) struct RleEncoder<S, T>
+where
+    T: Encodable + PartialEq + Clone,
+{
+    buf: S,
+    written: usize,
+    state: RleState<T>,
+}
+
+impl<S, T> RleEncoder<S, T>
+where
+    S: Sink,
+    T: Encodable + PartialEq + Clone,
+{
+    pub(crate) fn new(output_buf: S) -> RleEncoder<S, T> {
+        RleEncoder {
+            buf: output_buf,
+            written: 0,
+            state: RleState::Empty,
+        }
+    }
+
+    /// Flush the encoded values and return the output buffer and the number of bytes written
+    pub(crate) fn finish(mut self) -> (S, usize) {
+        match self.take_state() {
+            RleState::InitialNullRun(_size) => {}
+            RleState::NullRun(size) => {
+                self.flush_null_run(size);
+            }
+            RleState::LoneVal(value) => self.flush_lit_run(vec![value]),
+            RleState::Run(value, len) => self.flush_run(&value, len),
+            RleState::LiteralRun(last, mut run) => {
+                run.push(last);
+                self.flush_lit_run(run);
+            }
+            RleState::Empty => {}
+        }
+        (self.buf, self.written)
+    }
+
+    fn flush_run(&mut self, val: &T, len: usize) {
+        self.encode(&(len as i64));
+        self.encode(val);
+    }
+
+    fn flush_null_run(&mut self, len: usize) {
+        self.encode::<i64>(&0);
+        self.encode(&len);
+    }
+
+    fn flush_lit_run(&mut self, run: Vec<T>) {
+        self.encode(&-(run.len() as i64));
+        for val in run {
+            self.encode(&val);
+        }
+    }
+
+    fn take_state(&mut self) -> RleState<T> {
+        let mut state = RleState::Empty;
+        std::mem::swap(&mut self.state, &mut state);
+        state
+    }
+
+    pub(crate) fn append_null(&mut self) {
+        self.state = match self.take_state() {
+            RleState::Empty => RleState::InitialNullRun(1),
+            RleState::InitialNullRun(size) => RleState::InitialNullRun(size + 1),
+            RleState::NullRun(size) => RleState::NullRun(size + 1),
+            RleState::LoneVal(other) => {
+                self.flush_lit_run(vec![other]);
+                RleState::NullRun(1)
+            }
+            RleState::Run(other, len) => {
+                self.flush_run(&other, len);
+                RleState::NullRun(1)
+            }
+            RleState::LiteralRun(last, mut run) => {
+                run.push(last);
+                self.flush_lit_run(run);
+                RleState::NullRun(1)
+            }
+        }
+    }
+
+    pub(crate) fn append_value<BT: Borrow<T>>(&mut self, value: BT) {
+        self.state = match self.take_state() {
+            RleState::Empty => RleState::LoneVal(value.borrow().clone()),
+            RleState::LoneVal(other) => {
+                if &other == value.borrow() {
+                    RleState::Run(value.borrow().clone(), 2)
+                } else {
+                    let mut v = Vec::with_capacity(2);
+                    v.push(other);
+                    RleState::LiteralRun(value.borrow().clone(), v)
+                }
+            }
+            RleState::Run(other, len) => {
+                if &other == value.borrow() {
+                    RleState::Run(other, len + 1)
+                } else {
+                    self.flush_run(&other, len);
+                    RleState::LoneVal(value.borrow().clone())
+                }
+            }
+            RleState::LiteralRun(last, mut run) => {
+                if &last == value.borrow() {
+                    self.flush_lit_run(run);
+                    RleState::Run(value.borrow().clone(), 2)
+                } else {
+                    run.push(last);
+                    RleState::LiteralRun(value.borrow().clone(), run)
+                }
+            }
+            RleState::NullRun(size) | RleState::InitialNullRun(size) => {
+                self.flush_null_run(size);
+                RleState::LoneVal(value.borrow().clone())
+            }
+        }
+    }
+
+    pub(crate) fn append<BT: Borrow<T>>(&mut self, value: Option<BT>) {
+        match value {
+            Some(t) => self.append_value(t),
+            None => self.append_null(),
+        }
+    }
+
+    fn encode<V>(&mut self, val: &V)
+    where
+        V: Encodable,
+    {
+        self.written += val.encode(&mut self.buf);
+    }
+}
+
+enum RleState<T> {
+    Empty,
+    // Note that this is different to a `NullRun` because if every element of a column is null
+    // (i.e. the state when we call `finish` is `InitialNullRun`) then we don't output anything at
+    // all for the column
+    InitialNullRun(usize),
+    NullRun(usize),
+    LiteralRun(T, Vec<T>),
+    LoneVal(T),
+    Run(T, usize),
+}
+
+impl<S: Sink, T: Clone + PartialEq + Encodable> From<S> for RleEncoder<S, T> {
+    fn from(output: S) -> Self {
+        Self::new(output)
+    }
+}
+
+/// See discussion on [`RleEncoder`] for the format data is stored in.
+#[derive(Clone, Debug)]
+pub(crate) struct RleDecoder<'a, T> {
+    decoder: RawDecoder<'a>,
+    last_value: Option<T>,
+    count: isize,
+    literal: bool,
+}
+
+impl<T> RleDecoder<'_, T> {
+    pub(crate) fn done(&self) -> bool {
+        self.decoder.done() && self.count == 0
+    }
+
+    fn try_next(&mut self) -> Result<Option<Option<T>>, raw::Error>
+    where
+        T: Decodable + Clone + Debug,
+    {
+        while self.count == 0 {
+            if self.decoder.done() {
+                return Ok(None);
+            }
+            match self.decoder.read::<i64>()? {
+                count if count > 0 => {
+                    // normal run
+                    self.count = count as isize;
+                    self.last_value = Some(self.decoder.read()?);
+                    self.literal = false;
+                }
+                count if count < 0 => {
+                    // literal run
+                    self.count = count.abs() as isize;
+                    self.literal = true;
+                }
+                _ => {
+                    // null run
+                    // FIXME(jeffa5): handle usize > i64 here somehow
+                    self.count = self.decoder.read::<usize>()? as isize;
+                    self.last_value = None;
+                    self.literal = false;
+                }
+            }
+        }
+        self.count -= 1;
+        if self.literal {
+            Ok(Some(Some(self.decoder.read()?)))
+        } else {
+            Ok(Some(self.last_value.clone()))
+        }
+    }
+}
+
+impl<'a, T> From<Cow<'a, [u8]>> for RleDecoder<'a, T> {
+    fn from(bytes: Cow<'a, [u8]>) -> Self {
+        RleDecoder {
+            decoder: RawDecoder::from(bytes),
+            last_value: None,
+            count: 0,
+            literal: false,
+        }
+    }
+}
+
+impl<'a, T> From<&'a [u8]> for RleDecoder<'a, T> {
+    fn from(d: &'a [u8]) -> Self {
+        Cow::Borrowed(d).into()
+    }
+}
+
+impl<T> Iterator for RleDecoder<'_, T>
+where
+    T: Clone + Debug + Decodable,
+{
+    type Item = Result<Option<T>, raw::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.try_next().transpose()
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar/encoding.rs

@@ -0,0 +1,67 @@
+pub(crate) mod raw;
+
+pub(crate) use raw::{RawDecoder, RawEncoder};
+mod rle;
+pub(crate) use rle::{RleDecoder, RleEncoder};
+mod boolean;
+pub(crate) use boolean::{
+    BooleanDecoder, BooleanEncoder, MaybeBooleanDecoder, MaybeBooleanEncoder,
+};
+mod delta;
+pub(crate) use delta::{DeltaDecoder, DeltaEncoder};
+pub(crate) mod leb128;
+
+pub(crate) mod column_decoder;
+pub(crate) use column_decoder::ColumnDecoder;
+
+#[cfg(test)]
+pub(crate) mod properties;
+
+pub(crate) trait Sink {
+    fn append(&mut self, bytes: &[u8]);
+}
+
+impl Sink for &mut Vec<u8> {
+    fn append(&mut self, bytes: &[u8]) {
+        self.extend(bytes)
+    }
+}
+
+impl Sink for Vec<u8> {
+    fn append(&mut self, bytes: &[u8]) {
+        self.extend(bytes)
+    }
+}
+
+pub(crate) trait Encodable {
+    fn encode<S: Sink>(&self, out: &mut S) -> usize;
+}
+
+mod encodable_impls;
+pub(crate) use encodable_impls::RawBytes;
+
+#[derive(thiserror::Error, Debug)]
+pub(crate) enum DecodeError {
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error("invalid integer")]
+    FromInt(#[from] std::num::TryFromIntError),
+    #[error("bad leb128")]
+    BadLeb(#[from] ::leb128::read::Error),
+    #[error(transparent)]
+    BadLeb128(#[from] crate::storage::parse::leb128::Error),
+    #[error("attempted to allocate {attempted} which is larger than the maximum of {maximum}")]
+    OverlargeAllocation { attempted: usize, maximum: usize },
+    #[error("invalid string encoding")]
+    BadString,
+}
+
+pub(crate) trait Decodable: Sized {
+    fn decode<R>(bytes: &mut R) -> Result<Self, DecodeError>
+    where
+        R: std::io::Read;
+}
+mod decodable_impls;
+
+pub(crate) mod col_error;
+pub(crate) use col_error::DecodeColumnError;

data/vendor/automerge-rust/automerge/src/columnar/splice_error.rs

@@ -0,0 +1,47 @@
+use std::convert::Infallible;
+
+/// Represents an error which occurred when splicing.
+///
+/// When splicing values into existing column storage there are two kinds of errors which can
+/// occur, those caused by iterating over the existing items, and those caused by iterating over
+/// the replacement items.
+#[derive(Debug)]
+pub(crate) enum SpliceError<E, R> {
+    /// There was an error reading from the existing column storage
+    ReadExisting(E),
+    /// There was an error reading from the iterator of new rows
+    ReadReplace(R),
+}
+
+impl<E> SpliceError<E, Infallible> {
+    /// Map a spliceerror which is infallible in it's `Replace` error type into a different error.
+    ///
+    /// This is used when you have performed a splice with a `replace` iterator which is
+    /// infallible and need to return a more general `SpliceError`
+    pub(crate) fn existing<R>(self) -> SpliceError<E, R> {
+        match self {
+            SpliceError::ReadExisting(e) => SpliceError::ReadExisting(e),
+            SpliceError::ReadReplace(_) => unreachable!("absurd"),
+        }
+    }
+}
+
+impl<E, R> std::error::Error for SpliceError<E, R>
+where
+    E: std::error::Error,
+    R: std::error::Error,
+{
+}
+
+impl<E, R> std::fmt::Display for SpliceError<E, R>
+where
+    E: std::fmt::Display,
+    R: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ReadExisting(e) => write!(f, "error reading from existing rows: {}", e),
+            Self::ReadReplace(e) => write!(f, "error reading from replacement rows: {}", e),
+        }
+    }
+}

data/vendor/automerge-rust/automerge/src/columnar.rs

@@ -0,0 +1,14 @@
+//! Types for reading data which is stored in a columnar storage format
+//!
+//! The details of how values are encoded in `encoding`, which exposes a set of "decoder" and
+//! "encoder" types.
+//!
+//! The `column_range` module exposes a set of types - most of which are newtypes over
+//! `Range<usize>` - which have useful instance methods such as `encode()` to create a new range and
+//! `decoder()` to return an iterator of the correct type.
+pub(crate) mod column_range;
+pub(crate) use column_range::Key;
+pub(crate) mod encoding;
+
+mod splice_error;
+pub(crate) use splice_error::SpliceError;

data/vendor/automerge-rust/automerge/src/convert.rs

@@ -0,0 +1,112 @@
+//! Types for converting between different OpId representations
+//!
+//! In various places throughout the codebase we refer to operation IDs. The canonical type for
+//! representing an operation ID is [`crate::types::OpId`]. This type holds the counter of the operation
+//! ID but it does not store the actor ID, instead storing an index into an array of actor IDs
+//! stored elsewhere. This makes using OpIds very memory efficient. We also store operation IDs on
+//! disc. Here again we use a representation where the actor ID is stored as an offset into an
+//! array which is held elsewhere. We occasionally do need to refer to an operation ID which
+//! contains the full actor ID - typically when exporting to other processes or to the user.
+//!
+//! This is problematic when we want to write code which is generic over all these representations,
+//! or which needs to convert between them. This module hopes to solve that problem. The basic
+//! approach is to define the trait `OpId`, which is generic over the type of its `actor`. Using a
+//! trait means that there is no need to allocate intermediate collections of operation IDs when
+//! converting (for example when encoding a bunch of OpSet operation IDs into a change, where we
+//! have to translate the indices).
+//!
+//! Having defined the `OpId` trait we then define a bunch of enums representing each of the
+//! entities in the automerge data model which contain an `OpId`, namely `ObjId`, `Key`, and
+//! `ElemId`. Each of these enums implements a `map` method, which allows you to convert the actor
+//! ID of any contained operation using a mappping function.
+
+use std::borrow::Cow;
+
+pub(crate) trait OpId<ActorId> {
+    fn actor(&self) -> ActorId;
+    fn counter(&self) -> u64;
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum ObjId<O> {
+    Root,
+    Op(O),
+}
+
+impl From<crate::types::ObjId> for ObjId<crate::types::OpId> {
+    fn from(obj: crate::types::ObjId) -> ObjId<crate::types::OpId> {
+        if obj.is_root() {
+            ObjId::Root
+        } else {
+            ObjId::Op(obj.0)
+        }
+    }
+}
+
+impl<O> ObjId<O> {
+    pub(crate) fn map<F, P>(self, f: F) -> ObjId<P>
+    where
+        F: Fn(O) -> P,
+    {
+        match self {
+            ObjId::Root => ObjId::Root,
+            ObjId::Op(o) => ObjId::Op(f(o)),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum ElemId<O> {
+    Head,
+    Op(O),
+}
+
+impl<O> ElemId<O> {
+    pub(crate) fn map<F, P>(self, f: F) -> ElemId<P>
+    where
+        F: Fn(O) -> P,
+    {
+        match self {
+            ElemId::Head => ElemId::Head,
+            ElemId::Op(o) => ElemId::Op(f(o)),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) enum Key<'a, O> {
+    Prop(Cow<'a, smol_str::SmolStr>),
+    Elem(ElemId<O>),
+}
+
+impl<'a, O> Key<'a, O> {
+    pub(crate) fn map<F, P>(self, f: F) -> Key<'a, P>
+    where
+        F: Fn(O) -> P,
+    {
+        match self {
+            Key::Prop(p) => Key::Prop(p),
+            Key::Elem(e) => Key::Elem(e.map(f)),
+        }
+    }
+}
+
+impl OpId<usize> for crate::types::OpId {
+    fn counter(&self) -> u64 {
+        self.counter()
+    }
+
+    fn actor(&self) -> usize {
+        self.actor()
+    }
+}
+
+impl OpId<usize> for &crate::types::OpId {
+    fn counter(&self) -> u64 {
+        crate::types::OpId::counter(self)
+    }
+
+    fn actor(&self) -> usize {
+        crate::types::OpId::actor(self)
+    }
+}