Enum Operation

pub enum Operation {
    Patch(Patch),
    PutFile(Vec<u8>),
    DeleteFile,
    FileStaysSame,
}

Operations that can be performed on a file in a patch set.

Used primarily for zip archive diffing to track changes to individual files within the archive.

Example

use darkwing_diff::{diff_zip, DiffAlgorithm, CompressAlgorithm};

let patch_set = diff_zip(
    "before.zip".to_string(),
    "after.zip".to_string(),
    DiffAlgorithm::Rsync020,
    CompressAlgorithm::Zstd
)?;

Variants

Patch(Patch)

File was modified - contains patch to transform it

PutFile(Vec<u8>)

File is new or completely different - contains full file contents

DeleteFile

File was removed in the target

FileStaysSame

File is identical in source and target

Implementations

impl Operation

pub fn get_size(&self) -> usize

Returns the size in bytes of this operation’s data.

Trait Implementations

impl Archive for Operation

where Patch: Archive, Vec<u8>: Archive,

type Archived = ArchivedOperation

The archived representation of this type.

type Resolver = OperationResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl Debug for Operation

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<Operation, __D> for Archived<Operation>

where Patch: Archive, <Patch as Archive>::Archived: Deserialize<Patch, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Operation, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl PartialEq for Operation

fn eq(&self, other: &Operation) -> 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<__S: Fallible + ?Sized> Serialize<__S> for Operation

where Patch: Serialize<__S>, Vec<u8>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for Operation