Serializer

packet::serialize

Trait Serializer 

Source 
pub trait Serializer: Sized {
    type Buffer;

    // Required methods
    fn serialize<B: GrowBufferMut, P: BufferProvider<Self::Buffer, B>>(
        self,
        outer: PacketConstraints,
        provider: P,
    ) -> Result<B, (SerializeError<P::Error>, Self)>;
    fn serialize_new_buf<B: GrowBufferMut, A: LayoutBufferAlloc<B>>(
        &self,
        outer: PacketConstraints,
        alloc: A,
    ) -> Result<B, SerializeError<A::Error>>;

    // Provided methods
    fn serialize_vec(
        self,
        outer: PacketConstraints,
    ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Never>, Self)>
       where Self::Buffer: ReusableBuffer { ... }
    fn serialize_no_alloc(
        self,
        outer: PacketConstraints,
    ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>
       where Self::Buffer: ReusableBuffer { ... }
    fn serialize_outer<B: GrowBufferMut, P: BufferProvider<Self::Buffer, B>>(
        self,
        provider: P,
    ) -> Result<B, (SerializeError<P::Error>, Self)> { ... }
    fn serialize_vec_outer(
        self,
    ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Never>, Self)>
       where Self::Buffer: ReusableBuffer { ... }
    fn serialize_no_alloc_outer(
        self,
    ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>
       where Self::Buffer: ReusableBuffer { ... }
    fn wrap_in<B: PacketBuilder>(self, outer: B) -> Nested<Self, B> { ... }
    fn with_size_limit(
        self,
        limit: usize,
    ) -> Nested<Self, LimitedSizePacketBuilder> { ... }
}

Required Associated Types§

Source

type Buffer

The type of buffers returned from serialization methods on this trait.

Required Methods§

Source

fn serialize<B: GrowBufferMut, P: BufferProvider<Self::Buffer, B>>( self, outer: PacketConstraints, provider: P, ) -> Result<B, (SerializeError<P::Error>, Self)>

Serializes this Serializer, producing a buffer.

As Serializers can be nested using the Nested type (constructed using PacketBuilder::wrap_body and Serializer::wrap_in), the serialize method is recursive - calling it on a Nested will recurse into the inner Serializer, which might itself be a Nested, and so on. When the innermost Serializer is reached, the contained buffer is passed to the provider, allowing it to decide how to produce a buffer which is large enough to fit the entire packet - either by reusing the existing buffer, or by discarding it and allocating a new one. outer specifies PacketConstraints for the outer parts of the packet (header and footer).

Source

fn serialize_new_buf<B: GrowBufferMut, A: LayoutBufferAlloc<B>>( &self, outer: PacketConstraints, alloc: A, ) -> Result<B, SerializeError<A::Error>>

Serializes the data into a new buffer without consuming self.

Creates a new buffer using alloc and serializes the data into that that new buffer. Unlike all other serialize methods, serialize_new_buf takes self by reference. This allows to use the same Serializer to serialize the data more than once.

Provided Methods§

Source

fn serialize_vec( self, outer: PacketConstraints, ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Never>, Self)>
where Self::Buffer: ReusableBuffer,

Serializes this Serializer, allocating a Buf<Vec<u8>> if the contained buffer isn’t large enough.

serialize_vec is like serialize, except that, if the contained buffer isn’t large enough to contain the packet, a new Vec<u8> is allocated and wrapped in a Buf. If the buffer is large enough, but the body is too far forwards or backwards to fit the encapsulating headers or footers, the body will be moved within the buffer (this operation’s cost is linear in the size of the body).

serialize_vec is equivalent to calling serialize with new_buf_vec as the BufferProvider.

Source

fn serialize_no_alloc( self, outer: PacketConstraints, ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>
where Self::Buffer: ReusableBuffer,

Serializes this Serializer, failing if the existing buffer is not large enough.

serialize_no_alloc is like serialize, except that it will fail if the existing buffer isn’t large enough. If the buffer is large enough, but the body is too far forwards or backwards to fit the encapsulating headers or footers, the body will be moved within the buffer (this operation’s cost is linear in the size of the body).

serialize_no_alloc is equivalent to calling serialize with a BufferProvider which cannot allocate a new buffer (such as ()).

Source

fn serialize_outer<B: GrowBufferMut, P: BufferProvider<Self::Buffer, B>>( self, provider: P, ) -> Result<B, (SerializeError<P::Error>, Self)>

Serializes this Serializer as the outermost packet.

serialize_outer is like serialize, except that it is called when this Serializer describes the outermost packet, not encapsulated in any other packets. It is equivalent to calling serialize with an empty PacketBuilder (such as ()).

Source

fn serialize_vec_outer( self, ) -> Result<Either<Self::Buffer, Buf<Vec<u8>>>, (SerializeError<Never>, Self)>
where Self::Buffer: ReusableBuffer,

Serializes this Serializer as the outermost packet, allocating a Buf<Vec<u8>> if the contained buffer isn’t large enough.

serialize_vec_outer is like serialize_vec, except that it is called when this Serializer describes the outermost packet, not encapsulated in any other packets. It is equivalent to calling serialize_vec with an empty PacketBuilder (such as ()).

Source

fn serialize_no_alloc_outer( self, ) -> Result<Self::Buffer, (SerializeError<BufferTooShortError>, Self)>
where Self::Buffer: ReusableBuffer,

Serializes this Serializer as the outermost packet, failing if the existing buffer is not large enough.

serialize_no_alloc_outer is like serialize_no_alloc, except that it is called when this Serializer describes the outermost packet, not encapsulated in any other packets. It is equivalent to calling serialize_no_alloc with an empty PacketBuilder (such as ()).

Source

fn wrap_in<B: PacketBuilder>(self, outer: B) -> Nested<Self, B>

Encapsulates this Serializer in a packet, producing a new Serializer.

wrap_in() consumes this Serializer and a PacketBuilder, and produces a new Serializer which describes encapsulating this one in the packet described by outer.

Source

fn with_size_limit(self, limit: usize) -> Nested<Self, LimitedSizePacketBuilder>

Creates a new Serializer which will enforce a size limit.

with_size_limit consumes this Serializer and limit, and produces a new Serializer which will enforce the given limit on all serialization requests. Note that the given limit will be enforced at this layer - serialization requests will be rejected if the body produced by the request at this layer would exceed the limit. It has no effect on headers or footers added by encapsulating layers outside of this one.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§