Struct Bind 

pub struct Bind<A, B>(pub A, pub B);

Sequential composition of formats A and B, where B may depend on the value of A.

Parsing semantics: parses A to get a key, then parses B(key) to get the body value, and returns (key, value). During serialization, the caller must provide both the key and value.

Note on usage

Prefer super::Implicit when the key should be recovered from the body value instead of being carried explicitly through the value type.

Tuple Fields

0: A

1: B

Trait Implementations

impl<A, B, STA, STB> ByteLen<(STA, STB)> for Bind<A, B>

where STA: DeepView, STB: DeepView, A: ByteLen<STA>, B::O: ByteLen<STB>, B: MapRef<STA, Input = STA::V>,

fn length(&self, v: &(STA, STB)) -> usize

Returns the exact number of bytes produced by serialization.

impl<A: Clone, B: Clone> Clone for Bind<A, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, B> Consistency for Bind<A, B>

where A: Consistency, B: SpecMap<Input = A::Val>, B::Output: Consistency,

type Val = (<A as Consistency>::Val, <<B as SpecMap>::Output as Consistency>::Val)

The type of values whose consistency is being checked.

impl<A: Copy, B: Copy> Copy for Bind<A, B>

impl<A, B> EquivSerializers for Bind<A, B>

where A: EquivSerializersGeneral, B: SpecMap<Input = A::SVal>, B::Output: EquivSerializers,

impl<A, B> EquivSerializersGeneral for Bind<A, B>

where A: EquivSerializersGeneral, B: SpecMap<Input = A::SVal>, B::Output: EquivSerializersGeneral,

impl<A, B> GoodSerializer for Bind<A, B>

where A: GoodSerializer, B: SpecMap<Input = A::SVal>, B::Output: GoodSerializer,

impl<A, B> NoLookAhead for Bind<A, B>

where A: NoLookAhead, B: SpecMap<Input = A::PVal>, B::Output: NoLookAhead,

impl<A, B> NonMalleable for Bind<A, B>

where A: NonMalleable, B: SpecMap<Input = A::PVal>, B::Output: NonMalleable,

impl<A, B> NonTailFmt for Bind<A, B>

where A: NonTailFmt, B: SpecMap<Input = A::SValue>, B::Output: NonTailFmt,

impl<I, A, B> Parser<I> for Bind<A, B>

where I: InputBuf, A: Parser<I> + SafeParser, B::O: Parser<I> + SafeParser, B: MapRef<A::PT, Input = A::PVal>,

type PT = (<A as Parser<I>>::PT, <<B as MapRef<<A as Parser<I>>::PT>>::O as Parser<I>>::PT)

Executable value returned by this parser.

fn min_byte_len(&self) -> usize

A lower bound on the number of bytes one successful parse consumes.

fn parse(&self, ibuf: &I) -> PResult<Self::PT>

Parses a prefix of ibuf.

impl<A, B, STA, STB> Prepare<(STA, STB)> for Bind<A, B>

where STA: DeepView, STB: DeepView, A: Prepare<STA>, B::O: Prepare<STB>, B: MapRef<STA, Input = STA::V>,

fn prepare(&self, v: &(STA, STB)) -> Result<usize, PreSerializeError>

Validates v and returns its exact serialized length.

impl<A, B> Productive for Bind<A, B>

where A: Productive, B: SpecMap<Input = A::PVal>, B::Output: Productive,

impl<A, B> SPRoundTripDps for Bind<A, B>

where A: SPRoundTripDps + NonTailFmt, B: SpecMap<Input = A::T>, B::Output: SPRoundTripDps,

impl<A, B> SafeParser for Bind<A, B>

where A: SafeParser, B: SpecMap<Input = A::PVal>, B::Output: SafeParser,

impl<Output: OutputBuf, A, B, TA, TB> Serializer<Output, (TA, TB)> for Bind<A, B>

where TA: DeepView, TB: DeepView, A: Serializer<Output, TA>, B::O: Serializer<Output, TB>, B: MapRef<TA, Input = TA::V>,

fn serialize_into(&self, v: &(TA, TB), obuf: &mut Output)

Serializes the value v into the output buffer obuf by (logically) appending the serialized bytes to the end of obuf. This view has two main benefits:

impl<A, B> SoundParser for Bind<A, B>

where A: SoundParser, B: SpecMap<Input = A::PVal>, B::Output: SoundParser,

impl<A, B> SpecByteLen for Bind<A, B>

where A: SpecByteLen, B: SpecMap<Input = A::T>, B::Output: SpecByteLen,

type T = (<A as SpecByteLen>::T, <<B as SpecMap>::Output as SpecByteLen>::T)

The type of values whose byte length is being computed.

impl<A, B> SpecParser for Bind<A, B>

where A: SpecParser, B: SpecMap<Input = A::PVal>, B::Output: SpecParser,

type PVal = (<A as SpecParser>::PVal, <<B as SpecMap>::Output as SpecParser>::PVal)

The type of parsed values.

impl<A, B> SpecSerializer for Bind<A, B>

where A: SpecSerializer, B: SpecMap<Input = A::SVal>, B::Output: SpecSerializer,

type SVal = (<A as SpecSerializer>::SVal, <<B as SpecMap>::Output as SpecSerializer>::SVal)

The type of values to be serialized.

impl<A, B> SpecSerializerDps for Bind<A, B>

where A: SpecSerializerDps, B: SpecMap<Input = A::SValue>, B::Output: SpecSerializerDps,

type SValue = (<A as SpecSerializerDps>::SValue, <<B as SpecMap>::Output as SpecSerializerDps>::SValue)

The type of values to be serialized.

impl<A, B> StaticByteLen for Bind<A, B>

where A: StaticByteLen, B: SpecMap<Input = A::T>, B::Output: StaticByteLen,

impl<A, B> ValueByteLen for Bind<A, B>

where A: ValueByteLen, B: SpecMap<Input = A::T>, B::Output: ValueByteLen,