Struct EncodePlan 

pub struct EncodePlan<A> {
    pub max_output_units: usize,
    pub action: A,
}

Describes how much output capacity one encoded value needs before writing.

EncodePlan is produced by crate::BufferedEncodeHooks::prepare_encode and consumed by crate::BufferedEncodeHooks::write_encode. The capacity field is a safe upper bound required by the concrete writer, not necessarily the exact number of units that will be written.

Type Parameters

• A: Concrete action interpreted by the encoder implementation.

Fields

max_output_units: usize

Output units that must be writable before calling write_encode.

Default codec-backed encoders usually use crate::Codec::max_units_per_value. Domain-specific encoders may use a tighter bound, such as a charset encoder using its exact encoded length probe. A value of zero is valid for policies that consume input without producing output.

action: A

Concrete write action interpreted by the encoder implementation.

Implementations

impl<A> EncodePlan<A>

pub const fn new(max_output_units: usize, action: A) -> Self

Creates an encoding plan.

Parameters

• max_output_units: Output capacity required before writing.
• action: Concrete plan action for the encoder implementation.

Returns

Returns an encoding plan carrying the supplied capacity bound and action.

Trait Implementations

impl<A: Clone> Clone for EncodePlan<A>

fn clone(&self) -> EncodePlan<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Copy> Copy for EncodePlan<A>

impl<A: Debug> Debug for EncodePlan<A>

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

Formats the value using the given formatter.

impl<A: Eq> Eq for EncodePlan<A>

impl<A: Hash> Hash for EncodePlan<A>

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

Feeds this value into the given Hasher.

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<A: PartialEq> PartialEq for EncodePlan<A>

fn eq(&self, other: &EncodePlan<A>) -> 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<A> StructuralPartialEq for EncodePlan<A>