Struct Patch 

pub struct Patch { /* private fields */ }

A collection of operations to apply atomically.

Patches are the primary way to describe changes to a document. Operations are applied in order.

Examples

use tirea_state::{Patch, Op, path};
use serde_json::json;

let patch = Patch::new()
    .with_op(Op::set(path!("name"), json!("Alice")))
    .with_op(Op::set(path!("age"), json!(30)));

assert_eq!(patch.len(), 2);

Implementations

impl Patch

pub fn new() -> Self

Create an empty patch.

pub fn with_ops(ops: Vec<Op>) -> Self

Create a patch with the given operations.

pub fn with_op(self, op: Op) -> Self

Add an operation to this patch (builder pattern).

pub fn push(&mut self, op: Op)

Push an operation onto this patch.

pub fn ops(&self) -> &[Op]

Get the operations in this patch.

pub fn ops_mut(&mut self) -> &mut Vec<Op>

Get mutable access to the operations.

pub fn into_ops(self) -> Vec<Op>

Consume this patch and return the operations.

pub fn is_empty(&self) -> bool

Check if this patch is empty.

pub fn len(&self) -> usize

Get the number of operations in this patch.

pub fn extend(&mut self, other: Patch)

Extend this patch with operations from another patch.

pub fn merge(&mut self, other: Patch)

Merge another patch into this one (alias for extend).

pub fn clear(&mut self)

Clear all operations from this patch.

pub fn iter(&self) -> impl Iterator<Item = &Op>

Iterate over the operations.

pub fn canonicalize(&self) -> Patch

Canonicalize the patch by removing redundant operations.

This is a safe, semantics-preserving optimization that:

• Removes earlier Set operations when a later Set targets the same path
• Removes earlier Set operations when a later Delete targets the same path
• Removes earlier Delete operations when a later Set or Delete targets the same path

Important: This function only removes redundant operations. It never reorders the remaining operations. The output is always a subsequence of the input in the same relative order.

Operations that are not optimized (kept as-is):

• Increment, Decrement, MergeObject: These have cumulative effects and cannot be safely deduplicated without semantic analysis
• Append, Insert, Remove: Array operations are order-sensitive

Examples

use tirea_state::{Patch, Op, path};
use serde_json::json;

let patch = Patch::new()
    .with_op(Op::set(path!("name"), json!("Alice")))
    .with_op(Op::set(path!("name"), json!("Bob")));  // overwrites Alice

let canonical = patch.canonicalize();
assert_eq!(canonical.len(), 1);
assert_eq!(canonical.ops()[0], Op::set(path!("name"), json!("Bob")));

Trait Implementations

impl Clone for Patch

fn clone(&self) -> Patch

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Patch

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Patch

fn default() -> Patch

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Patch

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<Op> for Patch

fn extend<I: IntoIterator<Item = Op>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl From<Patch> for TrackedPatch

fn from(patch: Patch) -> Self

Converts to this type from the input type.

impl FromIterator<Op> for Patch

fn from_iter<I: IntoIterator<Item = Op>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> IntoIterator for &'a Patch

type Item = &'a Op

The type of the elements being iterated over.

type IntoIter = Iter<'a, Op>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for Patch

type Item = Op

The type of the elements being iterated over.

type IntoIter = IntoIter<Op>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Patch

fn eq(&self, other: &Patch) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PatchExt for Patch

fn touched(&self, include_parents: bool) -> BTreeSet<Path>

Compute the paths touched by this patch.

fn conflicts_with(&self, other: &Patch) -> Vec<Conflict>

Check if this patch conflicts with another patch.

impl Serialize for Patch

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Patch