Struct ZiPatchReader 

pub struct ZiPatchReader<R> { /* private fields */ }

Iterator over the Chunks in a ZiPatch stream.

ZiPatchReader wraps any std::io::Read source and yields one Chunk per call to Iterator::next. It validates the 12-byte file magic on construction, then reads chunks sequentially until the EOF_ terminator is encountered or an error occurs.

Stream contract

• Magic — the first 12 bytes must be \x91ZIPATCH\r\n\x1a\n. Any mismatch returns ZiPatchError::InvalidMagic from ZiPatchReader::new.
• Framing — every chunk is a length-prefixed frame: [body_len: u32 BE] [tag: 4 B] [body: body_len B] [crc32: u32 BE].
• CRC32 — computed over tag ++ body. Verification is enabled by default; use ZiPatchReader::skip_checksum_verification to disable it.
• Termination — the EOF_ chunk is consumed internally and causes the iterator to return None. Call ZiPatchReader::is_complete after iteration to distinguish a clean end from a truncated stream.
• Fused — once None is returned (either from EOF_ or an error), subsequent calls to next also return None. The iterator implements std::iter::FusedIterator.

Errors

Each call to Iterator::next returns Some(Err(e)) on parse failure, then None on all future calls. Possible errors include:

• ZiPatchError::TruncatedPatch — stream ended before EOF_.
• ZiPatchError::OversizedChunk — a declared chunk body exceeds 512 MiB.
• ZiPatchError::ChecksumMismatch — CRC32 verification failed.
• ZiPatchError::UnknownChunkTag — unrecognised 4-byte tag.
• ZiPatchError::Io — underlying I/O failure.

Example

Build a minimal in-memory patch (magic + ADIR + EOF_) and iterate it:

use std::io::Cursor;
use zipatch_rs::{Chunk, ZiPatchReader};

// Helper: wrap tag + body into a correctly framed chunk with CRC32.
fn make_chunk(tag: &[u8; 4], body: &[u8]) -> Vec<u8> {
    let mut crc_input = Vec::new();
    crc_input.extend_from_slice(tag);
    crc_input.extend_from_slice(body);
    let crc = crc32fast::hash(&crc_input);

    let mut out = Vec::new();
    out.extend_from_slice(&(body.len() as u32).to_be_bytes());
    out.extend_from_slice(tag);
    out.extend_from_slice(body);
    out.extend_from_slice(&crc.to_be_bytes());
    out
}

// 12-byte ZiPatch magic.
let magic: [u8; 12] = [0x91, 0x5A, 0x49, 0x50, 0x41, 0x54, 0x43, 0x48, 0x0D, 0x0A, 0x1A, 0x0A];

// ADIR body: u32 BE name_len (7) + b"created".
let mut adir_body = Vec::new();
adir_body.extend_from_slice(&7u32.to_be_bytes());
adir_body.extend_from_slice(b"created");

let mut patch = Vec::new();
patch.extend_from_slice(&magic);
patch.extend_from_slice(&make_chunk(b"ADIR", &adir_body));
patch.extend_from_slice(&make_chunk(b"EOF_", &[]));

let chunks: Vec<_> = ZiPatchReader::new(Cursor::new(patch))
    .unwrap()
    .collect::<Result<_, _>>()
    .unwrap();

assert_eq!(chunks.len(), 1);
assert!(matches!(chunks[0], Chunk::AddDirectory(_)));

Implementations

impl<R: Read> ZiPatchReader<R>

pub fn new(reader: R) -> Result<Self>

Wrap reader and validate the leading 12-byte ZiPatch magic.

Consumes exactly 12 bytes from reader. The magic is the byte sequence 0x91 0x5A 0x49 0x50 0x41 0x54 0x43 0x48 0x0D 0x0A 0x1A 0x0A (i.e. \x91ZIPATCH\r\n\x1a\n).

The reader is wrapped in a std::io::BufReader internally, so the many small typed reads the chunk parser issues (4-byte size, 4-byte tag, 5-byte SQPK prefix, …) coalesce into a small number of syscalls. Callers do not need to pre-wrap a raw std::fs::File or other unbuffered source.

CRC32 verification is enabled by default. Call ZiPatchReader::skip_checksum_verification before iterating to disable it.

Errors

• ZiPatchError::InvalidMagic — the first 12 bytes do not match the expected magic.
• ZiPatchError::Io — an I/O error occurred while reading the magic.

pub fn with_patch_name(self, name: impl Into<String>) -> Self

Attach a human-readable identifier to this patch stream.

The identifier is stamped onto every SequentialCheckpoint the apply driver emits so a future resume_apply_to call can detect a checkpoint that was persisted for a different patch and refuse to resume from it.

Typical value is the patch filename (e.g. "H2017.07.11.0000.0000a.patch"). No interpretation is performed — the string is compared verbatim.

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

Returns the caller-supplied patch identifier, if any.

Set by Self::with_patch_name; None otherwise.

pub fn verify_checksums(self) -> Self

Enable per-chunk CRC32 verification (the default).

This is the default state after ZiPatchReader::new. Calling this method after construction is only necessary if ZiPatchReader::skip_checksum_verification was previously called.

pub fn skip_checksum_verification(self) -> Self

Disable per-chunk CRC32 verification.

Useful when the source has already been verified out-of-band (e.g. a download hash was checked before the file was opened), or when processing known-good test data where the overhead is unnecessary.

pub fn is_complete(&self) -> bool

Returns true if iteration reached the EOF_ terminator cleanly.

A false return after next() yields None indicates the stream was truncated — the download or file copy was incomplete. In that case the iterator stopped because of a ZiPatchError::TruncatedPatch error, not because the patch finished normally.

pub fn bytes_read(&self) -> u64

Returns the running total of bytes consumed from the patch stream.

Starts at 12 after ZiPatchReader::new (the magic header has been read) and increases monotonically by the size of each chunk’s wire frame after each successful Iterator::next call. Includes the EOF_ terminator’s frame.

On parse error, the counter is not advanced past the failing chunk — it reflects the byte offset at the start of that chunk’s length prefix, not the broken position somewhere inside its frame. Use this offset together with the surfaced error to point a user at where the patch became unreadable.

This is the same counter that the apply_to driver attaches to ChunkEvent::bytes_read when firing progress events. Useful for the bytes_applied / total_patch_size ratio in a progress bar.

pub fn last_tag(&self) -> Option<[u8; 4]>

Returns the 4-byte ASCII tag of the most recently yielded chunk.

None before the first successful Iterator::next call and after the EOF_ terminator has been consumed (or an error has been surfaced). Used by apply_to to populate ChunkEvent::kind.

pub fn current_chunk_body_offset(&self) -> Option<u64>

Returns the absolute patch-file offset of the body of the most recently yielded chunk.

The chunk body begins immediately after the 8-byte [body_len: u32 BE, tag: [u8; 4]] frame header, so the value points at the first byte of the body — for SQPK chunks that is the start of [inner_size: i32 BE, sub_cmd: u8, …]; for the other chunk types it is the start of the variant-specific body.

Index builders use this to compute absolute patch-file offsets for SqpkAddData::data, SqpkFile block payloads, and SqpkHeader::header_data without re-walking the stream.

None before the first chunk is successfully yielded. A parse failure leaves the previously-set value untouched (the offset returned by this method always points at a chunk that was successfully parsed).

impl ZiPatchReader<BufReader<File>>

pub fn from_path(path: impl AsRef<Path>) -> Result<Self>

Open the file at path, wrap it in a std::io::BufReader, and validate the ZiPatch magic.

This is a convenience constructor equivalent to:

let reader = ZiPatchReader::new(BufReader::new(File::open("patch.patch").unwrap())).unwrap();

Errors

• ZiPatchError::Io — the file could not be opened.
• ZiPatchError::InvalidMagic — the file does not start with the ZiPatch magic bytes.

impl<R: Read> ZiPatchReader<R>

pub fn apply_to(self, ctx: &mut ApplyContext) -> Result<()>

Iterate every chunk in the patch stream and apply each one to ctx.

This is the primary high-level entry point for applying a patch. It drives the ZiPatchReader iterator to completion, calling Apply::apply on each yielded Chunk in stream order.

Chunks must be applied in order — the ZiPatch format is a sequential log and later chunks may depend on filesystem state produced by earlier ones (e.g. a directory created by an ADIR chunk that a subsequent SQPK AddFile writes into).

Errors

Stops at the first parse or apply error and returns it immediately. Any filesystem changes already applied by earlier chunks are not rolled back — the format does not provide transactional semantics.

Possible error variants:

• ZiPatchError::Io — underlying I/O failure (read or write).
• ZiPatchError::InvalidMagic — caught at construction, not here.
• ZiPatchError::UnknownChunkTag — an unrecognised 4-byte tag was encountered.
• ZiPatchError::ChecksumMismatch — a chunk’s CRC32 did not match.
• ZiPatchError::TruncatedPatch — the stream ended before EOF_.
• ZiPatchError::NegativeFileOffset — a SqpkFile chunk carried a negative offset.
• ZiPatchError::Decompress — a compressed block could not be inflated.
• ZiPatchError::UnsupportedPlatform — a SqpkTargetInfo chunk declared a platform_id outside 0/1/2, and a subsequent SQPK data chunk requested SqPack .dat/.index path resolution.
• ZiPatchError::Cancelled — an installed ApplyObserver requested cancellation.

Panics

Never panics under normal operation. The internal ZiPatchReader::last_tag is unwrapped after a successful Iterator::next — this is an internal invariant of the iterator (every Some(Ok(_)) updates the tag) and would only fail on a bug in this crate.

Example

use std::fs::File;
use zipatch_rs::{ApplyContext, ZiPatchReader};

let mut ctx = ApplyContext::new("/opt/ffxiv/game");
ZiPatchReader::new(File::open("update.patch").unwrap())
    .unwrap()
    .apply_to(&mut ctx)
    .unwrap();

impl<R: Read + Seek> ZiPatchReader<R>

pub fn resume_apply_to( self, ctx: &mut ApplyContext, from: Option<&SequentialCheckpoint>, ) -> Result<SequentialCheckpoint>

Resume a previously interrupted apply from a SequentialCheckpoint.

When from is None, behaves identically to Self::apply_to except for the return type: a successful run returns the final SequentialCheckpoint (with next_chunk_index equal to the total number of chunks consumed, including the EOF_ terminator-driven loop exit).

When from is Some, the driver fast-forwards the parser past from.next_chunk_index chunks without applying them, then resumes the apply loop. If from.in_flight is also Some, the next chunk (which must be the in-flight SqpkFile::AddFile) is resumed mid-stream: the target file’s existing partial content is preserved and the chunk’s remaining blocks are streamed in starting at in_flight.block_idx.

Stale-checkpoint detection

If from.patch_name does not match the value supplied via Self::with_patch_name, or from.patch_size does not match the total byte length of the underlying reader, the driver emits a warn! and starts a clean apply from chunk 0 — the same precedent as the stale-manifest path in indexed apply. The returned checkpoint in that case carries the new run’s identity.

ignore_missing and chunk-N safety

The apply loop never re-applies a chunk whose effects already landed: chunk-boundary checkpoints are recorded after the chunk’s apply call has returned, so next_chunk_index = N means chunks [0, N) are confirmed done. There is therefore no need to flip ApplyContext::ignore_missing just for the resume boundary — a DeleteFile or DeleteDirectory at chunk N is still a first attempt and follows the caller’s pre-existing flag setting.

In-flight AddFile safety check

When resuming an in-flight AddFile, the driver stats the target file. If the file is missing, or its on-disk length is less than the checkpoint’s bytes_into_target (e.g. the partial file was truncated, deleted, or replaced since the crash), the in-flight state is discarded with a warn! and the chunk is re-applied from block 0. This is the only failure mode where a from.in_flight is silently ignored; a target-path or file-offset mismatch on the resumed chunk produces the same behaviour.

Completion checkpoints

A successful run returns a final checkpoint whose next_chunk_index is one past the last chunk in the patch — i.e. the index the apply loop would read next if there were more chunks. Replaying that final checkpoint through this method returns ZiPatchError::TruncatedPatch: the fast-forward will run out of chunks before reaching next_chunk_index. Consumers should detect “patch fully applied” from the Ok(_) return of the first call (or whatever marker their persistence layer records alongside the checkpoint) rather than by passing the completion checkpoint back here.

Errors

Same vocabulary as Self::apply_to, plus ZiPatchError::SchemaVersionMismatch when from.schema_version does not equal apply::SequentialCheckpoint::CURRENT_SCHEMA_VERSION. The driver refuses to interpret a checkpoint whose layout this build cannot represent.

Panics

Never panics under normal operation. Internal invariants are the same as Self::apply_to.

Trait Implementations

impl<R: Debug> Debug for ZiPatchReader<R>

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

Formats the value using the given formatter.

impl<R: Read> Iterator for ZiPatchReader<R>

type Item = Result<Chunk, ZiPatchError>

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self::Item>

Advances the iterator and returns the next value.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>

where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between items of the original iterator.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self>

where Self: Sized, Self::Item: IntoIterator,

Creates an iterator that flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn try_collect<B>( &mut self, ) -> <<Self::Item as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual<B>, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item>

where Self: Sized, Self::Item: Ord,

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: Copy + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: Clone + 'a, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering

where I: IntoIterator<Item = Self::Item>, Self::Item: Ord, Self: Sized,

Lexicographically compares the elements of this Iterator with those of another.

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool

where Self: Sized, Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.

impl<R: Read> FusedIterator for ZiPatchReader<R>