Struct Mutation 

pub struct Mutation<A: Adapter> {
    pub path_rev: Vec<Cow<'static, str>>,
    pub operation: MutationKind<A>,
}

A mutation representing a change to a value at a specific path.

Mutation captures both the location where a change occurred (via path_rev) and the kind of change that was made (via operation). Mutations can be applied to values to reproduce the changes they represent.

Path Representation

The path is stored in reverse order for efficiency during collection. For example, a change at foo.bar.baz would have path_rev = ["baz", "bar", "foo"].

Example

use morphix::{JsonAdapter, Mutation, MutationKind};
use serde_json::json;

// A mutation that replaces the value at path "user.name"
let mutation = Mutation::<JsonAdapter> {
    path_rev: vec!["name".into(), "user".into()],
    operation: MutationKind::Replace(json!("Alice")),
};

// Apply the mutation to a JSON value
let mut data = json!({"user": {"name": "Bob", "age": 30}});
mutation.apply(&mut data).unwrap();
assert_eq!(data, json!({"user": {"name": "Alice", "age": 30}}));

Fields

path_rev: Vec<Cow<'static, str>>

The path to the mutated value, stored in reverse order.

An empty vec indicates a mutation at the root level.

operation: MutationKind<A>

The kind of mutation that occurred.

Implementations

impl<A: Adapter> Mutation<A>

pub fn apply(self, value: &mut A::Value) -> Result<(), MutationError>

Applies this mutation to a value.

Arguments

• value - value to mutate

Errors

• Returns IndexError if the path doesn’t exist in the value.
• Returns OperationError if the mutation cannot be performed.

Example

use morphix::{Mutation, MutationKind, JsonAdapter};
use serde_json::json;

let mut value = json!({"count": 0});

Mutation::<JsonAdapter> {
    path_rev: vec!["count".into()],
    operation: MutationKind::Replace(json!(42)),
}
.apply(&mut value)
.unwrap();

assert_eq!(value, json!({"count": 42}));

Trait Implementations

impl<A: Adapter> Clone for Mutation<A>

where A::Value: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Adapter> Debug for Mutation<A>

where A::Value: Debug,

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

Formats the value using the given formatter.

impl<A: Adapter> PartialEq for Mutation<A>

where A::Value: PartialEq,

fn eq(&self, other: &Self) -> 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<A: Adapter> Eq for Mutation<A>

where A::Value: Eq,