Struct TranscodeDecodeInput 

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

Decodes an Input unit stream into an Input value stream.

This type owns only the unit-level qubit_io::BufferedInput. Callers pass a streaming Transcoder and error mapper to each decode operation, which lets one buffered input drive different decoders without nesting buffers or storing decoder-specific state in the buffer owner.

Type Parameters

• I - Wrapped unit input.

Implementations

impl<I> TranscodeDecodeInput<I>

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

pub fn new(inner: I) -> Self

Creates a decoder input with the default unit buffer capacity.

Parameters

• inner - Unit input read by this adapter.

Returns

A new buffered decoder input.

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

Creates a decoder input with a unit buffer of at least capacity.

Parameters

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

Returns

A new buffered decoder input.

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

Returns a shared reference to the wrapped unit input.

Returns

A shared reference to the wrapped unit input.

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

Returns a mutable reference to the wrapped unit input.

Returns

A mutable reference to the wrapped unit input.

pub fn available(&self) -> usize

Returns the number of unread units currently buffered.

Returns

The number of unread units in the internal buffer.

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

Returns the currently buffered unread units.

Returns

Returns a shared slice over the unread portion of the internal unit buffer. The slice is valid until this adapter is mutated.

pub fn capacity(&self) -> usize

Returns the internal unit buffer capacity.

Returns

The maximum number of units retained in the internal buffer.

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

Refills the internal buffer until at least count unread units are available.

Parameters

• count - Minimum number of unread units required.

Errors

Returns I/O errors from the wrapped input while refilling.

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

Consumes unread units from the current buffer window.

Parameters

• count - Number of unread units to discard.

Panics

In debug builds, panics when count exceeds Self::available.

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

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

Parameters

• output - Destination storage that receives a copy of unread units.
• output_index - Start index inside output.
• count - Number of unread units to copy.

Safety

The caller must guarantee that output_index..output_index + count is a valid range inside output, that the addition does not overflow, that count <= self.available(), and that the destination range does not overlap with the unread units stored inside this buffer.

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

Consumes this adapter and returns its parts.

Returns

The wrapped input and the buffer holding unread units.

pub unsafe fn read_unchecked( &mut self, output: &mut [I::Item], output_index: usize, count: usize, ) -> Result<usize>

Reads buffered units into an indexed output range.

Parameters

• output - Destination unit storage.
• output_index - Start index inside output.
• count - Maximum number of units to read.

Returns

The number of units copied into output.

Errors

Returns input or buffer validation errors from the wrapped qubit_io::BufferedInput.

Safety

The caller must guarantee that output_index..output_index + count is a valid range inside output and that the addition does not overflow.

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

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

Decodes values into an indexed output range using a streaming Transcoder.

Parameters

• decoder - Streaming decoder used for this operation.
• map_error - Function mapping decoder errors into I/O errors.
• output - Destination value storage.
• output_index - Start index inside output.
• count - Maximum number of values to write.

Returns

The number of values written. Incomplete EOF tails are left buffered and reported as Ok(written), so callers can apply their own EOF policy.

Errors

Returns input errors, invalid output ranges, capacity errors from the internal buffer, or decoder errors mapped by map_error.

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

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

Finishes a streaming decoder into an indexed output range.

Parameters

• decoder - Streaming decoder whose final output is being collected.
• map_error - Function mapping decoder errors into I/O errors.
• output - Destination value storage.
• output_index - Start index inside output.
• count - Maximum number of finish values to write.

Returns

The number of values written by the decoder finish operation.

Errors

Returns invalid output ranges, capacity errors, or decoder finalization errors mapped to I/O errors.

impl<I> TranscodeDecodeInput<I>

where I: Input<Item = u8> + Seekable<Item = u8>,

pub fn seek(&mut self, position: SeekFrom) -> Result<u64>

Seeks the wrapped byte input and discards buffered bytes after success.

Parameters

• position - Target seek position.

Returns

The new stream position reported by the wrapped input.

Errors

Returns seek errors from the wrapped input.

Trait Implementations

impl<I> Debug for TranscodeDecodeInput<I>

where I: Input, I::Item: Copy + Default, BufferedInput<I>: Debug,

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

Formats this buffered decode input for debugging.

impl<I> Read for TranscodeDecodeInput<I>

where I: Input<Item = u8>,

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

Reads raw bytes through the internal buffer.

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>) -> Result<usize, Error>

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

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

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

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

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_, u8>) -> 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<'_, u8>, ) -> Result<(), Error>

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

Reads the exact number of bytes required to fill cursor.

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

where Self: Sized,

Creates a “by reference” adapter 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.

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>

where Self: Sized,

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

Read and return a fixed array of bytes from this source.

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

where T: FromEndianBytes, Self: Sized,

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

Read and return a type (e.g. an integer) in little-endian order.

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

where T: FromEndianBytes, Self: Sized,

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

Read and return a type (e.g. an integer) in big-endian order.

impl<I> Seek for TranscodeDecodeInput<I>

where I: Input<Item = u8> + Seekable<Item = u8>,

fn seek(&mut self, position: SeekFrom) -> Result<u64>

Seeks the wrapped byte input and discards buffered bytes after success.

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.

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position.