Struct HexByteCodec 

pub struct HexByteCodec { /* private fields */ }

Encodes and decodes one byte as two ASCII hexadecimal units.

HexByteCodec is the low-level Codec implementation for streaming or generic codec call sites. It does not understand whole-string prefixes, per-byte prefixes, separators, or whitespace. Use crate::HexCodec for owned byte-slice helpers with those formatting options.

For a complete safe streaming adapter example, see the English README and Chinese README.

Examples

use qubit_codec::Codec;
use qubit_codec_misc::HexByteCodec;

let mut codec = HexByteCodec::upper();
let mut output = [0_u8; 2];
let written = unsafe { Codec::encode(&mut codec, &0xaf, &mut output, 0) }?;

assert_eq!(2, written);
assert_eq!(b"AF", &output);

Implementations

impl HexByteCodec

pub const fn new() -> Self

Creates a lowercase single-byte hexadecimal codec.

pub const fn upper() -> Self

Creates an uppercase single-byte hexadecimal codec.

pub const fn is_uppercase(self) -> bool

Returns whether this byte codec emits uppercase hexadecimal digits.

pub const fn with_uppercase(self, uppercase: bool) -> Self

Sets whether encoded digits should be uppercase.

Parameters

• uppercase: Whether alphabetic hexadecimal digits are emitted in uppercase.

Returns

The updated codec, allowing further configuration before use.

Trait Implementations

impl Clone for HexByteCodec

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 HexByteCodec

type Value = u8

A single byte decoded from the hexadecimal representation.

type Unit = u8

An ASCII byte used as one encoded hexadecimal digit.

type DecodeError = MiscCodecError

The codec error reported when either input digit is invalid.

type EncodeError = MiscCodecError

The codec error type required by the trait; this implementation does not produce encoding errors for byte values.

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

Decodes one byte from two ASCII hexadecimal digits.

The digits are read from input starting at input_index. Invalid digits are reported with their position in the input.

Parameters

• input: The byte units containing the hexadecimal digits.
• input_index: The index of the first digit.

Returns

The decoded byte and the nonzero number of input units consumed (two).

Errors

Returns a decode failure when either input unit is not an ASCII hexadecimal digit. The failure identifies the invalid digit and its input position.

Safety

input must contain at least two readable units starting at input_index.

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

Encodes one byte as two ASCII hexadecimal digits.

Parameters

• value: The byte to encode.
• output: The buffer that receives the encoded digits.
• output_index: The index of the first output unit to write.

Returns

The number of output units written (two).

Errors

This implementation does not return an encoding error; the result is retained to satisfy the Codec interface.

Safety

output must contain at least two writable units starting at output_index.

const MIN_UNITS_PER_VALUE: usize = 2

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

const MAX_ENCODE_UNITS_PER_VALUE: usize = 2

The maximum unit count emitted when encoding one value.

const MAX_DECODE_UNITS_PER_VALUE: usize = 2

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 HexByteCodec

impl Debug for HexByteCodec

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

Formats the value using the given formatter.

impl Default for HexByteCodec

fn default() -> Self

Returns the “default value” for a type.

impl Eq for HexByteCodec

impl PartialEq for HexByteCodec

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for HexByteCodec