Struct Patch

pub struct Patch {
    pub diff_algorithm: DiffAlgorithm,
    pub compress_algorithm: CompressAlgorithm,
    pub before_hash: String,
    pub after_hash: String,
    pub patch: Vec<u8>,
}

A patch that can transform one file into another.

Contains all the information needed to verify and apply a patch, including source and target file hashes for integrity validation.

Example

use files_diff::{diff, apply, DiffAlgorithm, CompressAlgorithm};

let source = b"original content";
let target = b"modified content";

// Generate a patch
let patch = diff(
    source,
    target,
    DiffAlgorithm::Rsync020,
    CompressAlgorithm::Zstd
)?;

// Verify source hash matches
assert_eq!(files_diff::hash(source), patch.before_hash);

// Apply patch and verify result
let result = apply(source, &patch)?;
assert_eq!(files_diff::hash(&result), patch.after_hash);

Fields

diff_algorithm: DiffAlgorithm

Algorithm used to generate this patch

compress_algorithm: CompressAlgorithm

Compression method used for the patch data

before_hash: String

MD5 hash of the source file

after_hash: String

MD5 hash of the target file

patch: Vec<u8>

The actual patch data

Implementations

impl Patch

pub fn get_size(&self) -> usize

Returns the total size in bytes of this patch.

pub fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serializes this patch to a byte vector.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error>

Deserializes a patch from a byte vector.

Trait Implementations

impl Archive for Patch

where DiffAlgorithm: Archive, CompressAlgorithm: Archive, String: Archive, Vec<u8>: Archive,

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.

type Archived = ArchivedPatch

The archived representation of this type.

type Resolver = PatchResolver

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.

impl Debug for Patch

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

Formats the value using the given formatter.

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

where DiffAlgorithm: Archive, <DiffAlgorithm as Archive>::Archived: Deserialize<DiffAlgorithm, __D>, CompressAlgorithm: Archive, <CompressAlgorithm as Archive>::Archived: Deserialize<CompressAlgorithm, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, Vec<u8>: Archive, <Vec<u8> as Archive>::Archived: Deserialize<Vec<u8>, __D>,

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

Deserializes using the given deserializer

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<__S: Fallible + ?Sized> Serialize<__S> for Patch

where DiffAlgorithm: Serialize<__S>, CompressAlgorithm: Serialize<__S>, String: 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 Patch