cumulo-dipa 0.1.2

dipa makes it easy to efficiently delta encode large Rust data structures.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! dipa makes it easy to efficiently delta encode large Rust data structures.
//!
//! # Repository
//!
//! The source code is available at [https://github.com/chinedufn/dipa]
//!
//! # Documentation
//!
//! The Dipa Book introduces you to dipa and teaches you how to use it.
//!
//! It is available online at [https://chinedufn.github.io/dipa/]
//!
//! You can also view the book offline:
//!
//! ```sh,no_run,ignore
//! # Do this once while online
//! git clone git@github.com:chinedufn/dipa.git && cd dipa
//! cargo install mdbook
//!
//! # This works offline
//! ./bin/serve-book.sh
//! ```

#[macro_use]
extern crate serde;

#[cfg(feature = "derive")]
pub use cumulo_dipa_derive::DiffPatch;

mod sequence;

mod bool;
mod cow;
mod float;
mod integer;
mod map;
mod null;
mod option;
mod set;
mod string;
mod tuple;

#[macro_use]
mod number_impl;

mod delta_n;

#[cfg(any(test, feature = "impl-tester"))]
mod dipa_impl_tester;
#[cfg(any(test, feature = "impl-tester"))]
pub use self::dipa_impl_tester::DipaImplTester;

/// The type returned by [Diffable.create_delta_towards].
pub struct CreatedDelta<D> {
    /// The diff between the start and end value.
    pub delta: D,
    /// True if changed, false if same.
    pub did_change: bool,
}

/// Allows a type to be diffed with another type.
pub trait Diffable<'s, 'e, Other: ?Sized> {
    /// This will typically hold references to data from the structs that are being diffed.
    type Delta;

    /// This will typically be an owned version of [`Self::Delta`].
    type DeltaOwned;

    /// Diff self with some target end state, generating a patch that would convert
    ///  self -> end_state.
    fn create_delta_towards(&'s self, end_state: &'e Other) -> CreatedDelta<Self::Delta>;
}

/// Modifies a type using n a patch.
///
/// You would typically create this patch using [`Diffable.create_delta_towards`].
///
/// You'll typically serialize to a [`Diffable::Delta`], send it over a network and then deserialize
/// to [`Diffable::DeltaOwned`]. Then you would use that owned delta as the patch to apply via
/// [`Patchable.apply_patch`].
///
/// FIXME: This should return a result since it is possible to, for example, accidentally apply a
///  a patch to the wrong data structure do to a logical bug.
pub trait Patchable<P> {
    /// Apply a patch.
    fn apply_patch(&mut self, patch: P);
}