Struct CharsetEncoder 

pub struct CharsetEncoder<C>
where
    C: CharsetCodec,
{ /* private fields */ }

Converts Unicode scalar values into units of one charset.

CharsetEncoder wraps a low-level CharsetCodec and applies the configured UnmappableAction whenever the codec reports that an input character cannot be represented by the target charset.

Type Parameters

• C: Low-level charset codec used to encode one character into target storage units.

Implementations

impl<C> CharsetEncoder<C>

where C: CharsetCodec,

pub const DEFAULT_REPLACEMENT: char = '\u{fffd}'

Default replacement character used when unmappable input is replaced.

pub const DEFAULT_FALLBACK_REPLACEMENT: char = '?'

Fallback replacement used when the default replacement is unmappable.

pub fn new(codec: C) -> Self

Creates an encoder with default replacement policy.

Parameters

• codec: Low-level charset codec used to encode output units.

Returns

Returns an encoder whose unmappable action is UnmappableAction::Replace and whose replacement character is CharsetEncoder::DEFAULT_REPLACEMENT. If the default cannot be encoded by the codec, CharsetEncoder::DEFAULT_FALLBACK_REPLACEMENT is used.

pub fn with_replacement( self, replacement: char, ) -> Result<Self, CharsetEncodeError>

Creates an encoder with the provided replacement character.

The replacement character is checked once on construction. If the codec cannot encode it, this returns an error immediately.

Parameters

• replacement: Replacement character for unmappable input.

Returns

• Ok(Self) when the character is encodable by the codec.
• Err(Self::Error) when the replacement is unsupported.

pub const fn codec(&self) -> &C

Returns the wrapped low-level codec.

Returns

Returns a shared reference to the configured codec.

pub fn codec_mut(&mut self) -> &mut C

Returns a mutable reference to the wrapped codec.

Returns

Returns a mutable reference to the configured codec.

pub const fn unmappable_action(&self) -> UnmappableAction

Returns the configured unmappable-character action.

Returns

Returns the action used when target encoding cannot represent a character.

pub fn set_unmappable_action(&mut self, action: UnmappableAction)

Sets the unmappable-character action.

Parameters

• action: New policy for unmappable input characters.

pub const fn replacement(&self) -> char

Returns the configured replacement character.

Returns

Returns the character encoded when UnmappableAction::Replace is used.

pub fn set_replacement( &mut self, replacement: char, ) -> Result<(), CharsetEncodeError>

Sets the replacement character.

Parameters

• replacement: New replacement character used by replace policy.

Errors

Returns Err when the codec cannot encode the given replacement.

Trait Implementations

impl<C> Clone for CharsetEncoder<C>

where C: CharsetCodec + Clone, C::Unit: Clone,

fn clone(&self) -> CharsetEncoder<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Coder<char, <C as CharsetCodec>::Unit> for CharsetEncoder<C>

where C: CharsetCodec,

fn max_output_len(&self, input_len: usize) -> Option<usize>

Returns the maximum number of target units needed for input_len characters.

fn convert( &mut self, input: &[char], input_index: usize, output: &mut [C::Unit], output_index: usize, ) -> Result<CoderProgress, Self::Error>

Encodes characters into the target charset while applying unmappable policy.

type Error = CharsetEncodeError

Error reported for semantic conversion failures.

fn reset(&mut self)

Resets state retained between conversion calls.

fn finish( &mut self, _output: &mut [Output], _output_index: usize, ) -> Result<CoderProgress, Self::Error>

Flushes any buffered output after input conversion is complete.

impl<C> Debug for CharsetEncoder<C>

where C: CharsetCodec + Debug,

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

Formats the encoder without exposing additional bounds for cached units.

impl<C> PartialEq for CharsetEncoder<C>

where C: CharsetCodec + PartialEq,

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

Compares encoder configuration without leaking cached-unit trait bounds.

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<C> Eq for CharsetEncoder<C>

where C: CharsetCodec + Eq,