Trait destream::en::Encoder[−][src]

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>;

Show 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: IntoIterator<Item = bool> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_i8<T: IntoIterator<Item = i8> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_i16<T: IntoIterator<Item = i16> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_i32<T: IntoIterator<Item = i32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_i64<T: IntoIterator<Item = i64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_u8<T: IntoIterator<Item = u8> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_u16<T: IntoIterator<Item = u16> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_u32<T: IntoIterator<Item = u32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_u64<T: IntoIterator<Item = u64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_f32<T: IntoIterator<Item = f32> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

    fn encode_array_f64<T: IntoIterator<Item = f64> + Send + Unpin + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        chunks: S
    ) -> Result<Self::Ok, Self::Error>
    where
        <T as IntoIterator>::IntoIter: Send + Unpin + 'en;

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

    fn encode_bytes(self, v: &[u8]) -> 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_map(
        self, 
        len: Option<usize>
    ) -> Result<Self::EncodeMap, Self::Error>;

    fn encode_map_stream<K: IntoStream<'en> + 'en, V: IntoStream<'en> + 'en, S: Stream<Item = (K, V)> + Send + Unpin + 'en>(
        self, 
        map: S
    ) -> Result<Self::Ok, Self::Error>;

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

    fn encode_seq_stream<T: IntoStream<'en> + 'en, S: Stream<Item = T> + Send + Unpin + 'en>(
        self, 
        seq: S
    ) -> Result<Self::Ok, Self::Error>;

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

    fn collect_seq<T: IntoStream<'en> + 'en, I: IntoIterator<Item = T>>(
        self, 
        iter: I
    ) -> Result<Self::Ok, Self::Error> { ... }

    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> { ... }

}
Expand description

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

Based on serde::ser::Serializer.

Associated Types

The output type produced by this Encoder.

The type returned when an encoding error is encountered.

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

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

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

Required methods

Encode a bool.

Encode an i8.

Encode an i16.

Encode an i32.

Encode an i64.

Encode a u8.

Encode a u16.

Encode a u32.

Encode a u64.

Encode an f32 value.

Encode an f64 value.

Encode an array of bools.

Encode an array of i8s.

Encode an array of i16s.

Encode an array of i32s.

Encode an array of i64s.

Encode an array of u8s.

Encode an array of u16s.

Encode an array of u32s.

Encode an array of u64s.

Encode an array of f32s.

Encode an array of f64s.

Encode a &str.

Encode a byte buffer.

Encode a None value.

Encode a Some(T) value.

Encode a () value.

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.

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

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.

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

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.

Provided methods

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.

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.

Encode a string produced by an implementation of Display.

Implementors