Struct kserd::encode::Encoder

pub struct Encoder;

Encoder to pass to Serialize::serialize to encode a type into a Kserd.

There is no data associated with the Encoder, instead it is used to implement serde's Serializer trait. It can be used to encode a data type that implements Serialize like so:

use kserd::encode::Encoder;
use kserd::encode::Serialize;

let data = ("Hello!", 3.14);
let expected = Kserd::new(
    Value::Tuple(vec![
        Kserd::new_str("Hello!"),
        Kserd::new_num(3.14),
    ])
);

let kserd = data.serialize(Encoder);
assert_eq!(kserd, Ok(expected));

It is important to note that the signature of the Serialize trait does not allow propogation of borrowed data. Specifically, when implementing a Serializer the values are either passed through copied, or as ephemeral borrows as in the case of strings and byte arrays. This limits the Kserd to be an owned copy, with a 'static lifetime parameter. This has implications when decoding as described in the Decoder documentation. An alternate trait ToKserd is defined that consumes the data structure and allows borrowed data to be propogated to the Kserd.

There is also a helper function Kserd::enc that can encode without importing the Encoder.

let expected = Kserd::new(
    Value::Tuple(vec![
        Kserd::new_str("Hello!"),
        Kserd::new_num(3.14),
    ])
);

let kserd = Kserd::enc(&("Hello!", 3.14));
assert_eq!(kserd, Ok(expected));

Trait Implementations

impl Serializer for Encoder

type Ok = Kserd<'static>

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an [io::Write] or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type Error = Error

The error type when some error occurs during serialization.

type SerializeSeq = SeqLike

Type returned from [serialize_seq] for serializing the content of the sequence.

type SerializeTuple = TupleLike

Type returned from [serialize_tuple] for serializing the content of the tuple.

type SerializeTupleStruct = TupleLike

Type returned from [serialize_tuple_struct] for serializing the content of the tuple struct.

type SerializeTupleVariant = TupleLike

Type returned from [serialize_tuple_variant] for serializing the content of the tuple variant.

type SerializeMap = MapLike

Type returned from [serialize_map] for serializing the content of the map.

type SerializeStruct = CntrLike

Type returned from [serialize_struct] for serializing the content of the struct.

type SerializeStructVariant = CntrLike

Type returned from [serialize_struct_variant] for serializing the content of the struct variant.

fn serialize_bool(self, v: bool) -> Result<Kserd<'static>, Error>

Serialize a bool value.

fn serialize_i8(self, v: i8) -> Result<Kserd<'static>, Error>

Serialize an i8 value.

fn serialize_i16(self, v: i16) -> Result<Kserd<'static>, Error>

Serialize an i16 value.

fn serialize_i32(self, v: i32) -> Result<Kserd<'static>, Error>

Serialize an i32 value.

fn serialize_i64(self, v: i64) -> Result<Kserd<'static>, Error>

Serialize an i64 value.

fn serialize_i128(self, v: i128) -> Result<Kserd<'static>, Error>

Serialize an i128 value.

fn serialize_u8(self, v: u8) -> Result<Kserd<'static>, Error>

Serialize a u8 value.

fn serialize_u16(self, v: u16) -> Result<Kserd<'static>, Error>

Serialize a u16 value.

fn serialize_u32(self, v: u32) -> Result<Kserd<'static>, Error>

Serialize a u32 value.

fn serialize_u64(self, v: u64) -> Result<Kserd<'static>, Error>

Serialize a u64 value.

fn serialize_u128(self, v: u128) -> Result<Kserd<'static>, Error>

Serialize a u128 value.

fn serialize_f32(self, v: f32) -> Result<Kserd<'static>, Error>

Serialize an f32 value.

fn serialize_f64(self, v: f64) -> Result<Kserd<'static>, Error>

Serialize an f64 value.

fn serialize_char(self, v: char) -> Result<Kserd<'static>, Error>

Serialize a character.

fn serialize_str(self, v: &str) -> Result<Kserd<'static>, Error>

Serialize a &str.

fn serialize_bytes(self, v: &[u8]) -> Result<Kserd<'static>, Error>

Serialize a chunk of raw byte data.

fn serialize_none(self) -> Result<Kserd<'static>, Error>

Serialize a [None] value.

fn serialize_some<T: ?Sized + Serialize>(
    self,
    v: &T
) -> Result<Kserd<'static>, Error>

Serialize a [Some(T)] value.

fn serialize_unit(self) -> Result<Kserd<'static>, Error>

Serialize a () value.

fn serialize_unit_struct(
    self,
    name: &'static str
) -> Result<Kserd<'static>, Error>

Serialize a unit struct like struct Unit or PhantomData<T>.

fn serialize_unit_variant(
    self,
    _: &'static str,
    _: u32,
    variant: &'static str
) -> Result<Kserd<'static>, Error>

Serialize a unit variant like E::A in enum E { A, B }.

fn serialize_newtype_struct<T: ?Sized + Serialize>(
    self,
    name: &'static str,
    value: &T
) -> Result<Kserd<'static>, Error>

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_newtype_variant<T: ?Sized + Serialize>(
    self,
    _: &'static str,
    _: u32,
    variant: &'static str,
    value: &T
) -> Result<Kserd<'static>, Error>

Serialize a newtype variant like E::N in enum E { N(u8) }.

fn serialize_seq(self, len: Option<usize>) -> Result<SeqLike, Error>

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

fn serialize_tuple(self, len: usize) -> Result<TupleLike, Error>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple_struct(
    self,
    name: &'static str,
    len: usize
) -> Result<TupleLike, Error>

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_tuple_variant(
    self,
    _: &'static str,
    _: u32,
    variant: &'static str,
    len: usize
) -> Result<TupleLike, Error>

Begin to serialize a tuple variant like E::T in enum E { T(u8, u8) }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_map(self, _len: Option<usize>) -> Result<MapLike, Error>

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

fn serialize_struct(
    self,
    name: &'static str,
    _len: usize
) -> Result<CntrLike, Error>

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn serialize_struct_variant(
    self,
    _: &'static str,
    _: u32,
    variant: &'static str,
    _: usize
) -> Result<CntrLike, Error>

Begin to serialize a struct variant like E::S in enum E { S { r: u8, g: u8, b: u8 } }. This call must be followed by zero or more calls to serialize_field, then a call to end.

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

Serialize a string produced by an implementation of Display.

fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    I: IntoIterator,
    <I as IntoIterator>::Item: Serialize, 

Collect an iterator as a sequence.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error> where
    I: IntoIterator<Item = (K, V)>,
    K: Serialize,
    V: Serialize, 

Collect an iterator as a map.

fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.