Struct Base64Encoder 

pub struct Base64Encoder { /* private fields */ }

Encodes bytes incrementally using a strict Base64 configuration.

The encoder uses fixed-size state and does not allocate. Call reset before streaming. Input and output buffers remain caller-owned. It may retain up to two consumed input bytes until a complete quantum is available or finish encodes the final partial quantum. Retained bytes are already included in the reported input consumption and must not be submitted again. If output capacity is insufficient, use the returned progress to retry with the unconsumed input and a larger output buffer. NeedOutput.required is the minimum total capacity from the advanced output position (output_index + progress.written()) for the next step. When retaining the output buffer, its length must cover that position plus required; when switching to an empty buffer at index zero, provide at least required slots.

Examples

use qubit_codec::Transcoder;
use qubit_codec_misc::Base64Encoder;

let mut encoder = Base64Encoder::standard();
let mut output = [0; 4];
encoder.reset(&mut output, 0).unwrap();
let progress = encoder.transcode(b"M", 0, &mut output, 0).unwrap();
assert_eq!(progress.read(), 1);
assert_eq!(progress.written(), 0);
let written = encoder.finish(&mut output, 0).unwrap();
assert_eq!(&output[..written], b"TQ==");

Retrying after output pressure must advance both indices. The encoder has already consumed the first five bytes of ManMan, so only the final n is submitted again:

use qubit_codec::TranscodeStatus;
use qubit_codec::Transcoder;
use qubit_codec_misc::Base64Encoder;

let mut encoder = Base64Encoder::standard();
encoder.reset(&mut [], 0).unwrap();
let mut output = [0; 4];
let first = encoder.transcode(b"ManMan", 0, &mut output, 0).unwrap();
assert_eq!((first.read(), first.written()), (5, 4));
assert_eq!(&output, b"TWFu");
let required = match first.status() {
    TranscodeStatus::NeedOutput { required } => required.get(),
    status => panic!("expected NeedOutput, got {status:?}"),
};
let mut larger = [0; 8];
larger[..4].copy_from_slice(&output);
let next = encoder.transcode(b"ManMan", first.read(), &mut larger, first.written()).unwrap();
assert_eq!(next.read(), 1);
assert_eq!(next.written(), 4);
assert!(required <= larger.len() - first.written());
assert_eq!(encoder.finish(&mut larger, first.written() + next.written()).unwrap(), 0);
assert_eq!(&larger, b"TWFuTWFu");

Implementations

impl Base64Encoder

pub fn standard() -> Self

Creates a strict standard Base64 encoder with padding.

The encoder requires reset before streaming and does not allocate.

pub fn standard_no_pad() -> Self

Creates a strict standard Base64 encoder without padding.

The encoder requires reset before streaming and does not allocate.

pub fn url_safe() -> Self

Creates a strict URL-safe Base64 encoder with padding.

The encoder requires reset before streaming and does not allocate.

pub fn url_safe_no_pad() -> Self

Creates a strict URL-safe Base64 encoder without padding.

The encoder requires reset before streaming and does not allocate.

Trait Implementations

impl Debug for Base64Encoder

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

Formats the value using the given formatter.

impl Default for Base64Encoder

fn default() -> Self

Creates the default strict standard Base64 encoder with padding.

The encoder must be reset before streaming.

impl TranscodeEncoder for Base64Encoder

type EncodeError = !

The encoder cannot fail while converting an input byte.

impl Transcoder for Base64Encoder

type Input = u8

Base64 encoding consumes bytes.

type Output = u8

Base64 encoding produces bytes.

type Error = TranscodeEncodeError<!, u8>

Reports streaming state or output-capacity failures; encoding itself is infallible.

fn max_transcode_output_len( &self, input_len: usize, ) -> Result<usize, CapacityError>

Returns an upper bound for encoding input_len input bytes.

Parameters

• input_len: Number of input bytes to encode.

Returns

The maximum encoded length, or a capacity error if that length overflows.

fn max_finish_output_len(&self) -> Result<usize, CapacityError>

Returns the maximum output needed to encode the retained final bytes.

Returns

Four bytes for padded output, or three bytes for unpadded output.

Errors

This method always returns Ok; its constant bound cannot overflow.

fn reset( &mut self, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::Error>

Starts a new stream and validates the output position.

Any bytes retained from an earlier stream are discarded.

Parameters

• output: Caller-owned output storage; it is not modified.
• output_index: Position at which subsequent output will be written.

Returns

Zero bytes written.

Errors

Returns an error if output_index is outside output.

fn transcode( &mut self, input: &[u8], input_index: usize, output: &mut [u8], output_index: usize, ) -> Result<TranscodeProgress, Self::Error>

Encodes complete Base64 quanta and retains up to two trailing bytes.

Retained bytes count as consumed; resuming must use the returned input position so those bytes are not submitted twice. On output pressure, continue with the reported indices and sufficient output capacity.

Parameters

• input: Caller-owned input bytes.
• input_index: Position of the first input byte to consume.
• output: Caller-owned destination storage.
• output_index: Position of the first output byte to write.

Returns

Progress containing the input consumed, output written, and whether more output capacity is required.

Errors

Returns an error for invalid indices or when the stream has not been reset or has already been finished.

fn finish( &mut self, output: &mut [u8], output_index: usize, ) -> Result<usize, Self::Error>

Encodes any retained final bytes and marks the stream as finished.

Parameters

• output: Caller-owned destination storage.
• output_index: Position at which final encoded bytes are written.

Returns

The number of bytes written for the final partial quantum.

Errors

Returns an error for an invalid output index, insufficient capacity, or a stream that was not reset or was already finished.

fn max_reset_output_len(&self) -> Result<usize, CapacityError>

Returns an upper bound for output units emitted when resetting stream state.

fn max_total_output_len(&self, input_len: usize) -> Result<usize, CapacityError>

Returns an upper bound for a complete reset -> transcode_eof -> finish stream.

fn transcode_eof( &mut self, input: &[Self::Input], input_index: usize, output: &mut [Self::Output], output_index: usize, ) -> Result<TranscodeProgress, Self::Error>

Converts source units after the caller has established end of input.

fn transcode_complete_into( &mut self, input: &[Self::Input], output: &mut [Self::Output], ) -> Result<usize, Self::Error>

Runs a complete one-shot reset -> transcode -> finish stream.