Struct Optional

pub struct Optional<C1, C2>(pub C1, pub C2);

Essentially doing OrdChoice((C1, C2), C2), but the result is mapped through Left((A, B)) <-> (Some(A), B) Right(B) <-> (None, B)

NOTE: we are not directly using OrdChoice since we don’t want to enforce C2::is_prefix_secure()

Tuple Fields

0: C1

1: C2

Trait Implementations

impl<C1, C2> Combinator for Optional<C1, C2>

where C1: Combinator, C2: Combinator, C1::V: SecureSpecCombinator<SpecResult = <C1::Owned as View>::V>, C2::V: SecureSpecCombinator<SpecResult = <C2::Owned as View>::V> + DisjointFrom<C1::V>,

type Result<'a> = PairValue<OptionDeep<<C1 as Combinator>::Result<'a>>, <C2 as Combinator>::Result<'a>>

The result type of parsing and the input type of serialization.

type Owned = PairValue<OptionDeep<<C1 as Combinator>::Owned>, <C2 as Combinator>::Owned>

The owned parsed type. This is currently a hack to avoid lifetime bindings in SpecCombinator::SpecResult , but it can be useful if we want to have functions that return owned values (e.g. Vec<T>).

fn length(&self) -> Option<usize>

The length of the output buffer, if known. This can be used to optimize serialization by pre-allocating the buffer.

fn parse<'a>( &self, s: &'a [u8], ) -> Result<(usize, Self::Result<'a>), ParseError>

The parsing function.

fn serialize( &self, v: Self::Result<'_>, data: &mut Vec<u8>, pos: usize, ) -> Result<usize, SerializeError>

The serialization function.

impl<C1: Debug, C2: Debug> Debug for Optional<C1, C2>

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

Formats the value using the given formatter.

impl<C1, C2> SpecCombinator for Optional<C1, C2>

where C1: SecureSpecCombinator, C2: SecureSpecCombinator + DisjointFrom<C1>,

type SpecResult = PairValue<OptionDeep<<C1 as SpecCombinator>::SpecResult>, <C2 as SpecCombinator>::SpecResult>

The view of Combinator::Result.

impl<C1: View, C2: View> View for Optional<C1, C2>

type V = Optional<<C1 as View>::V, <C2 as View>::V>

impl<T1, T2, T3> DisjointFrom<T1> for Optional<T2, T3>

where T1: SecureSpecCombinator, T2: SecureSpecCombinator + DisjointFrom<T1>, T3: SecureSpecCombinator + DisjointFrom<T1> + DisjointFrom<T2>,

If T2 and T3 are both disjoint from T1, then something like Optional<T1, Optional<T2, T3>> is doable

impl<C1, C2> SecureSpecCombinator for Optional<C1, C2>

where C1: SecureSpecCombinator, C2: SecureSpecCombinator + DisjointFrom<C1>,