Struct Mutations 

pub struct Mutations<V = Box<dyn Serialize>> { /* private fields */ }

A collection of mutations collected during observation.

It is the return type for flush and flat_flush operations.

Behavior

• If no mutations are pushed, into_inner returns None.
• If exactly one mutation is pushed, it is returned as-is.
• If multiple mutations are pushed, they are wrapped in a Batch.

The is_replace flag tracks whether this collection represents a whole-value replace. It is set automatically when constructed from a Replace mutation, and is used by flat_flush to propagate replace status to parent observers for replace collapse.

Example

use morphix::{Mutation, MutationKind, Mutations};

let mut mutations = Mutations::new();

mutations.insert("a", MutationKind::Replace(42));
mutations.insert("b", MutationKind::Truncate(1));

let result = mutations.into_inner();
assert!(matches!(result, Some(Mutation { kind: MutationKind::Batch(_), .. })));

Implementations

impl<V> Mutations<V>

pub fn new() -> Self

Creates a new empty collection.

pub fn with_capacity(self, capacity: usize) -> Self

Sets the capacity hint for the internal Batch storage.

The capacity hint is used when the internal storage needs to be converted to a Batch to hold multiple mutations.

pub fn with_replace(self, is_replace: bool) -> Self

Sets the is_replace flag on this collection.

This is used by composite observers to propagate replace status through flat_flush, where the collection may contain per-field mutations that are a flattened decomposition of a whole-value replace.

pub fn with_prefix(self, segment: impl Into<PathSegment>) -> Self

Prepends a path segment to the contained mutation.

If the collection is empty, this is a no-op. Otherwise, the segment is pushed onto the mutation’s reverse-order path.

pub fn into_inner(self) -> Option<Mutation<V>>

Consumes the batch and returns the collected mutation.

pub fn is_replace(&self) -> bool

Returns true if this collection represents a whole-value replace.

This flag is set automatically when the collection is created from a Replace mutation kind, or explicitly via with_replace. It is used by flat_flush to signal to the parent observer that the entire content was replaced, enabling replace collapse.

pub fn extend(&mut self, mutations: impl Into<Self>)

Merges another collection of mutations into this one.

If the incoming collection contains a Batch with an empty path, its inner mutations are flattened into this collection rather than being nested.

pub fn insert( &mut self, segment: impl Into<PathSegment>, mutations: impl Into<Self>, )

Inserts mutations at a specified path segment.

The incoming mutations will have the given segment prepended to their path before being added to this collection.

pub fn len(&self) -> usize

Returns the number of top-level mutations in this collection.

A top-level mutation is one with an empty path. If this collection contains a Batch with an empty path, this returns the number of mutations in that batch. Otherwise, it returns 1 if a mutation exists, or 0 if the collection is empty.

pub fn is_empty(&self) -> bool

Returns true if this collection contains no mutations.

pub fn truncate(len: usize) -> Self

Available on crate feature truncate only.

Creates a Mutations containing a single Truncate mutation.

pub fn delete() -> Self

Available on crate feature delete only.

Creates a Mutations containing a single Delete mutation.

pub fn into_delete(self) -> Self

Available on crate feature delete only.

Converts all mutations in this collection to Delete.

Each mutation retains its path but has its kind replaced with Delete. For a Batch, every inner mutation is converted individually, preserving the per-field paths. This is used by flat_flush when the parent needs to emit deletions for all fields of a flattened struct or map.

impl Mutations

pub fn replace_owned<T: Serialize + 'static>(value: T) -> Self

Creates a Mutations containing a single Replace mutation, taking ownership of the value.

Unlike replace, which accepts &T (including unsized types) and wraps it in [SerializeRef], this method takes T by value and boxes it directly.

pub fn replace<T: Serialize + ?Sized + 'static>(value: &T) -> Self

Creates a Mutations containing a single Replace mutation with the given value.

The value is wrapped in a Box<dyn Serialize> via [SerializeRef], allowing unsized types like str and [T] to be used.

pub fn append_owned<T: Serialize + 'static>(value: T) -> Self

Available on crate feature append only.

Creates a Mutations containing a single Append mutation, taking ownership of the value.

Unlike append, which accepts &T (including unsized types) and wraps it in [SerializeRef], this method takes T by value and boxes it directly.

pub fn append<T: Serialize + ?Sized + 'static>(value: &T) -> Self

Available on crate feature append only.

Creates a Mutations containing a single Append mutation with the given value.

The value is wrapped in a Box<dyn Serialize> via [SerializeRef], allowing unsized types like str and [T] to be used.

Trait Implementations

impl<V: Clone> Clone for Mutations<V>

fn clone(&self) -> Mutations<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for Mutations<V>

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

Formats the value using the given formatter.

impl<V> Default for Mutations<V>

fn default() -> Self

Returns the “default value” for a type.

impl<V> From<MutationKind<V>> for Mutations<V>

fn from(kind: MutationKind<V>) -> Self

Converts to this type from the input type.

impl<V> From<Mutations<V>> for Option<Mutation<V>>

fn from(value: Mutations<V>) -> Self

Converts to this type from the input type.

impl<V: PartialEq> PartialEq for Mutations<V>

fn eq(&self, other: &Mutations<V>) -> 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<V: Eq> Eq for Mutations<V>

impl<V> StructuralPartialEq for Mutations<V>