Struct CStringLiteralCodec 

pub struct CStringLiteralCodec;

Encodes and decodes byte-oriented C string literal fragments.

This codec is intended for textual formats that embed byte sequences with C escapes, such as PK\003\004 or \xd0\xcf. It decodes into raw bytes and does not require surrounding quotes.

Hexadecimal \x and \X escapes consume one or two digits. Octal escapes consume one to three digits and retain only the low eight bits. Universal \u and \U escapes require exactly four or eight hex digits, respectively, and their values must fit in one byte. They produce that byte directly rather than converting a Unicode code point to UTF-8. The decoder does not remove surrounding quotes. Raw source text is limited to printable ASCII, tab, line feed, vertical tab, and form feed; other bytes, including non-ASCII text and raw carriage returns, must be escaped. An escaped space (\ ) is also accepted.

The owned decode helper treats its input as complete text. For streaming input, use Codec::decode_eof after confirming EOF to resolve format-specific short escapes. Open-stream decoding requests more input only when the visible escape prefix can still form a valid byte value. For malformed input, a streaming skip/replace hook may consume the invalid span visible in the current input chunk; recovery can therefore depend on chunk boundaries. Valid input and strict decoding are unaffected. See the English README and Chinese README for a safe streaming adapter example and the linked EOF short-escape test.

Its low-level Codec<Value = u8, Unit = u8> implementation handles one raw byte or one C escape fragment. Whole-fragment iteration remains part of the owned encode and decode helpers.

Examples

use qubit_codec_misc::CStringLiteralCodec;

let codec = CStringLiteralCodec::new();
assert_eq!(codec.encode(b"Hi"), "Hi");
assert_eq!(codec.decode(r"\x48\x69").unwrap(), b"Hi");

Implementations

impl CStringLiteralCodec

pub fn new() -> Self

Creates a C string literal codec.

Returns

A stateless C string literal codec.

pub fn encode(&self, bytes: &[u8]) -> String

Encodes bytes into a C string literal fragment.

Parameters

• bytes: Raw bytes to encode.

Returns

A C string literal fragment without surrounding quotes.

pub fn decode(&self, text: &str) -> MiscCodecResult<Vec<u8>>

Decodes a C string literal fragment into bytes.

Parameters

• text: C string literal fragment without surrounding quotes.

Returns

Decoded raw bytes.

Errors

Returns MiscCodecError::InvalidEscape for malformed escape sequences, MiscCodecError::InvalidDigit for malformed fixed-width numeric escapes, and MiscCodecError::InvalidCharacter for unsupported raw source characters.

Trait Implementations

impl Clone for CStringLiteralCodec

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 CStringLiteralCodec

type Value = u8

Raw byte represented by one encoded unit or escape fragment.

type Unit = u8

Encoded input and output units are bytes.

type DecodeError = MiscCodecError

Error type reported while decoding one fragment.

type EncodeError = MiscCodecError

Error type reported while encoding one byte; encoding is infallible.

fn encode_len(&self, value: &u8) -> usize

Returns the exact C string literal width for one byte.

Parameters

• value: Byte whose encoded width is measured.

Returns

Number of output units required to encode value.

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

Decodes one raw byte or one C escape fragment.

Safety

The caller must provide an input index with at least one readable unit and a slice satisfying the codec trait’s decode preconditions.

Parameters

• input: Encoded byte units to read.
• input_index: Index of the next encoded fragment.

Returns

The decoded byte and number of consumed units.

Errors

Returns a decoding failure for malformed input or an incomplete streaming escape.

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

Decodes one value after end of input has been confirmed.

Safety

The caller must provide an input index with at least one readable unit and a slice satisfying the codec trait’s EOF decode preconditions.

Parameters

• input: Encoded byte units to read after EOF is confirmed.
• input_index: Index of the next encoded fragment.

Returns

The decoded byte and number of consumed units.

Errors

Returns a decoding failure when the EOF-confirmed fragment is malformed.

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

Encodes one byte as a raw byte or C escape fragment.

Safety

The caller must provide enough writable output units for Self::encode_len.

Parameters

• value: Byte to encode.
• output: Destination unit buffer.
• output_index: Start index in output.

Returns

Number of output units written.

Errors

This implementation does not return an error for a valid output buffer.

const MIN_UNITS_PER_VALUE: usize = 1

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 = 10

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.

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_finish( &mut self, _output: &mut [Self::Value], _output_index: usize, ) -> Result<usize, Self::DecodeError>

Finishes decode-side EOF state into output.

impl Copy for CStringLiteralCodec

impl Debug for CStringLiteralCodec

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

Formats the value using the given formatter.

impl Default for CStringLiteralCodec

fn default() -> Self

Returns the “default value” for a type.

impl Eq for CStringLiteralCodec

impl PartialEq for CStringLiteralCodec

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CStringLiteralCodec

impl ValueDecoder<str> for CStringLiteralCodec

type Error = MiscCodecError

Error type reported for malformed C string literal fragments.

type Output = Vec<u8>

Owned raw bytes decoded from the input fragment.

fn decode(&mut self, input: &str) -> Result<Self::Output, Self::Error>

Decodes a C string literal fragment into bytes.

Parameters

• input: Encoded fragment without surrounding quotes.

Returns

The decoded raw bytes on success.

Errors

Returns the codec error describing the malformed fragment.

impl ValueEncoder<[u8]> for CStringLiteralCodec

type Error = MiscCodecError

Error type used when encoding fails; the current encoder is infallible.

type Output = String

Owned textual fragment produced by encoding the input bytes.

fn encode(&mut self, input: &[u8]) -> Result<Self::Output, Self::Error>

Encodes bytes into a C string literal fragment.

Parameters

• input: Raw bytes to encode.

Returns

The encoded fragment without surrounding quotes.