Struct Base64QuantumCodec 

pub struct Base64QuantumCodec { /* private fields */ }

Encodes and decodes one complete Base64 quantum.

A quantum maps exactly three raw bytes to four Base64 units. It does not handle final short input groups or = padding; callers that process streams must finalize those cases in a transcoder or facade layer.

Examples

use qubit_codec::Codec;
use qubit_codec_misc::Base64QuantumCodec;

let mut codec = Base64QuantumCodec::standard();
let mut encoded = [0; 4];
// SAFETY: `encoded` has room for the four units written by one quantum.
let written = unsafe { codec.encode(b"Man", &mut encoded, 0) }
    .expect("three bytes can be encoded");
assert_eq!(written, 4);
assert_eq!(&encoded, b"TWFu");

Implementations

impl Base64QuantumCodec

pub fn standard() -> Self

Creates a standard-alphabet Base64 quantum codec.

Returns

Standard Base64 quantum codec.

pub fn url_safe() -> Self

Creates a URL-safe-alphabet Base64 quantum codec.

Returns

URL-safe Base64 quantum codec.

Trait Implementations

impl Clone for Base64QuantumCodec

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Codec for Base64QuantumCodec

type Value = [u8; 3]

Raw value represented by one complete Base64 quantum.

type Unit = u8

Encoded unit used by the Base64 alphabet.

type DecodeError = MiscCodecError

Error reported when an encoded unit is outside the selected alphabet.

type EncodeError = MiscCodecError

Error type exposed by the codec’s encoding operation.

unsafe fn decode( &mut self, input: &[u8], input_index: usize, ) -> Result<([u8; 3], NonZeroUsize), DecodeFailure<Self::DecodeError>>

Decodes one complete four-unit Base64 quantum.

Parameters

• input: Encoded Base64 units containing the quantum.
• input_index: Index of the first unit in the quantum.

Returns

The decoded three-byte value and the number of consumed input units.

Errors

Returns a decode failure with MiscCodecError::InvalidBase64 when any unit is not valid for the selected alphabet. Its input index is relative to input, and the failure reports that the complete four-unit quantum was consumed.

Safety

The caller must ensure that four units starting at input_index are readable in input.

unsafe fn encode( &mut self, value: &[u8; 3], output: &mut [u8], output_index: usize, ) -> Result<usize, Self::EncodeError>

Encodes one complete three-byte Base64 quantum.

Parameters

• value: Three raw bytes to encode.
• output: Destination buffer for four encoded units.
• output_index: Index of the first destination unit to write.

Returns

The number of output units written, which is always four.

Errors

This implementation does not return an error.

Safety

The caller must ensure that four units starting at output_index are writable in output.

const MIN_UNITS_PER_VALUE: usize = 4

The minimum possible non-zero readable unit count for one decoded value.

const MAX_ENCODE_UNITS_PER_VALUE: usize = 4

The maximum unit count emitted when encoding one value.

const MAX_DECODE_UNITS_PER_VALUE: usize = 4

The maximum non-zero unit count consumed to decode one value.

const MAX_ENCODE_RESET_UNITS: usize = 0

The maximum unit count emitted when resetting encode state.

const MAX_ENCODE_FINISH_UNITS: usize = 0

The maximum unit count emitted when finishing encode state at EOF.

const MAX_DECODE_RESET_VALUES: usize = 0

The maximum value count emitted when resetting decode state.

const MAX_DECODE_FINISH_VALUES: usize = 0

The maximum value count emitted when finishing decode state.

fn can_encode_value(&self, _value: &Self::Value) -> bool

Returns whether value is in this codec’s encodable value domain.

fn encode_len(&self, _value: &Self::Value) -> usize

Returns the exact unit count this codec will write when encoding value.

unsafe fn encode_reset( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>

Emits stream-start output and resets encode-side state.

unsafe fn encode_finish( &mut self, _output: &mut [Self::Unit], _output_index: usize, ) -> Result<usize, Self::EncodeError>

Emits EOF trailer output and finishes encode-side state.

unsafe fn decode_reset( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>

Emits stream-start values and resets decode-side state.

unsafe fn decode_eof( &mut self, input: &[Self::Unit], input_index: usize, ) -> Result<(Self::Value, NonZero<usize>), DecodeFailure<Self::DecodeError>>

Decodes one value after the caller has established end of input.

unsafe fn decode_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>

Finishes decode-side EOF state into output.

impl Copy for Base64QuantumCodec

impl Debug for Base64QuantumCodec

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

Formats the value using the given formatter.

impl Default for Base64QuantumCodec

fn default() -> Self

Creates a standard-alphabet Base64 quantum codec.

Returns

A codec configured to use the standard Base64 alphabet.

impl Eq for Base64QuantumCodec

impl PartialEq for Base64QuantumCodec

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Base64QuantumCodec