Enum gix_filter::pipeline::convert::ToWorktreeOutcome

pub enum ToWorktreeOutcome<'input, 'pipeline> {
    Unchanged(&'input [u8]),
    Buffer(&'pipeline [u8]),
    Process(MaybeDelayed<'pipeline>),
}

The result of a conversion with zero or more filters.

Panics

If std::io::Read is used on it and the output is delayed, a panic will occour. The caller is responsible for either disallowing delayed results or if allowed, handle them. Use `is_delayed().

Variants

Unchanged(&'input [u8])

The original input wasn’t changed and the original buffer is present

Buffer(&'pipeline [u8])

A reference to the result of one or more filters of which one didn’t support streaming.

This can happen if an eol, working-tree-encoding or ident filter is applied, possibly on top of an external filter.

Process(MaybeDelayed<'pipeline>)

An external filter (and only that) was applied and its results have to be consumed. Note that the output might be delayed, which requires special handling to eventually receive it.

Implementations

impl<'input, 'pipeline> ToWorktreeOutcome<'input, 'pipeline>

pub fn is_delayed(&self) -> bool

Return true if this outcome is delayed. In that case, one isn’t allowed to use Read or cause a panic.

pub fn is_changed(&self) -> bool

Returns true if the input buffer was actually changed, or false if it is returned directly.

pub fn as_bytes(&self) -> Option<&[u8]>

Return a buffer if we contain one, or None otherwise.

This method is useful only if it’s clear that no driver is available, which may cause a stream to be returned and not a buffer.

pub fn as_read(&mut self) -> Option<&mut (dyn Read + '_)>

Return a stream to read the drivers output from, if possible.

Note that this is only the case if the driver process was applied last and didn’t delay its output.

Trait Implementations

impl<'input, 'pipeline> Read for ToWorktreeOutcome<'input, 'pipeline>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

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

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

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

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where Self: Sized,

Creates an adapter which will read at most limit bytes from it.