Trait destream::en::Encoder

pub trait Encoder<'en>: Sized {
    type Ok: Stream + Send + Unpin + 'en;
    type Error: Error + Send + Unpin + 'en;
    type EncodeMap: EncodeMap<'en, Ok = Self::Ok, Error = Self::Error>;
    type EncodeSeq: EncodeSeq<'en, Ok = Self::Ok, Error = Self::Error>;
    type EncodeTuple: EncodeTuple<'en, Ok = Self::Ok, Error = Self::Error>;

    // Required methods
    fn encode_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
    fn encode_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
    fn encode_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
    fn encode_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
    fn encode_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
    fn encode_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
    fn encode_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
    fn encode_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
    fn encode_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
    fn encode_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
    fn encode_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
    fn encode_array_bool<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = bool> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_i8<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = i8> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_i16<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = i16> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_i32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = i32> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_i64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = i64> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_u8<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = u8> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_u16<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = u16> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_u32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = u32> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_u64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = u64> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_f32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = f32> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_array_f64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>
       where T: IntoIterator<Item = f64> + Send + Unpin + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en,
             <T as IntoIterator>::IntoIter: Send + Unpin + 'en;
    fn encode_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
    fn encode_none(self) -> Result<Self::Ok, Self::Error>;
    fn encode_some<T: IntoStream<'en> + 'en>(
        self,
        value: T
    ) -> Result<Self::Ok, Self::Error>;
    fn encode_unit(self) -> Result<Self::Ok, Self::Error>;
    fn encode_bytes<B: Into<Bytes>>(
        self,
        bytes: B
    ) -> Result<Self::Ok, Self::Error>;
    fn encode_uuid(self, uuid: Uuid) -> Result<Self::Ok, Self::Error>;
    fn encode_map(
        self,
        len: Option<usize>
    ) -> Result<Self::EncodeMap, Self::Error>;
    fn encode_map_stream<K, V, S>(self, map: S) -> Result<Self::Ok, Self::Error>
       where K: IntoStream<'en> + 'en,
             V: IntoStream<'en> + 'en,
             S: Stream<Item = (K, V)> + Send + Unpin + 'en;
    fn encode_seq(
        self,
        len: Option<usize>
    ) -> Result<Self::EncodeSeq, Self::Error>;
    fn encode_seq_stream<T, S>(self, seq: S) -> Result<Self::Ok, Self::Error>
       where T: IntoStream<'en> + 'en,
             S: Stream<Item = T> + Send + Unpin + 'en;
    fn encode_tuple(self, len: usize) -> Result<Self::EncodeTuple, Self::Error>;
    fn collect_bytes<B: IntoIterator<Item = u8>>(
        self,
        bytes: B
    ) -> Result<Self::Ok, Self::Error>;

    // Provided methods
    fn collect_seq<T, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
       where T: IntoStream<'en> + 'en,
             I: IntoIterator<Item = T> { ... }
    fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
       where K: IntoStream<'en> + 'en,
             V: IntoStream<'en> + 'en,
             I: IntoIterator<Item = (K, V)> { ... }
    fn collect_str<T: Display + ?Sized>(
        self,
        value: &T
    ) -> Result<Self::Ok, Self::Error> { ... }
}

A data format that can encode and stream any data structure supported by destream.

Based on serde::ser::Serializer.

Required Associated Types

type Ok: Stream + Send + Unpin + 'en

The output type produced by this Encoder.

type Error: Error + Send + Unpin + 'en

The type returned when an encoding error is encountered.

type EncodeMap: EncodeMap<'en, Ok = Self::Ok, Error = Self::Error>

Type returned from encode_map for streaming the content of the map.

type EncodeSeq: EncodeSeq<'en, Ok = Self::Ok, Error = Self::Error>

Type returned from encode_seq for streaming the content of the sequence.

type EncodeTuple: EncodeTuple<'en, Ok = Self::Ok, Error = Self::Error>

Type returned from encode_tuple for streaming the content of the tuple.

Required Methods

fn encode_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

Encode a bool.

fn encode_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

Encode an i8.

fn encode_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

Encode an i16.

fn encode_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

Encode an i32.

fn encode_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

Encode an i64.

fn encode_u8(self, v: u8) -> Result<Self::Ok, Self::Error>

Encode a u8.

fn encode_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

Encode a u16.

fn encode_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

Encode a u32.

fn encode_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

Encode a u64.

fn encode_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

Encode an f32 value.

fn encode_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

Encode an f64 value.

fn encode_array_bool<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = bool> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of bools.

fn encode_array_i8<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = i8> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of i8s.

fn encode_array_i16<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = i16> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of i16s.

fn encode_array_i32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = i32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of i32s.

fn encode_array_i64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = i64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of i64s.

fn encode_array_u8<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = u8> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of u8s.

fn encode_array_u16<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = u16> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of u16s.

fn encode_array_u32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = u32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of u32s.

fn encode_array_u64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = u64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of u64s.

fn encode_array_f32<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = f32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of f32s.

fn encode_array_f64<T, S>(self, chunks: S) -> Result<Self::Ok, Self::Error>

where T: IntoIterator<Item = f64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en, <T as IntoIterator>::IntoIter: Send + Unpin + 'en,

Encode an array of f64s.

fn encode_str(self, v: &str) -> Result<Self::Ok, Self::Error>

Encode a &str.

fn encode_none(self) -> Result<Self::Ok, Self::Error>

Encode a None value.

fn encode_some<T: IntoStream<'en> + 'en>( self, value: T ) -> Result<Self::Ok, Self::Error>

Encode a Some(T) value.

fn encode_unit(self) -> Result<Self::Ok, Self::Error>

Encode a () value.

fn encode_bytes<B: Into<Bytes>>(self, bytes: B) -> Result<Self::Ok, Self::Error>

Encode a binary value.

fn encode_uuid(self, uuid: Uuid) -> Result<Self::Ok, Self::Error>

Encode a Uuid.

fn encode_map(self, len: Option<usize>) -> Result<Self::EncodeMap, Self::Error>

Begin encoding a map. This call must be followed by zero or more calls to encode_key and encode_value, then end.

The argument is the number of elements in the map, which may or may not be computable before iterating over the map.

fn encode_map_stream<K, V, S>(self, map: S) -> Result<Self::Ok, Self::Error>

where K: IntoStream<'en> + 'en, V: IntoStream<'en> + 'en, S: Stream<Item = (K, V)> + Send + Unpin + 'en,

Given a stream of encodable key-value pairs, return a stream encoded as a map.

fn encode_seq(self, len: Option<usize>) -> Result<Self::EncodeSeq, Self::Error>

Begin encoding a variably sized sequence. This call must be followed by zero or more calls to encode_element, then end.

The argument is the number of elements in the sequence, which may or may not be computable before iterating over the sequence.

fn encode_seq_stream<T, S>(self, seq: S) -> Result<Self::Ok, Self::Error>

where T: IntoStream<'en> + 'en, S: Stream<Item = T> + Send + Unpin + 'en,

Given a stream of encodable values, return a stream encoded as a sequence.

fn encode_tuple(self, len: usize) -> Result<Self::EncodeTuple, Self::Error>

Begin encoding a statically sized sequence whose length will be known at decoding time without looking at the encoded data. This call must be followed by zero or more calls to encode_element, then end.

fn collect_bytes<B: IntoIterator<Item = u8>>( self, bytes: B ) -> Result<Self::Ok, Self::Error>

Collect an iterator of bytes.

Provided Methods

fn collect_seq<T, I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where T: IntoStream<'en> + 'en, I: IntoIterator<Item = T>,

Collect an iterator as a sequence.

The default implementation encodes each item yielded by the iterator using encode_seq. Implementors should not need to override this method.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where K: IntoStream<'en> + 'en, V: IntoStream<'en> + 'en, I: IntoIterator<Item = (K, V)>,

Collect an iterator as a map.

The default implementation encodes each pair yielded by the iterator using encode_map. Implementors should not need to override this method.

fn collect_str<T: Display + ?Sized>( self, value: &T ) -> Result<Self::Ok, Self::Error>

Encode a string produced by an implementation of Display.

Object Safety

This trait is not object safe.

Implementors