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 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);
}