Enum GenericPatchOperation 

pub enum GenericPatchOperation<V>
where
    V: DiffableValue,
{
    Add {
        path: String,
        value: V,
    },
    Remove {
        path: String,
    },
    Replace {
        path: String,
        value: V,
    },
    Move {
        from: String,
        path: String,
    },
    Copy {
        from: String,
        path: String,
    },
    Test {
        path: String,
        value: V,
    },
}

A single patch operation (format-agnostic)

Modeled after RFC 6902 (JSON Patch) but generic over value types.

Variants

Add

Add a value at a path

Fields

path: String

The target path

value: V

The value to add

Remove

Remove the value at a path

Fields

path: String

The path to remove

Replace

Replace the value at a path

Fields

path: String

The target path

value: V

The new value

Move

Move a value from one path to another

Fields

from: String

The source path

path: String

The destination path

Copy

Copy a value from one path to another

Fields

from: String

The source path

path: String

The destination path

Test

Test that a value at a path equals the expected value

Fields

path: String

The path to test

value: V

The expected value

Implementations

impl<V> GenericPatchOperation<V>

where V: DiffableValue,

pub fn path(&self) -> &str

Get the target path of this operation

pub fn from_path(&self) -> Option<&str>

Get the source path for move/copy operations

pub const fn is_add(&self) -> bool

Check if this is an add operation

pub const fn is_remove(&self) -> bool

Check if this is a remove operation

pub const fn is_replace(&self) -> bool

Check if this is a replace operation

Trait Implementations

impl<V> Clone for GenericPatchOperation<V>

where V: Clone + DiffableValue,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for GenericPatchOperation<V>

where V: Debug + DiffableValue,

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

Formats the value using the given formatter.

impl<V> Display for GenericPatchOperation<V>

where V: DiffableValue + Debug,

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

Formats the value using the given formatter.

impl<V> FromIterator<GenericPatchOperation<V>> for GenericPatch<V>

where V: DiffableValue,

fn from_iter<I>(iter: I) -> GenericPatch<V>

where I: IntoIterator<Item = GenericPatchOperation<V>>,

Creates a value from an iterator.

impl<V> PartialEq for GenericPatchOperation<V>

where V: PartialEq + DiffableValue,

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

where V: Eq + DiffableValue,

impl<V> StructuralPartialEq for GenericPatchOperation<V>

where V: DiffableValue,