Struct streamcatcher::TxCatcher

pub struct TxCatcher<T, Tx> { /* fields omitted */ }

A shared stream buffer, using an applied input data transform.

Implementations

impl<T, Tx> TxCatcher<T, Tx> where
    T: AsyncRead + Unpin + 'static,
    Tx: AsyncTransform<T> + Unpin + 'static, 

pub fn load_all_async(self) -> LoadAll<T, Tx>

Read all bytes from the underlying stream into the backing store in the current task.

impl<T, Tx> TxCatcher<T, Tx>

pub fn tokio(self) -> Compat<Self>

impl<T, Tx> TxCatcher<T, Tx> where
    Tx: NeedsBytes + Default, 

pub fn new(source: T) -> Self

Create a new stream buffer using the default transform and configuration.`

pub fn with_config(source: T, config: Config) -> Result<Self>

Create a new stream buffer using the default transform and a custom configuration.`

impl<T, Tx> TxCatcher<T, Tx> where
    Tx: NeedsBytes, 

pub fn with_tx(source: T, transform: Tx, config: Option<Config>) -> Result<Self>

Create a new stream buffer using a custom transform and configuration.`

impl<T, Tx> TxCatcher<T, Tx>

pub fn new_handle(&self) -> Self

Acquire a new handle to this object, creating a new view of the existing cached data from the beginning.

pub fn is_finalised(&self) -> bool

Returns whether the underlying stream has been finalised, i.e., whether all rope segments have been combined into a single contiguous backing store.

According to Config, this may never become true if finalisation is disabled.

pub fn is_finished(&self) -> bool

Returns whether the underlying stream is finished, i.e., all bytes it will produce have been stored in some fashion.

pub fn pos(&self) -> usize

Returns this handle’s position.

pub fn len(&self) -> usize

Returns the number of bytes taken and stored from the transformed stream.

pub fn is_empty(&self) -> bool

Returns whether any bytes have been stored from the transformed source.

pub fn builder() -> Config

Returns a builder object to configure and construct a cache.

impl<T, Tx> TxCatcher<T, Tx> where
    T: Read + 'static,
    Tx: Transform<T> + NeedsBytes + 'static, 

pub fn spawn_loader(&self) -> JoinHandle<()>

Spawn a new thread to read all bytes from the underlying stream into the backing store.

pub fn load_all(&mut self)

Block the current thread to read all bytes from the underlying stream into the backing store.

Trait Implementations

impl<T, Tx> AsyncRead for TxCatcher<T, Tx> where
    T: AsyncRead + Unpin + 'static,
    Tx: AsyncTransform<T> + Unpin + 'static, 

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut [u8]
) -> Poll<IoResult<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<T, Tx> AsyncSeek for TxCatcher<T, Tx> where
    T: AsyncRead + Unpin + 'static,
    Tx: AsyncTransform<T> + Unpin + 'static, 

fn poll_seek(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    pos: SeekFrom
) -> Poll<IoResult<u64>>

Attempt to seek to an offset, in bytes, in a stream.

impl<T, Tx> Clone for TxCatcher<T, Tx>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, Tx: Debug> Debug for TxCatcher<T, Tx>

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

Formats the value using the given formatter.

impl<T, Tx> Read for TxCatcher<T, Tx> where
    T: Read + 'static,
    Tx: Transform<T> + NeedsBytes + 'static, 

fn read(&mut self, buf: &mut [u8]) -> IoResult<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: &mut ReadBuf<'_>) -> 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, buf: &mut ReadBuf<'_>) -> Result<(), Error>

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

Read the exact number of bytes required to fill buf.

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

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

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adapter which will chain this stream with another.

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

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

impl<T, Tx> Seek for TxCatcher<T, Tx> where
    T: Read + 'static,
    Tx: Transform<T> + NeedsBytes + 'static, 

fn seek(&mut self, pos: SeekFrom) -> IoResult<u64>

Seek to an offset, in bytes, in a stream.

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream.

fn stream_len(&mut self) -> Result<u64, Error>

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

Returns the length of this stream (in bytes).

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream.

impl<T, Tx> StateAccess for TxCatcher<T, Tx> where
    Tx: Stateful, 

type State = <Tx as Stateful>::State

Transform state.

unsafe fn get_state_unchecked(&self) -> Self::State

Directly access a transform’s state before a stream has finished.

fn get_final_state(&self) -> Option<Self::State>

Returns the transform’s state if the source (and transform) are finished.