Struct AsyncTranscodeDecodeInput 

pub struct AsyncTranscodeDecodeInput<I>
where
    I: AsyncInput,
    I::Item: Copy + Default,
{ /* private fields */ }

Decodes an asynchronous unit stream into values.

The adapter owns unit buffering but not decoder state. Callers supply a streaming decoder and error mapper for each operation.

Type Parameters

• I: Wrapped asynchronous unit input.

Implementations

impl<I> AsyncTranscodeDecodeInput<I>

where I: AsyncInput, I::Item: Copy + Default,

pub fn new(inner: I) -> Self

Creates an adapter with the default unit-buffer capacity.

Parameters

• inner: Unit input read by this adapter.

Returns

Returns a new buffered asynchronous decoder input.

pub fn with_capacity(inner: I, capacity: usize) -> Self

Creates an adapter with an internal unit buffer of at least capacity.

Parameters

• inner: Unit input read by this adapter.
• capacity: Requested internal unit-buffer capacity.

Returns

Returns a new buffered asynchronous decoder input.

pub fn try_with_capacity( inner: I, capacity: usize, ) -> Result<Self, TryReserveError>

Tries to create an adapter with an internal unit buffer of at least capacity.

Errors

Returns the allocation error when the internal buffer cannot be allocated.

pub const fn inner(&self) -> &I

Returns a shared reference to the wrapped asynchronous input.

The input can be physically positioned after units retained in this adapter’s unread buffer.

pub fn inner_mut(&mut self) -> &mut I

Returns a mutable reference to the wrapped asynchronous input.

Direct reads can invalidate the logical stream position represented by unread buffered units.

pub const fn unread_len(&self) -> usize

Returns the number of unread units currently buffered.

pub fn unread(&self) -> &[I::Item]

Returns the unread buffered unit window.

pub fn capacity(&self) -> usize

Returns the total internal unit-buffer capacity.

pub fn consume(&mut self, count: usize)

Consumes unread units from the current buffer window.

Panics

Panics when count exceeds the unread unit count.

pub unsafe fn copy_unread_to( &self, output: &mut [I::Item], output_index: usize, count: usize, )

Copies unread units into an indexed output range without consuming them.

Safety

The caller must guarantee that the indexed range fits in output, does not overflow, holds no overlapping unread units, and count is no greater than the unread unit count.

pub fn into_parts(self) -> (I, Buffer<I::Item>)

Consumes this adapter and returns the input plus its unread buffer.

pub fn reset<D, M, Value>( &self, decoder: &mut D, map_error: &mut M, output: &mut [Value], output_index: usize, count: usize, ) -> Result<usize>

where D: Transcoder<Input = I::Item, Output = Value>, M: FnMut(D::Error) -> Error,

Runs decoder reset into an indexed output range without I/O.

Errors

Returns invalid output-range, capacity, or mapped decoder-reset errors.

Panics

Panics if the decoder writes more values than its reset bound.

pub fn finish<D, M, Value>( &self, decoder: &mut D, map_error: &mut M, output: &mut [Value], output_index: usize, count: usize, ) -> Result<usize>

where D: Transcoder<Input = I::Item, Output = Value>, M: FnMut(D::Error) -> Error,

Finishes a decoder into an indexed output range without I/O.

Errors

Returns invalid output-range, capacity, or mapped decoder-finish errors.

Panics

Panics if the decoder writes more values than its finish bound.

impl<I> AsyncTranscodeDecodeInput<I>

where I: AsyncInput + Unpin, I::Item: Copy + Default + Unpin,

pub async fn fill_more_async(&mut self) -> Result<bool>

Appends at least one unit to the unread buffer.

Returns

Returns true when data was appended, or false at end of input.

Errors

Returns input or buffer-management errors while refilling.

pub async fn fill_until_async(&mut self, count: usize) -> Result<bool>

Refills until at least count unread units are available.

Returns

Returns true when count units are available, or false when EOF occurs first.

Errors

Returns allocation, input, or buffer-management errors while refilling.

pub fn poll_transcode<D, M, Value>( self: Pin<&mut Self>, cx: &mut Context<'_>, decoder: &mut D, map_error: &mut M, output: &mut [Value], output_index: usize, count: usize, ) -> Poll<Result<AsyncTranscodeDecodeStep>>

where D: Transcoder<Input = I::Item, Output = Value>, M: FnMut(D::Error) -> Error,

Polls one cancellation-safe decoder operation.

The operation first refills only when no unread unit is buffered. After a decoder call changes either the decoder or the buffered input, it immediately returns AsyncTranscodeDecodeStep::Progress and never polls the input again. This makes the returned progress the commit boundary for cancellation: resume with the adapter’s current state, rather than replaying the previous source range.

Errors

Returns input, allocation, output-range, invalid-progress, or mapped decoder errors.

pub async fn transcode_async<D, M, Value>( &mut self, decoder: &mut D, map_error: &mut M, output: &mut [Value], output_index: usize, count: usize, ) -> Result<AsyncTranscodeDecodeStep>

where D: Transcoder<Input = I::Item, Output = Value>, M: FnMut(D::Error) -> Error,

Decodes one cancellation-safe progress step into an indexed output range.

This is the async wrapper for Self::poll_transcode. It returns after one decoder invocation; callers that require a complete destination range must drive successive steps and retain each returned progress.

Trait Implementations

impl<I> AsyncInput for AsyncTranscodeDecodeInput<I>

where I: AsyncInput, I::Item: Copy + Default,

type Item = <I as AsyncInput>::Item

Item type read through the retained unit buffer.

fn is_buffered(&self) -> bool

Reports that this input retains unread units.

unsafe fn poll_read_unchecked( self: Pin<&mut Self>, cx: &mut Context<'_>, output: &mut [Self::Item], index: usize, count: usize, ) -> Poll<Result<usize>>

Polls one read through the retained unit buffer.

Safety

The caller must provide a valid indexed output range.

fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, output: &mut [Self::Item], ) -> Poll<Result<usize, Error>>

Polls a read into the full destination slice.

fn read_async<'a>( &'a mut self, output: &'a mut [Self::Item], ) -> ReadFuture<'a, Self>

where Self: Sized + Unpin,

Creates a future that performs one asynchronous read operation.

fn read_fully_async<'a>( &'a mut self, output: &'a mut [Self::Item], ) -> ReadFullyFuture<'a, Self>

where Self: Sized + Unpin,

Creates a future that fills a destination as far as possible.

fn read_exactly_async<'a>( &'a mut self, output: &'a mut [Self::Item], ) -> ReadExactFuture<'a, Self>

where Self: Sized + Unpin,

Creates a future that fills the entire destination.

impl<I> Debug for AsyncTranscodeDecodeInput<I>

where I: AsyncInput, I::Item: Copy + Default, AsyncBufferedInput<I>: Debug,

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

Formats this asynchronous decoder input for debugging.