automerge-rb 0.1.1

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

@@ -0,0 +1,329 @@
+use std::{convert::Infallible, ops::Range};
+
+use super::{DeltaRange, RleRange};
+use crate::{
+    columnar::{
+        encoding::{
+            raw, DecodeColumnError, DeltaDecoder, DeltaEncoder, RleDecoder, RleEncoder, Sink,
+        },
+        SpliceError,
+    },
+    convert,
+    types::OpId,
+};
+
+/// A collection of ranges which decode to lists of OpIds
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct OpIdListRange {
+    num: RleRange<u64>,
+    actor: RleRange<u64>,
+    counter: DeltaRange,
+}
+
+impl OpIdListRange {
+    pub(crate) fn new(num: RleRange<u64>, actor: RleRange<u64>, counter: DeltaRange) -> Self {
+        Self {
+            num,
+            actor,
+            counter,
+        }
+    }
+
+    pub(crate) fn group_range(&self) -> &RleRange<u64> {
+        &self.num
+    }
+
+    pub(crate) fn actor_range(&self) -> &RleRange<u64> {
+        &self.actor
+    }
+
+    pub(crate) fn counter_range(&self) -> &DeltaRange {
+        &self.counter
+    }
+
+    pub(crate) fn iter<'a>(&self, data: &'a [u8]) -> OpIdListIter<'a> {
+        OpIdListIter {
+            num: self.num.decoder(data),
+            actor: self.actor.decoder(data),
+            counter: self.counter.decoder(data),
+        }
+    }
+
+    pub(crate) fn encode<O, I, II, IE>(opids: I, out: &mut Vec<u8>) -> Self
+    where
+        O: convert::OpId<usize>,
+        II: IntoIterator<Item = O, IntoIter = IE>,
+        IE: Iterator<Item = O> + ExactSizeIterator,
+        I: Iterator<Item = II> + Clone,
+    {
+        let num = RleRange::encode(
+            opids.clone().map(|os| Some(os.into_iter().len() as u64)),
+            out,
+        );
+        let actor = RleRange::encode(
+            opids
+                .clone()
+                .flat_map(|os| os.into_iter().map(|o| Some(o.actor() as u64))),
+            out,
+        );
+        let counter = DeltaRange::encode(
+            opids.flat_map(|os| os.into_iter().map(|o| Some(o.counter() as i64))),
+            out,
+        );
+        Self {
+            num,
+            actor,
+            counter,
+        }
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn splice<I, II, IE, R>(
+        &self,
+        data: &[u8],
+        replace: Range<usize>,
+        replace_with: I,
+        out: &mut Vec<u8>,
+    ) -> Result<Self, SpliceError<raw::Error, R>>
+    where
+        R: std::error::Error + Clone,
+        II: IntoIterator<Item = OpId, IntoIter = IE>,
+        IE: Iterator<Item = OpId> + ExactSizeIterator,
+        I: Iterator<Item = Result<II, R>> + Clone,
+    {
+        let group_replace = group_replace_range(replace.clone(), self.num.decoder(data))
+            .map_err(|e| e.existing())?;
+        let num = self.num.splice(
+            data,
+            replace,
+            replace_with
+                .clone()
+                .map(|elems| elems.map(|elems| Some(elems.into_iter().len() as u64))),
+            out,
+        )?;
+        let actor = self.actor.splice(
+            data,
+            group_replace.clone(),
+            replace_with.clone().flat_map(|elem| match elem {
+                Err(e) => SplicingIter::Failed(e),
+                Ok(i) => SplicingIter::Iter(i.into_iter(), |oid: OpId| oid.actor() as u64),
+            }),
+            out,
+        )?;
+        let counter = self.counter.splice(
+            data,
+            group_replace,
+            replace_with.flat_map(|elem| match elem {
+                Err(e) => SplicingIter::Failed(e),
+                Ok(i) => SplicingIter::Iter(i.into_iter(), |oid: OpId| oid.counter() as i64),
+            }),
+            out,
+        )?;
+        Ok(Self {
+            num,
+            actor,
+            counter,
+        })
+    }
+}
+
+enum SplicingIter<E, I, F> {
+    Failed(E),
+    Iter(I, F),
+}
+
+impl<E, I, F, U> Iterator for SplicingIter<E, I, F>
+where
+    E: std::error::Error + Clone,
+    I: Iterator<Item = OpId>,
+    F: Fn(OpId) -> U,
+{
+    type Item = Result<Option<U>, E>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Failed(e) => Some(Err(e.clone())),
+            Self::Iter(i, f) => i.next().map(|oid| Ok(Some(f(oid)))),
+        }
+    }
+}
+
+/// Find the replace range for the grouped columns.
+fn group_replace_range(
+    replace: Range<usize>,
+    mut num: RleDecoder<'_, u64>,
+) -> Result<Range<usize>, SpliceError<raw::Error, Infallible>> {
+    let mut idx = 0;
+    let mut grouped_replace_start: usize = 0;
+    let mut grouped_replace_len: usize = 0;
+    while idx < replace.start {
+        if let Some(Some(count)) = num.next().transpose().map_err(SpliceError::ReadExisting)? {
+            grouped_replace_start += count as usize;
+        }
+        idx += 1;
+    }
+    for _ in 0..replace.len() {
+        if let Some(Some(count)) = num.next().transpose().map_err(SpliceError::ReadExisting)? {
+            grouped_replace_len += count as usize;
+        }
+    }
+    Ok(grouped_replace_start..(grouped_replace_start + grouped_replace_len))
+}
+
+#[derive(Clone)]
+pub(crate) struct OpIdListIter<'a> {
+    num: RleDecoder<'a, u64>,
+    actor: RleDecoder<'a, u64>,
+    counter: DeltaDecoder<'a>,
+}
+
+impl OpIdListIter<'_> {
+    fn try_next(&mut self) -> Result<Option<Vec<OpId>>, DecodeColumnError> {
+        let num = match self
+            .num
+            .next()
+            .transpose()
+            .map_err(|e| DecodeColumnError::decode_raw("num", e))?
+        {
+            Some(Some(n)) => n,
+            Some(None) => return Err(DecodeColumnError::unexpected_null("num")),
+            None => return Ok(None),
+        };
+
+        // We cannot trust `num` because it is provided over the network,
+        // but in the common case it will be correct and small (so we
+        // use with_capacity to make sure the vector is precisely the right
+        // size).
+        let mut p = Vec::with_capacity(std::cmp::min(num, 100) as usize);
+        for _ in 0..num {
+            let actor = self
+                .actor
+                .next()
+                .transpose()
+                .map_err(|e| DecodeColumnError::decode_raw("actor", e))?;
+            let counter = self
+                .counter
+                .next()
+                .transpose()
+                .map_err(|e| DecodeColumnError::decode_raw("counter", e))?;
+            match (actor, counter) {
+                (Some(Some(a)), Some(Some(ctr))) => match ctr.try_into() {
+                    Ok(ctr) => p.push(OpId::new(ctr, a as usize)),
+                    Err(_e) => {
+                        return Err(DecodeColumnError::invalid_value(
+                            "counter",
+                            "negative value for counter",
+                        ))
+                    }
+                },
+                (Some(None) | None, _) => return Err(DecodeColumnError::unexpected_null("actor")),
+                (_, Some(None) | None) => {
+                    return Err(DecodeColumnError::unexpected_null("counter"))
+                }
+            }
+        }
+        Ok(Some(p))
+    }
+}
+
+impl Iterator for OpIdListIter<'_> {
+    type Item = Result<Vec<OpId>, DecodeColumnError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.try_next().transpose()
+    }
+}
+
+pub(crate) struct OpIdListEncoder<S> {
+    num: RleEncoder<S, u64>,
+    actor: RleEncoder<S, u64>,
+    counter: DeltaEncoder<S>,
+}
+
+impl<S: Sink> OpIdListEncoder<S> {
+    pub(crate) fn append<I, O>(&mut self, ids: I)
+    where
+        I: Iterator<Item = O> + ExactSizeIterator,
+        O: convert::OpId<usize>,
+    {
+        self.num.append_value(ids.len() as u64);
+        for id in ids {
+            self.actor.append_value(id.actor() as u64);
+            self.counter.append_value(id.counter() as i64);
+        }
+    }
+}
+
+impl OpIdListEncoder<Vec<u8>> {
+    pub(crate) fn new() -> Self {
+        Self {
+            num: RleEncoder::from(Vec::new()),
+            actor: RleEncoder::from(Vec::new()),
+            counter: DeltaEncoder::from(Vec::new()),
+        }
+    }
+
+    pub(crate) fn finish(self, out: &mut Vec<u8>) -> OpIdListRange {
+        let start = out.len();
+        let (num, _) = self.num.finish();
+        out.extend(num);
+        let num_end = out.len();
+
+        let (actor, _) = self.actor.finish();
+        out.extend(actor);
+        let actor_end = out.len();
+
+        let (counter, _) = self.counter.finish();
+        out.extend(counter);
+        let counter_end = out.len();
+
+        OpIdListRange {
+            num: (start..num_end).into(),
+            actor: (num_end..actor_end).into(),
+            counter: (actor_end..counter_end).into(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::collection::vec as propvec;
+    use proptest::prelude::*;
+
+    use crate::columnar::encoding::properties::{opid, splice_scenario};
+
+    fn encode(opids: Vec<Vec<OpId>>) -> (OpIdListRange, Vec<u8>) {
+        let mut out = Vec::new();
+        let range = OpIdListRange::encode(opids.iter(), &mut out);
+        (range, out)
+    }
+
+    fn decode(range: OpIdListRange, buf: &[u8]) -> Vec<Vec<OpId>> {
+        range.iter(buf).map(|c| c.unwrap()).collect()
+    }
+
+    proptest! {
+        #[test]
+        fn encode_decode_opid_list(opids in propvec(propvec(opid(), 0..100), 0..100)){
+            let (range, encoded) = encode(opids.clone());
+            let result = decode(range, &encoded);
+            assert_eq!(opids, result)
+        }
+
+        #[test]
+        fn splice_opid_list(scenario in splice_scenario(propvec(opid(), 0..100))) {
+            let (range, encoded) = encode(scenario.initial_values.clone());
+            let mut out = Vec::new();
+            let replacements: Vec<Result<Vec<OpId>, Infallible>> = scenario.replacements.iter().cloned().map(Ok).collect();
+            let new_range = range.splice(
+                &encoded,
+                scenario.replace_range.clone(),
+                replacements.into_iter(),
+                &mut out
+                ).unwrap();
+            let result = decode(new_range, &out[..]);
+            scenario.check(result);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+use std::{borrow::Cow, ops::Range};
+
+use crate::columnar::encoding::RawDecoder;
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct RawRange(Range<usize>);
+
+impl RawRange {
+    pub(crate) fn decoder<'a>(&self, data: &'a [u8]) -> RawDecoder<'a> {
+        RawDecoder::from(Cow::Borrowed(&data[self.0.clone()]))
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub(crate) fn end(&self) -> usize {
+        self.0.end
+    }
+}
+
+impl AsRef<Range<usize>> for RawRange {
+    fn as_ref(&self) -> &Range<usize> {
+        &self.0
+    }
+}
+
+impl From<Range<usize>> for RawRange {
+    fn from(r: Range<usize>) -> RawRange {
+        RawRange(r)
+    }
+}
+
+impl From<RawRange> for Range<usize> {
+    fn from(r: RawRange) -> Range<usize> {
+        r.0
+    }
+}

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

@@ -0,0 +1,216 @@
+use std::{
+    borrow::{Borrow, Cow},
+    fmt::Debug,
+    marker::PhantomData,
+    ops::Range,
+};
+
+use crate::columnar::{
+    encoding::{raw, Decodable, Encodable, RleDecoder, RleEncoder, Sink},
+    SpliceError,
+};
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct RleRange<T> {
+    range: Range<usize>,
+    _phantom: PhantomData<T>,
+}
+
+impl<T> RleRange<T> {
+    pub(crate) fn decoder<'a>(&self, data: &'a [u8]) -> RleDecoder<'a, T> {
+        RleDecoder::from(Cow::Borrowed(&data[self.range.clone()]))
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.range.is_empty()
+    }
+
+    pub(crate) fn start(&self) -> usize {
+        self.range.start
+    }
+
+    pub(crate) fn end(&self) -> usize {
+        self.range.end
+    }
+}
+
+impl<T: Clone + Decodable + Encodable + PartialEq + Eq + Debug> RleRange<T> {
+    /// The semantics of this are similar to `Vec::splice`
+    ///
+    /// # Arguments
+    ///
+    /// * `data` - The buffer containing the original rows
+    /// * `replace` - The range of elements in the original collection to replace
+    /// * `replace_with` - An iterator to insert in place of the original elements.
+    /// * `out` - The buffer to encode the resulting collection into
+    pub(crate) fn splice<
+        'a,
+        I: Iterator<Item = Result<Option<TB>, E>>,
+        TB: Borrow<T> + 'a,
+        E: std::error::Error,
+    >(
+        &self,
+        data: &[u8],
+        replace: Range<usize>,
+        mut replace_with: I,
+        out: &mut Vec<u8>,
+    ) -> Result<Self, SpliceError<raw::Error, E>> {
+        let start = out.len();
+        let mut encoder = self.encoder(out);
+        let mut decoder = self.decoder(data);
+        let mut idx = 0;
+        while idx < replace.start {
+            match decoder
+                .next()
+                .transpose()
+                .map_err(SpliceError::ReadExisting)?
+            {
+                Some(elem) => encoder.append(elem.as_ref()),
+                None => panic!("out of bounds"),
+            }
+            idx += 1;
+        }
+        for _ in 0..replace.len() {
+            decoder.next();
+            if let Some(next) = replace_with
+                .next()
+                .transpose()
+                .map_err(SpliceError::ReadReplace)?
+            {
+                encoder.append(next.as_ref().map(|n| n.borrow()));
+            }
+        }
+        for next in replace_with {
+            let next = next.map_err(SpliceError::ReadReplace)?;
+            encoder.append(next.as_ref().map(|n| n.borrow()));
+        }
+        for next in decoder {
+            let next = next.map_err(SpliceError::ReadExisting)?;
+            encoder.append(next.as_ref());
+        }
+        let (_, len) = encoder.finish();
+        let range = start..(start + len);
+        Ok(range.into())
+    }
+}
+
+impl<T: Encodable + Clone + PartialEq> RleRange<T> {
+    pub(crate) fn encoder<S: Sink>(&self, output: S) -> RleEncoder<S, T> {
+        RleEncoder::from(output)
+    }
+
+    pub(crate) fn encode<BT: Borrow<T>, I: Iterator<Item = Option<BT>>>(
+        items: I,
+        out: &mut Vec<u8>,
+    ) -> Self {
+        let start = out.len();
+        let mut encoder = RleEncoder::new(out);
+        for item in items {
+            encoder.append(item);
+        }
+        let (_, len) = encoder.finish();
+        (start..(start + len)).into()
+    }
+}
+
+impl<T> AsRef<Range<usize>> for RleRange<T> {
+    fn as_ref(&self) -> &Range<usize> {
+        &self.range
+    }
+}
+
+impl<T> From<Range<usize>> for RleRange<T> {
+    fn from(r: Range<usize>) -> RleRange<T> {
+        RleRange {
+            range: r,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T> From<RleRange<T>> for Range<usize> {
+    fn from(r: RleRange<T>) -> Range<usize> {
+        r.range
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::columnar::encoding::properties::option_splice_scenario;
+    use proptest::prelude::*;
+    use std::{borrow::Cow, convert::Infallible};
+
+    #[test]
+    fn rle_int_round_trip() {
+        let vals = [1, 1, 2, 2, 3, 2, 3, 1, 3];
+        let mut buf = Vec::with_capacity(vals.len() * 3);
+        let mut encoder: RleEncoder<_, u64> = RleEncoder::new(&mut buf);
+        for val in vals {
+            encoder.append_value(val)
+        }
+        let (_, total_slice_len) = encoder.finish();
+        let mut decoder: RleDecoder<'_, u64> =
+            RleDecoder::from(Cow::Borrowed(&buf[0..total_slice_len]));
+        let mut result = Vec::new();
+        while let Some(Some(val)) = decoder.next().transpose().unwrap() {
+            result.push(val);
+        }
+        assert_eq!(result, vals);
+    }
+
+    #[test]
+    fn rle_int_insert() {
+        let vals = [1, 1, 2, 2, 3, 2, 3, 1, 3];
+        let mut buf = Vec::with_capacity(vals.len() * 3);
+        let mut encoder: RleEncoder<_, u64> = RleEncoder::new(&mut buf);
+        for val in vals.iter().take(4) {
+            encoder.append_value(val)
+        }
+        encoder.append_value(5);
+        for val in vals.iter().skip(4) {
+            encoder.append_value(val);
+        }
+        let (_, total_slice_len) = encoder.finish();
+        let mut decoder: RleDecoder<'_, u64> =
+            RleDecoder::from(Cow::Borrowed(&buf[0..total_slice_len]));
+        let mut result = Vec::new();
+        while let Some(Some(val)) = decoder.next().transpose().unwrap() {
+            result.push(val);
+        }
+        let expected = [1, 1, 2, 2, 5, 3, 2, 3, 1, 3];
+        assert_eq!(result, expected);
+    }
+
+    fn encode<T: Clone + Encodable + PartialEq>(vals: &[Option<T>]) -> (RleRange<T>, Vec<u8>) {
+        let mut buf = Vec::with_capacity(vals.len() * 3);
+        let range = RleRange::<T>::encode(vals.iter().map(|v| v.as_ref()), &mut buf);
+        (range, buf)
+    }
+
+    fn decode<T: Clone + Decodable + Debug>(range: RleRange<T>, buf: &[u8]) -> Vec<Option<T>> {
+        range.decoder(buf).collect::<Result<Vec<_>, _>>().unwrap()
+    }
+
+    proptest! {
+        #[test]
+        fn splice_ints(scenario in option_splice_scenario(any::<Option<i32>>())) {
+            let (range, buf) = encode(&scenario.initial_values);
+            let mut out = Vec::new();
+            let replacements: Vec<Result<Option<i32>, Infallible>> = scenario.replacements.iter().cloned().map(Ok).collect();
+            let new_range = range.splice(&buf, scenario.replace_range.clone(), replacements.into_iter(), &mut out).unwrap();
+            let result = decode::<i32>(new_range, &out);
+            scenario.check_optional(result)
+        }
+
+        #[test]
+        fn splice_strings(scenario in option_splice_scenario(any::<Option<String>>())) {
+            let (range, buf) = encode(&scenario.initial_values);
+            let mut out = Vec::new();
+            let replacements: Vec<Result<Option<String>, Infallible>> = scenario.replacements.iter().cloned().map(Ok).collect();
+            let new_range = range.splice(&buf, scenario.replace_range.clone(), replacements.into_iter(), &mut out).unwrap();
+            let result = decode::<String>(new_range, &out);
+            scenario.check_optional(result)
+        }
+    }
+}