#[cfg(feature = "alloc")]
use alloc::{collections::{BTreeMap, VecDeque}, vec::Vec, vec};
#[cfg(feature = "deku")]
use deku::{no_std_io::{Read, Seek, Write}, prelude::*};
#[cfg(feature = "macros")]
pub use deltapatcher_macros::WrappingArithmetic;
use crate::{Delta, Diff, Patch};
#[cfg(feature = "alloc")]
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SliceDelta<T> {
entries: BTreeMap<u32, SliceDeltaEntry<T>>,
}
#[cfg(feature = "alloc")]
impl<T> Default for SliceDelta<T> {
fn default() -> Self {
Self {
entries: BTreeMap::new(),
}
}
}
#[cfg(feature = "alloc")]
impl<T> SliceDelta<T> {
pub fn new() -> Self {
Self::default()
}
pub fn aggregate_entry(&mut self, mut next: SliceDeltaEntry<T>) {
let lower = self
.entries
.range(..next.start_index)
.next_back()
.filter(|(_, e)| e.remove_end() >= next.start_index)
.map(|(&k, _)| k);
if let Some(k) = lower {
let prev = self.entries.remove(&k).unwrap();
next = merge_two(prev, next);
}
loop {
let upper = self
.entries
.range(next.start_index..)
.next()
.filter(|(_, e)| e.start_index <= next.remove_end())
.map(|(&k, _)| k);
match upper {
Some(k) => {
let other = self.entries.remove(&k).unwrap();
next = merge_two(next, other);
}
None => break,
}
}
self.entries.insert(next.start_index, next);
}
}
#[cfg(all(feature = "alloc", feature = "deku"))]
impl<T, Ctx> DekuWriter<Ctx> for SliceDelta<T>
where
Ctx: Copy,
u32: DekuWriter<Ctx>,
SliceDeltaEntry<T>: DekuWriter<Ctx>,
{
fn to_writer<W: Write + Seek>(
&self,
writer: &mut Writer<W>,
ctx: Ctx,
) -> Result<(), DekuError> {
(self.entries.len() as u32).to_writer(writer, ctx)?;
for entry in self.entries.values() {
entry.to_writer(writer, ctx)?;
}
Ok(())
}
}
#[cfg(all(feature = "alloc", feature = "deku"))]
impl<'a, T, Ctx> DekuReader<'a, Ctx> for SliceDelta<T>
where
Ctx: Copy,
u32: DekuReader<'a, Ctx>,
SliceDeltaEntry<T>: DekuReader<'a, Ctx>,
{
fn from_reader_with_ctx<R: Read + Seek>(
reader: &mut Reader<R>,
ctx: Ctx,
) -> Result<Self, DekuError> {
let count = u32::from_reader_with_ctx(reader, ctx)? as usize;
let mut entries = BTreeMap::new();
for _ in 0..count {
let entry = SliceDeltaEntry::<T>::from_reader_with_ctx(reader, ctx)?;
entries.insert(entry.start_index, entry);
}
Ok(Self { entries })
}
}
#[cfg(feature = "alloc")]
fn merge_two<T>(a: SliceDeltaEntry<T>, b: SliceDeltaEntry<T>) -> SliceDeltaEntry<T> {
debug_assert!(a.start_index <= b.start_index);
let start = a.start_index;
let remove_end = a.remove_end().max(b.remove_end());
let mut add = a.add;
add.extend(b.add);
SliceDeltaEntry {
start_index: start,
remove: remove_end - start,
add,
}
}
#[cfg(feature = "alloc")]
enum Segment<T> {
Unchanged { a_start: u32, a_end: Option<u32> },
Added(Vec<T>),
}
#[cfg(feature = "alloc")]
impl<T> Segment<T> {
fn len(&self) -> Option<u32> {
match self {
Segment::Unchanged { a_start, a_end } => a_end.map(|e| e - a_start),
Segment::Added(items) => Some(items.len() as u32),
}
}
}
#[cfg(feature = "alloc")]
fn take_front<T: Clone>(segments: &mut VecDeque<Segment<T>>, mut want: u32) {
while want > 0 {
let seg = segments
.front_mut()
.expect("next's entries remove more content than is available");
match seg.len() {
Some(avail) if avail <= want => {
want -= avail;
segments.pop_front();
}
_ => {
match seg {
Segment::Unchanged { a_start, .. } => *a_start += want,
Segment::Added(items) => {
items.drain(0..want as usize);
}
}
want = 0;
}
}
}
}
#[cfg(feature = "alloc")]
fn advance_to<T: Clone>(segments: &mut VecDeque<Segment<T>>, output: &mut Vec<Segment<T>>, mut want: u32) {
while want > 0 {
let avail = segments
.front()
.expect("next's entries start past the end of the aggregated vector")
.len();
match avail {
Some(avail) if avail <= want => {
want -= avail;
output.push(segments.pop_front().unwrap());
}
_ => {
let front = segments.front_mut().unwrap();
match front {
Segment::Unchanged { a_start, .. } => {
let split = *a_start + want;
output.push(Segment::Unchanged {
a_start: *a_start,
a_end: Some(split),
});
*a_start = split;
}
Segment::Added(items) => {
let head: Vec<T> = items.drain(0..want as usize).collect();
output.push(Segment::Added(head));
}
}
want = 0;
}
}
}
}
#[cfg(feature = "alloc")]
impl<T: Clone> Delta for SliceDelta<T> {
fn aggregate(&mut self, next: &Self) {
self.aggregate_owned(next.clone());
}
fn aggregate_owned(&mut self, next: Self) {
let mut segments: VecDeque<Segment<T>> = VecDeque::new();
let mut cursor_a = 0u32;
for entry in core::mem::take(&mut self.entries).into_values() {
if entry.start_index > cursor_a {
segments.push_back(Segment::Unchanged {
a_start: cursor_a,
a_end: Some(entry.start_index),
});
}
cursor_a = entry.remove_end();
if !entry.add.is_empty() {
segments.push_back(Segment::Added(entry.add)); }
}
segments.push_back(Segment::Unchanged {
a_start: cursor_a,
a_end: None,
});
let mut output: Vec<Segment<T>> = Vec::new();
let mut b_cursor = 0u32;
for entry in next.entries.into_values() {
advance_to(&mut segments, &mut output, entry.start_index - b_cursor);
take_front(&mut segments, entry.remove);
b_cursor = entry.remove_end(); if !entry.add.is_empty() {
output.push(Segment::Added(entry.add)); }
}
output.extend(segments);
let mut new_entries = BTreeMap::new();
let mut next_expected_a = 0u32;
let mut add_buffer: Vec<T> = Vec::new();
for segment in output {
match segment {
Segment::Added(items) => add_buffer.extend(items),
Segment::Unchanged { a_start, a_end } => {
if a_start != next_expected_a || !add_buffer.is_empty() {
let entry = SliceDeltaEntry::new(
next_expected_a,
a_start - next_expected_a,
core::mem::take(&mut add_buffer),
);
new_entries.insert(entry.start_index, entry);
}
next_expected_a = a_end.unwrap_or(a_start);
}
}
}
self.entries = new_entries;
}
}
#[cfg(feature = "alloc")]
fn diff_slices<T: Clone + PartialEq>(initial: &[T], final_: &[T]) -> SliceDelta<T> {
let n = initial.len();
let m = final_.len();
let mut lcs = vec![vec![0u32; m + 1]; n + 1];
for i in (0..n).rev() {
for j in (0..m).rev() {
lcs[i][j] = if initial[i] == final_[j] {
lcs[i + 1][j + 1] + 1
} else {
lcs[i + 1][j].max(lcs[i][j + 1])
};
}
}
let mut entries = BTreeMap::new();
let (mut i, mut j) = (0usize, 0usize);
let mut run_start: Option<usize> = None;
let mut run_add: Vec<T> = Vec::new();
let mut run_remove = 0u32;
macro_rules! flush {
() => {
#[allow(unused_assignments)]
{
if let Some(start) = run_start.take() {
if run_remove != 0 || !run_add.is_empty() {
let entry = SliceDeltaEntry::new(
start as u32,
run_remove,
core::mem::take(&mut run_add),
);
entries.insert(entry.start_index, entry);
}
run_remove = 0;
}
}
};
}
while i < n && j < m {
if initial[i] == final_[j] {
flush!();
i += 1;
j += 1;
} else if lcs[i + 1][j] >= lcs[i][j + 1] {
run_start.get_or_insert(i);
run_remove += 1;
i += 1;
} else {
run_start.get_or_insert(i);
run_add.push(final_[j].clone());
j += 1;
}
}
if i < n {
run_start.get_or_insert(i);
run_remove += (n - i) as u32;
}
if j < m {
run_start.get_or_insert(n);
run_add.extend(final_[j..].iter().cloned());
}
flush!();
SliceDelta { entries }
}
#[cfg(feature = "alloc")]
impl<T: Clone + PartialEq> Diff<SliceDelta<T>> for Vec<T> {
fn diff(&self, initial: &Self) -> SliceDelta<T> {
diff_slices(initial, self)
}
}
#[cfg(feature = "alloc")]
impl<T: Clone> Patch<SliceDelta<T>> for Vec<T> {
fn patch(&mut self, delta: &SliceDelta<T>) {
for entry in delta.entries.values().rev() {
let start = entry.start_index as usize;
let end = start + entry.remove as usize;
self.splice(start..end, entry.add.iter().cloned());
}
}
}
#[cfg(feature = "alloc")]
impl<T: Clone + PartialEq> Diff<SliceDelta<T>> for [T] {
fn diff(&self, initial: &Self) -> SliceDelta<T> {
diff_slices(initial, self)
}
}
#[cfg(feature = "alloc")]
impl<T: Clone + PartialEq> Patch<SliceDelta<T>> for [T] {
fn patch(&mut self, delta: &SliceDelta<T>) {
let mut buffer: Vec<T> = Vec::with_capacity(self.len());
let mut read = 0usize;
for entry in delta.entries.values() {
let start = entry.start_index as usize;
buffer.extend_from_slice(&self[read..start]);
read = start + entry.remove as usize;
buffer.extend(entry.add.iter().cloned());
}
buffer.extend_from_slice(&self[read..]);
assert!(
buffer.len() <= self.len(),
"patch would increase the length of the slice"
);
self[..buffer.len()].clone_from_slice(&buffer);
}
}
#[cfg(feature = "alloc")]
impl<T: Clone + PartialEq, const N: usize> Diff<SliceDelta<T>> for [T; N] {
fn diff(&self, initial: &Self) -> SliceDelta<T> {
<[T] as Diff<SliceDelta<T>>>::diff(self, initial)
}
}
#[cfg(feature = "alloc")]
impl<T: Clone + PartialEq, const N: usize> Patch<SliceDelta<T>> for [T; N] {
fn patch(&mut self, delta: &SliceDelta<T>) {
<[T]>::patch(self, delta)
}
}
#[cfg(feature = "alloc")]
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SliceDeltaEntry<T> {
start_index: u32,
remove: u32,
add: Vec<T>,
}
#[cfg(feature = "alloc")]
impl<T> SliceDeltaEntry<T> {
pub fn new(start_index: u32, remove: u32, add: Vec<T>) -> Self {
assert!(remove != 0 || !add.is_empty());
Self {
start_index,
remove,
add,
}
}
pub fn insert(start_index: u32, add: Vec<T>) -> Self {
Self::new(start_index, 0, add)
}
pub fn remove(start_index: u32, remove: u32) -> Self {
Self::new(start_index, remove, Vec::new())
}
pub fn replace(start_index: u32, new_values: Vec<T>) -> Self {
Self::new(start_index, new_values.len() as u32, new_values)
}
pub const fn remove_end(&self) -> u32 {
self.start_index + self.remove
}
pub const fn add_len(&self) -> u32 {
self.add.len() as u32
}
pub const fn end_after(&self) -> u32 {
self.start_index + self.add_len()
}
pub const fn delta_len(&self) -> i64 {
self.add_len() as i64 - self.remove as i64
}
pub const fn contains_index(&self, index: u32) -> bool {
index >= self.start_index && index < self.remove_end()
}
}
#[cfg(all(feature = "alloc", feature = "deku"))]
impl<T, Ctx> DekuWriter<Ctx> for SliceDeltaEntry<T>
where
Ctx: Copy,
u32: DekuWriter<Ctx>,
T: DekuWriter<Ctx>,
{
fn to_writer<W: Write + Seek>(
&self,
writer: &mut Writer<W>,
ctx: Ctx,
) -> Result<(), DekuError> {
self.start_index.to_writer(writer, ctx)?;
self.remove.to_writer(writer, ctx)?;
(self.add.len() as u32).to_writer(writer, ctx)?;
for item in &self.add {
item.to_writer(writer, ctx)?;
}
Ok(())
}
}
#[cfg(all(feature = "alloc", feature = "deku"))]
impl<'a, T, Ctx> DekuReader<'a, Ctx> for SliceDeltaEntry<T>
where
Ctx: Copy,
u32: DekuReader<'a, Ctx>,
T: DekuReader<'a, Ctx>,
{
fn from_reader_with_ctx<R: Read + Seek>(
reader: &mut Reader<R>,
ctx: Ctx,
) -> Result<Self, DekuError> {
let start_index = u32::from_reader_with_ctx(reader, ctx)?;
let remove = u32::from_reader_with_ctx(reader, ctx)?;
let add_count = u32::from_reader_with_ctx(reader, ctx)? as usize;
let mut add = Vec::with_capacity(add_count);
for _ in 0..add_count {
add.push(T::from_reader_with_ctx(reader, ctx)?);
}
Ok(Self {
start_index,
remove,
add,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ArithmeticDelta<T: WrappingArithmetic>(pub T);
impl<T> Delta for ArithmeticDelta<T>
where
T: WrappingArithmetic,
{
fn aggregate(&mut self, next: &Self) {
self.0 = self.0.wrapping_add(next.0);
}
}
#[cfg(feature = "deku")]
impl<T, Ctx> DekuWriter<Ctx> for ArithmeticDelta<T>
where
T: WrappingArithmetic + DekuWriter<Ctx>,
{
fn to_writer<W: Write+Seek>(&self, writer: &mut Writer<W>, ctx: Ctx,) -> Result<(), DekuError> {
self.0.to_writer(writer, ctx)
}
}
#[cfg(feature = "deku")]
impl<'a, T, Ctx> DekuReader<'a, Ctx> for ArithmeticDelta<T>
where
T: WrappingArithmetic + DekuReader<'a, Ctx>,
{
fn from_reader_with_ctx<R: Read + Seek>(reader: &mut Reader<R>, ctx: Ctx,) -> Result<Self, DekuError>
where
Self: Sized {
T::from_reader_with_ctx(reader, ctx).map(Self)
}
}
pub trait WrappingArithmetic: Copy {
fn wrapping_add(self, rhs: Self) -> Self;
fn wrapping_sub(self, rhs: Self) -> Self;
}
macro_rules! impl_wrapping_arith {
($T: ty) => {
impl WrappingArithmetic for $T {
fn wrapping_add(self, rhs: $T) -> $T {
<$T>::wrapping_add(self, rhs)
}
fn wrapping_sub(self, rhs: $T) -> $T {
<$T>::wrapping_sub(self, rhs)
}
}
};
($($T: ty),*) => {
$(impl_wrapping_arith!($T);)*
};
}
impl_wrapping_arith! {
u8,
u16,
u32,
u64,
u128,
usize,
i8,
i16,
i32,
i64,
i128,
isize
}
impl<T: WrappingArithmetic> Diff<ArithmeticDelta<Self>> for T
{
fn diff(&self, initial: &Self) -> ArithmeticDelta<Self> {
ArithmeticDelta(self.wrapping_sub(*initial))
}
}
impl<T: WrappingArithmetic> Patch<ArithmeticDelta<Self>> for T
{
fn patch(&mut self, delta: &ArithmeticDelta<Self>) {
*self = self.wrapping_add(delta.0);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn assert_roundtrip<T, D>(initial: T, final_: T)
where
T: Diff<D> + Clone + PartialEq + core::fmt::Debug,
{
let delta = final_.diff(&initial);
let mut applied = initial.clone();
applied.patch(&delta);
assert_eq!(applied, final_);
}
mod without_delta {
use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Flip(bool);
impl Diff<Flip> for bool {
fn diff(&self, initial: &Self) -> Flip {
Flip(self != initial)
}
}
impl Patch<Flip> for bool {
fn patch(&mut self, delta: &Flip) {
if delta.0 {
*self = !*self;
}
}
}
#[test]
fn diff_and_apply() {
assert_roundtrip::<bool, Flip>(true, false);
assert_roundtrip::<bool, Flip>(false, true);
assert_roundtrip::<bool, Flip>(true, true);
assert_roundtrip::<bool, Flip>(false, false);
}
}
#[cfg(feature = "alloc")]
mod slice {
use super::*;
#[test]
fn diff_and_apply() {
assert_roundtrip(vec![1, 2, 3, 4], vec![1, 5, 3, 6, 4]);
assert_roundtrip(vec![1, 2, 3], vec![]);
assert_roundtrip(vec![], vec![1, 2, 3]);
assert_roundtrip(vec![1, 2, 3], vec![1, 2, 3]);
}
#[test]
fn aggregate_matches_direct_diff() {
let a = vec![1, 2, 3, 4, 5];
let b = vec![1, 9, 3, 4, 10, 5];
let c = vec![9, 3, 11, 4, 10];
let mut d1 = b.diff(&a);
let d2 = c.diff(&b);
d1.aggregate(&d2);
let mut applied = a.clone();
applied.patch(&d1);
assert_eq!(applied, c);
}
#[test]
fn aggregate_entry_merges_touching_ranges() {
let mut delta = SliceDelta::<i32>::new();
delta.aggregate_entry(SliceDeltaEntry::replace(0, vec![1, 2]));
delta.aggregate_entry(SliceDeltaEntry::replace(2, vec![3]));
assert_eq!(delta.entries.len(), 1);
let entry = delta.entries.values().next().unwrap();
assert_eq!(entry.start_index, 0);
assert_eq!(entry.add, vec![1, 2, 3]);
}
#[test]
fn slice_patch_same_length() {
let initial = [1, 2, 3, 4];
let final_ = vec![1, 5, 3, 6];
let delta = final_.diff(&initial.to_vec());
let mut buf = initial;
buf.patch(&delta);
assert_eq!(buf, [1, 5, 3, 6]);
}
#[test]
fn slice_patch_shrink_ok() {
let initial = [1, 2, 3, 4, 5];
let final_ = vec![1, 3, 5];
let delta = final_.diff(&initial.to_vec());
let mut buf = initial;
buf.patch(&delta);
assert_eq!(&buf[..3], [1, 3, 5]); }
#[test]
#[should_panic(expected = "increase the length")]
fn slice_patch_growth_panics() {
let initial = [1, 2, 3];
let final_ = vec![1, 2, 3, 4];
let delta = final_.diff(&initial.to_vec());
let mut buf = initial;
buf.patch(&delta);
}
#[test]
fn slice_patch_permutation_no_extra_space() {
let initial: [u8; 10] = [4, 5, 6, 7, 8, 9, 10, 1, 2, 3];
let final_ = vec![8, 1, 5, 2, 3, 6, 7, 9, 10, 4];
let delta = final_.diff(&initial.to_vec());
let mut buf = initial;
buf.patch(&delta); assert_eq!(buf, [8, 1, 5, 2, 3, 6, 7, 9, 10, 4]);
}
}
mod arithmetic {
use super::*;
#[test]
fn diff_and_apply() {
assert_roundtrip(5u32, 10u32);
assert_roundtrip(-1i32, i32::MAX);
assert_roundtrip(i32::MIN, i32::MAX);
assert_roundtrip(u8::MAX, u8::MIN);
}
}
#[cfg(feature = "macros")]
mod derive_enum {
use super::*;
use deltapatcher_macros::Diff;
extern crate self as deltapatcher;
#[derive(Diff, Debug, Clone, PartialEq)]
enum Shape {
Rect {
#[deltapatcher(delta_ty = ArithmeticDelta<i32>)]
width: i32,
#[deltapatcher(delta_ty = ArithmeticDelta<i32>)]
height: i32,
},
Circle(
#[deltapatcher(delta_ty = ArithmeticDelta<u32>)]
u32,
),
Point,
}
#[test]
fn same_variant_named_roundtrip() {
assert_roundtrip(
Shape::Rect { width: 10, height: 20 },
Shape::Rect { width: 30, height: 5 },
);
}
#[test]
fn same_variant_unnamed_roundtrip() {
assert_roundtrip(Shape::Circle(4), Shape::Circle(100));
}
#[test]
fn same_variant_unit_roundtrip() {
assert_roundtrip(Shape::Point, Shape::Point);
}
#[test]
fn cross_variant_named_to_unnamed_roundtrip() {
assert_roundtrip(
Shape::Rect { width: 1, height: 2 },
Shape::Circle(99),
);
}
#[test]
fn cross_variant_unnamed_to_unit_roundtrip() {
assert_roundtrip(Shape::Circle(7), Shape::Point);
}
#[test]
fn cross_variant_unit_to_named_roundtrip() {
assert_roundtrip(
Shape::Point,
Shape::Rect { width: -3, height: 42 },
);
}
#[test]
fn aggregate_same_variant_matches_direct_diff() {
let a = Shape::Rect { width: 0, height: 0 };
let b = Shape::Rect { width: 10, height: -5 };
let c = Shape::Rect { width: 3, height: 20 };
let mut d_ab = b.diff(&a);
let d_bc = c.diff(&b);
d_ab.aggregate(&d_bc);
let mut result = a.clone();
result.patch(&d_ab);
assert_eq!(result, c);
}
#[test]
fn aggregate_replace_then_same_variant() {
let a = Shape::Circle(1);
let b = Shape::Rect { width: 10, height: 20 };
let c = Shape::Rect { width: 30, height: 5 };
let mut d1 = b.diff(&a);
let d2 = c.diff(&b);
d1.aggregate(&d2);
let mut result = a.clone();
result.patch(&d1);
assert_eq!(result, c);
}
#[test]
fn aggregate_same_variant_then_replace() {
let a = Shape::Rect { width: 0, height: 0 };
let b = Shape::Rect { width: 5, height: 5 };
let c = Shape::Circle(42);
let mut d1 = b.diff(&a);
let d2 = c.diff(&b); d1.aggregate(&d2);
let mut result = a.clone();
result.patch(&d1);
assert_eq!(result, c);
}
#[test]
fn aggregate_replace_then_replace() {
let a = Shape::Point;
let b = Shape::Circle(10);
let c = Shape::Rect { width: -1, height: -1 };
let mut d1 = b.diff(&a); let d2 = c.diff(&b); d1.aggregate(&d2);
let mut result = a.clone();
result.patch(&d1);
assert_eq!(result, c);
}
}
#[cfg(feature = "deku")]
mod deku_tests {
use super::*;
use deku::ctx::Endian;
use deku::reader::Reader;
use deku::writer::Writer;
use std::io::Cursor;
#[test]
fn test_arithmetic_delta_endianness() {
let delta = ArithmeticDelta(0x12345678_u32);
let mut buf_be = vec![];
let mut writer_be = Writer::new(Cursor::new(&mut buf_be));
delta.to_writer(&mut writer_be, Endian::Big).unwrap();
assert_eq!(buf_be, vec![0x12, 0x34, 0x56, 0x78]);
let mut reader_be = Reader::new(Cursor::new(buf_be.as_slice()));
let decoded_be = ArithmeticDelta::<u32>::from_reader_with_ctx(&mut reader_be, Endian::Big).unwrap();
assert_eq!(delta, decoded_be);
let mut buf_le = vec![];
let mut writer_le = Writer::new(Cursor::new(&mut buf_le));
delta.to_writer(&mut writer_le, Endian::Little).unwrap();
assert_eq!(buf_le, vec![0x78, 0x56, 0x34, 0x12]);
let mut reader_le = Reader::new(Cursor::new(buf_le.as_slice()));
let decoded_le = ArithmeticDelta::<u32>::from_reader_with_ctx(&mut reader_le, Endian::Little).unwrap();
assert_eq!(delta, decoded_le);
}
#[cfg(feature = "alloc")]
#[test]
fn test_slice_delta_serialization_format() {
let mut delta = SliceDelta::<u16>::new();
delta.aggregate_entry(SliceDeltaEntry::new(1, 2, vec![0xAAAA, 0xBBBB]));
delta.aggregate_entry(SliceDeltaEntry::new(5, 0, vec![0xCCCC]));
let mut buf = vec![];
let mut writer = Writer::new(Cursor::new(&mut buf));
delta.to_writer(&mut writer, Endian::Little).unwrap();
let expected_bytes = vec![
2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0xAA, 0xAA, 0xBB, 0xBB, 5, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0xCC, 0xCC, ];
assert_eq!(buf, expected_bytes);
}
#[cfg(feature = "alloc")]
#[test]
fn test_slice_delta_roundtrip() {
let mut delta = SliceDelta::<i32>::new();
delta.aggregate_entry(SliceDeltaEntry::new(0, 5, vec![1, 2, 3]));
delta.aggregate_entry(SliceDeltaEntry::new(10, 0, vec![99, 100]));
let mut buf = vec![];
let mut writer = Writer::new(Cursor::new(&mut buf));
delta.to_writer(&mut writer, Endian::Big).unwrap();
let mut reader = Reader::new(Cursor::new(buf.as_slice()));
let decoded = SliceDelta::<i32>::from_reader_with_ctx(&mut reader, Endian::Big).unwrap();
assert_eq!(delta.entries.len(), decoded.entries.len());
for (key, original_entry) in &delta.entries {
let decoded_entry = decoded.entries.get(key).unwrap();
assert_eq!(original_entry, decoded_entry);
}
}
}
}