Struct Crypto 

pub struct Crypto<Data> {
    pub offset: VarInt,
    pub data: Data,
}

Fields

offset: VarInt

A variable-length integer specifying the byte offset in the stream for the data in this CRYPTO frame.

data: Data

The cryptographic message data.

Implementations

impl<Data> Crypto<Data>

pub const fn tag(&self) -> u8

pub fn map_data<F: FnOnce(Data) -> Out, Out>(self, map: F) -> Crypto<Out>

Converts the crypto data from one type to another

impl<Data: EncoderValue> Crypto<Data>

pub fn try_fit(&self, capacity: usize) -> Result<usize, FitError>

Tries to fit the frame into the provided capacity

If ok, the new payload length is returned, otherwise the frame cannot fit.

Trait Implementations

impl<Data> AckElicitable for Crypto<Data>

fn ack_elicitation(&self) -> AckElicitation

impl<Data> CongestionControlled for Crypto<Data>

fn is_congestion_controlled(&self) -> bool

impl<Data: Debug> Debug for Crypto<Data>

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

Formats the value using the given formatter.

impl<'a, Data: DecoderValue<'a>> DecoderParameterizedValue<'a> for Crypto<Data>

type Parameter = u8

fn decode_parameterized( _tag: Self::Parameter, buffer: DecoderBuffer<'a>, ) -> DecoderBufferResult<'a, Self>

impl<'a, Data: DecoderValueMut<'a>> DecoderParameterizedValueMut<'a> for Crypto<Data>

type Parameter = u8

fn decode_parameterized_mut( _tag: Self::Parameter, buffer: DecoderBufferMut<'a>, ) -> DecoderBufferMutResult<'a, Self>

impl<Data: EncoderValue> EncoderValue for Crypto<Data>

fn encode<E: Encoder>(&self, buffer: &mut E)

Encodes the value into the encoder

fn encode_mut<E>(&mut self, encoder: &mut E)

where E: Encoder,

Encodes the value into the encoder, while potentially mutating the value itself

fn encoding_size(&self) -> usize

Returns the encoding size with no buffer constrains

fn encoding_size_for_encoder<E>(&self, encoder: &E) -> usize

where E: Encoder,

Returns the encoding size for the given encoder’s capacity

fn encode_with_len_prefix<Len, E>(&self, encoder: &mut E)

where Len: TryFrom<usize> + EncoderValue, E: Encoder, Self: Sized, <Len as TryFrom<usize>>::Error: Debug,

Encodes the value into the encoder with a prefix of Len

fn encode_to_vec(&self) -> Vec<u8>

impl<'a, AckRanges, Data> From<Crypto<Data>> for Frame<'a, AckRanges, Data>

fn from(v: Crypto<Data>) -> Frame<'a, AckRanges, Data>

Converts to this type from the input type.

impl<'a> From<Crypto<DecoderBuffer<'a>>> for CryptoRef<'a>

fn from(s: Crypto<DecoderBuffer<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Crypto<DecoderBufferMut<'a>>> for CryptoRef<'a>

fn from(s: Crypto<DecoderBufferMut<'a>>) -> Self

Converts to this type from the input type.

impl<'a> From<Crypto<DecoderBufferMut<'a>>> for CryptoMut<'a>

fn from(s: Crypto<DecoderBufferMut<'a>>) -> Self

Converts to this type from the input type.

impl<Data> IntoEvent<Frame> for &Crypto<Data>

where Data: EncoderValue,

fn into_event(self) -> Frame

impl<Data: PartialEq> PartialEq for Crypto<Data>

fn eq(&self, other: &Crypto<Data>) -> 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<Data> Probing for Crypto<Data>

fn path_validation(&self) -> Probe

impl<Data: Eq> Eq for Crypto<Data>

impl<Data> StructuralPartialEq for Crypto<Data>