Struct Utf32ByteCodec 

pub struct Utf32ByteCodec { /* private fields */ }

Combined byte-serialized UTF-32 codec.

The codec uses one configured byte order for both decoding and encoding. It does not detect, consume, or emit a BOM automatically; callers should use crate::UnicodeBom when a byte stream may carry an explicit BOM.

Examples

use qubit_text_codec::{
    ByteOrder,
    CharsetCodec,
    DecodeStatus,
    Charset,
    Utf32,
    Utf32ByteCodec,
};

let codec = Utf32ByteCodec::new(ByteOrder::BigEndian);
assert_eq!(Charset::UTF_32BE, codec.charset());
assert_eq!(Utf32::MAX_BYTES_PER_CHAR, codec.max_units_per_char());

let mut output = [0_u8; Utf32::MAX_BYTES_PER_CHAR];
let written = codec.encode_one('中', &mut output, 0).expect("buffer fits");
assert_eq!(
    DecodeStatus::Complete {
        value: '中',
        consumed: written,
    },
    codec.decode_one(&output[..written], 0).expect("valid UTF-32BE"),
);

Implementations

impl Utf32ByteCodec

pub const fn new(byte_order: ByteOrder) -> Self

Creates a byte-serialized UTF-32 codec.

Parameters

• byte_order: The byte order used by the byte buffer.

Returns

Returns a UTF-32 byte codec.

pub const fn byte_order(self) -> ByteOrder

Returns the configured byte order.

Returns

Returns the byte order used by this codec.

pub const fn charset(self) -> Charset

Returns the fixed-endian UTF-32 charset descriptor.

Returns

Returns Charset::UTF_32LE or Charset::UTF_32BE according to this codec’s configured byte order.

pub const fn max_units_per_char(self) -> usize

Returns the maximum number of serialized UTF-32 bytes for one character.

Returns

Returns Utf32::MAX_BYTES_PER_CHAR.

Trait Implementations

impl CharsetCodec for Utf32ByteCodec

fn charset(&self) -> Charset

Returns the fixed-endian UTF-32 charset for the configured byte order.

Returns

Returns Charset::UTF_32BE when configured with ByteOrder::BigEndian, otherwise Charset::UTF_32LE.

fn max_units_per_char(&self) -> usize

Returns the fixed size (4 bytes) for one serialized UTF-32 scalar value.

Returns

Returns Utf32::MAX_BYTES_PER_CHAR.

fn decode_one( &self, input: &[u8], index: usize, ) -> CharsetDecodeResult<DecodeStatus>

Decodes one UTF-32 scalar value from a byte-prefixed UTF-32 stream.

Arguments

• input - Byte-prefixed UTF-32 buffer.
• index - Start offset for parsing; must satisfy index <= input.len().

Returns

• Ok(DecodeStatus::NeedMore { required, available }) when fewer than four bytes remain.
• Ok(DecodeStatus::Complete { value, consumed }) when one character is decoded.

Errors

• crate::CharsetDecodeErrorKind::MalformedSequence when byte index is invalid.
• crate::CharsetDecodeErrorKind::InvalidCodePoint when bytes decode to an invalid scalar.

fn encode_one( &self, ch: char, output: &mut [u8], index: usize, ) -> CharsetEncodeResult<usize>

Encodes one Unicode scalar value into UTF-32 bytes at index.

Arguments

• ch - The Unicode scalar value to encode.
• output - Destination byte buffer.
• index - Start offset where 4 bytes are written; must satisfy index <= output.len().

Returns

Always returns Ok(4) on success.

Errors

• crate::CharsetEncodeErrorKind::BufferTooSmall if fewer than 4 bytes remain in output.

type Unit = u8

Storage unit used by the encoded representation.

impl Clone for Utf32ByteCodec

fn clone(&self) -> Utf32ByteCodec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Utf32ByteCodec

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

Formats the value using the given formatter.

impl Hash for Utf32ByteCodec

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Hashes the fixed-endian UTF-32 charset identity.

Parameters

• state: The hasher receiving this codec’s identity.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Utf32ByteCodec

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Utf32ByteCodec

impl Eq for Utf32ByteCodec

impl StructuralPartialEq for Utf32ByteCodec