Struct Tag 

pub struct Tag<Inner, T>(pub Refined<Inner, TagPred<T>>);

Generic tag combinator that matches the input with a given value and discards it e.g. Tag(U8, 0) matches the byte 0; Tag(Fixed::<3>, &[1, 2, 3]) matches the bytes [1, 2, 3]

Tuple Fields

0: Refined<Inner, TagPred<T>>

Implementations

impl<Inner, T> Tag<Inner, T>

pub fn new(inner: Inner, tag: T) -> Self

Creates a new Tag combinator.

Trait Implementations

impl<'x, const N: usize> Combinator<'x, &'x [u8], Vec<u8>> for Tag<Fixed<N>, [u8; N]>

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, _v: Self::SType) -> usize

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

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

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

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

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U16Be, u16>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U16Le, u16>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U32Be, u32>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U32Le, u32>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U64Be, u64>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U64Le, u64>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<U8, u8>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<'x, I, O> Combinator<'x, I, O> for Tag<UnsignedLEB128, UInt>

where I: VestPublicInput, O: VestPublicOutput<I>,

type Type = ()

The result type of parsing

type SType = ()

The input type of serialization, often a reference to Self::Type. For “structural” formats though (e.g., crate::regular::sequence::Pair and crate::regular::variant::Choice), this is the tuple/sum of the corresponding Combinator::SType types.

fn length(&self, v: Self::SType) -> usize

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

fn parse(&self, s: I) -> Result<(usize, Self::Type), ParseError>

The parsing function. To enable “zero-copy” parsing, implementations of parse should not consume/deepcopy the input buffer I, but rather return a slice of the input buffer for Self::Type whenever possible. See crate::buf_traits::VestInput and crate::buf_traits::VestPublicInput for more details.

fn serialize( &self, v: Self::SType, data: &mut O, pos: usize, ) -> Result<usize, SerializeError>

The serialization function. The intended use of serialize is to serialize a value v into the buffer buf at the position pos “in-place” (i.e., without allocating a new buffer or extending the buffer).

impl<Inner: SpecCombinator<Type = T>, T> SpecCombinator for Tag<Inner, T>

type Type = ()

The view of [Combinator::Result].

impl<Inner: View, T: View> View for Tag<Inner, T>

type V = Tag<<Inner as View>::V, <T as View>::V>

impl<Inner, T> DisjointFrom<Tag<Inner, T>> for Tag<Inner, T>

where Inner: SpecCombinator<Type = T>,

impl<Inner: SecureSpecCombinator<Type = T>, T> SecureSpecCombinator for Tag<Inner, T>