Encoder

musli_core::en

Trait Encoder 

Source 
pub trait Encoder: Sized {
    type Cx: Context<Error = Self::Error>;
    type Error;
    type Mode: 'static;
    type EncodePack: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeSome: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeSequence: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeMap: MapEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeMapEntries: EntriesEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeVariant: VariantEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeSequenceVariant: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;
    type EncodeMapVariant: MapEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>;


Show 42 methods    // Required methods
    fn cx(&self) -> Self::Cx;
    fn expecting(&self, f: &mut Formatter<'_>) -> Result;

    // Provided methods
    fn try_fast_encode<T>(
        self,
        value: T,
    ) -> Result<TryFastEncode<T, Self>, Self::Error>
       where T: Encode<Self::Mode> { ... }
    fn encode<T>(self, value: T) -> Result<(), Self::Error>
       where T: Encode<Self::Mode> { ... }
    fn encode_empty(self) -> Result<(), Self::Error> { ... }
    fn encode_bool(self, v: bool) -> Result<(), Self::Error> { ... }
    fn encode_char(self, v: char) -> Result<(), Self::Error> { ... }
    fn encode_u8(self, v: u8) -> Result<(), Self::Error> { ... }
    fn encode_u16(self, v: u16) -> Result<(), Self::Error> { ... }
    fn encode_u32(self, v: u32) -> Result<(), Self::Error> { ... }
    fn encode_u64(self, v: u64) -> Result<(), Self::Error> { ... }
    fn encode_u128(self, v: u128) -> Result<(), Self::Error> { ... }
    fn encode_i8(self, v: i8) -> Result<(), Self::Error> { ... }
    fn encode_i16(self, v: i16) -> Result<(), Self::Error> { ... }
    fn encode_i32(self, v: i32) -> Result<(), Self::Error> { ... }
    fn encode_i64(self, v: i64) -> Result<(), Self::Error> { ... }
    fn encode_i128(self, v: i128) -> Result<(), Self::Error> { ... }
    fn encode_usize(self, v: usize) -> Result<(), Self::Error> { ... }
    fn encode_isize(self, v: isize) -> Result<(), Self::Error> { ... }
    fn encode_f32(self, v: f32) -> Result<(), Self::Error> { ... }
    fn encode_f64(self, v: f64) -> Result<(), Self::Error> { ... }
    fn encode_array<const N: usize>(
        self,
        array: &[u8; N],
    ) -> Result<(), Self::Error> { ... }
    fn encode_bytes(self, bytes: &[u8]) -> Result<(), Self::Error> { ... }
    fn encode_bytes_vectored<I>(
        self,
        len: usize,
        vectors: I,
    ) -> Result<(), Self::Error>
       where I: IntoIterator<Item: AsRef<[u8]>> { ... }
    fn encode_string(self, string: &str) -> Result<(), Self::Error> { ... }
    fn collect_string<T>(self, value: &T) -> Result<(), Self::Error>
       where T: ?Sized + Display { ... }
    fn encode_some(self) -> Result<Self::EncodeSome, Self::Error> { ... }
    fn encode_none(self) -> Result<(), Self::Error> { ... }
    fn encode_pack(self) -> Result<Self::EncodePack, Self::Error> { ... }
    fn encode_pack_fn<F>(self, f: F) -> Result<(), Self::Error>
       where F: FnOnce(&mut Self::EncodePack) -> Result<(), Self::Error> { ... }
    fn encode_slice<T>(self, slice: impl AsRef<[T]>) -> Result<(), Self::Error>
       where T: Encode<Self::Mode> { ... }
    fn encode_slices<T>(
        self,
        len: usize,
        slices: impl IntoIterator<Item: AsRef<[T]>>,
    ) -> Result<(), Self::Error>
       where T: Encode<Self::Mode> { ... }
    fn encode_sequence(
        self,
        hint: impl SequenceHint,
    ) -> Result<Self::EncodeSequence, Self::Error> { ... }
    fn encode_sequence_fn<F>(
        self,
        hint: impl SequenceHint,
        f: F,
    ) -> Result<(), Self::Error>
       where F: FnOnce(&mut Self::EncodeSequence) -> Result<(), Self::Error> { ... }
    fn encode_map(
        self,
        hint: impl MapHint,
    ) -> Result<Self::EncodeMap, Self::Error> { ... }
    fn encode_map_fn<F>(
        self,
        hint: impl MapHint,
        f: F,
    ) -> Result<(), Self::Error>
       where F: FnOnce(&mut Self::EncodeMap) -> Result<(), Self::Error> { ... }
    fn encode_map_entries(
        self,
        hint: impl MapHint,
    ) -> Result<Self::EncodeMapEntries, Self::Error> { ... }
    fn encode_variant(self) -> Result<Self::EncodeVariant, Self::Error> { ... }
    fn encode_variant_fn<F>(self, f: F) -> Result<(), Self::Error>
       where F: FnOnce(&mut Self::EncodeVariant) -> Result<(), Self::Error> { ... }
    fn encode_unit_variant<T>(self, tag: &T) -> Result<(), Self::Error>
       where T: ?Sized + Encode<Self::Mode> { ... }
    fn encode_sequence_variant<T>(
        self,
        tag: &T,
        hint: impl SequenceHint,
    ) -> Result<Self::EncodeSequenceVariant, Self::Error>
       where T: ?Sized + Encode<Self::Mode> { ... }
    fn encode_map_variant<T>(
        self,
        tag: &T,
        hint: impl MapHint,
    ) -> Result<Self::EncodeMapVariant, Self::Error>
       where T: ?Sized + Encode<Self::Mode> { ... }

}
Expand description

Trait governing how the encoder works.

Required Associated Types§

Source

type Cx: Context<Error = Self::Error>

Context associated with the encoder.

Source

type Error

Error associated with encoding.

Source

type Mode: 'static

Mode associated with encoding.

Source

type EncodePack: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

A simple pack that packs a sequence of elements.

Source

type EncodeSome: Encoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

Encoder returned when encoding an optional value which is present.

Source

type EncodeSequence: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

The type of a sequence encoder.

Source

type EncodeMap: MapEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

The type of a map encoder.

Source

type EncodeMapEntries: EntriesEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

Streaming encoder for map pairs.

Source

type EncodeVariant: VariantEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

Encoder for a variant.

Source

type EncodeSequenceVariant: SequenceEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

Encoder for a sequence variant.

Source

type EncodeMapVariant: MapEncoder<Cx = Self::Cx, Error = Self::Error, Mode = Self::Mode>

Encoder for a map variant.

Required Methods§

Source

fn cx(&self) -> Self::Cx

Access the context associated with the encoder.

Source

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

An expectation error. Every other implementation defers to this to report that something unexpected happened.

Provided Methods§

Source

fn try_fast_encode<T>( self, value: T, ) -> Result<TryFastEncode<T, Self>, Self::Error>
where T: Encode<Self::Mode>,

Try to quickly encode the specified value.

The default implementation simply returns the current encoder as Err(Self).

This is intended to be a fast path when encoding a value when an encoding permits it.

Source

fn encode<T>(self, value: T) -> Result<(), Self::Error>
where T: Encode<Self::Mode>,

Encode the value T into the current encoder.

This calls the appropriate Encode implementation for the given type.

Source

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

Encode a unit or something that is completely empty.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
struct UnitStruct;

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for UnitStruct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_empty()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a boolean value.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: bool
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_bool(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_char(self, v: char) -> Result<(), Self::Error>

Encode a character.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: char
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_char(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 8-bit unsigned integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: u8
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_u8(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 16-bit unsigned integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: u16
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_u16(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 32-bit unsigned integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: u32
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_u32(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 64-bit unsigned integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: u64
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_u64(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_u128(self, v: u128) -> Result<(), Self::Error>

Encode a 128-bit unsigned integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: u128
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_u128(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 8-bit signed integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: i8
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_i8(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 16-bit signed integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: i16
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_i16(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 32-bit signed integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: i32
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_i32(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 64-bit signed integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: i64
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_i64(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_i128(self, v: i128) -> Result<(), Self::Error>

Encode a 128-bit signed integer.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: i128
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_i128(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_usize(self, v: usize) -> Result<(), Self::Error>

Encode a usize.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: usize
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_usize(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_isize(self, v: isize) -> Result<(), Self::Error>

Encode a isize.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: isize
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_isize(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 32-bit floating point value.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: f32
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_f32(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a 64-bit floating point value.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: f64
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_f64(self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_array<const N: usize>( self, array: &[u8; N], ) -> Result<(), Self::Error>

Encode fixed-length array.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: [u8; 128]
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_array(&self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_bytes(self, bytes: &[u8]) -> Result<(), Self::Error>

Encode a sequence of bytes.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    #[musli(bytes)]
    data: Vec<u8>
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_bytes(self.data.as_slice())
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_bytes_vectored<I>( self, len: usize, vectors: I, ) -> Result<(), Self::Error>
where I: IntoIterator<Item: AsRef<[u8]>>,

Encode the given slices of bytes in sequence, with one following another as a single contiguous byte array.

The provided len is trusted, but providing the wrong length must never result in any memory unsafety. It might just cause the payload to be corrupted.

This can be useful to avoid allocations when a caller doesn’t have access to a single byte sequence like in VecDeque.

§Examples

Deriving an implementation:

use std::collections::VecDeque;
use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: VecDeque<u8>
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let (first, second) = self.data.as_slices();
        encoder.encode_bytes_vectored(self.data.len(), [first, second])
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_string(self, string: &str) -> Result<(), Self::Error>

Encode a string.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: String
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_string(self.data.as_str())
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode a value that implements Display as a string.

§Examples
use musli::{Encode, Encoder};

struct MyType {
    data: String,
}

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.collect_string(self.data.as_str())
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_some(self) -> Result<Self::EncodeSome, Self::Error>

Encode an optional value that is present.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: Option<String>
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match &self.data {
            Some(data) => {
                encoder.encode_some()?.encode(data)
            }
            None => {
                encoder.encode_none()
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

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

Encode an optional value that is absent.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: Option<String>
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match &self.data {
            Some(data) => {
                encoder.encode_some()?.encode(data)
            }
            None => {
                encoder.encode_none()
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_pack(self) -> Result<Self::EncodePack, Self::Error>

Construct a pack that can encode more than one element at a time.

This hints to the format that it should attempt to encode all of the elements in the packed sequence as compact as possible and that subsequent unpackers will know the exact length of the element being unpacked.

§Examples
use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

struct PackedStruct {
    field: u32,
    data: [u8; 128],
}

impl<M> Encode<M> for PackedStruct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut pack = encoder.encode_pack()?;
        pack.encode_next()?.encode(self.field)?;
        pack.encode_next()?.encode(self.data)?;
        pack.finish_sequence()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_pack_fn<F>(self, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self::EncodePack) -> Result<(), Self::Error>,

Encodes a pack using a closure.

§Examples
use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

struct PackedStruct {
    field: u32,
    data: [u8; 128],
}

impl<M> Encode<M> for PackedStruct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_pack_fn(|pack| {
            pack.encode_next()?.encode(self.field)?;
            pack.encode_next()?.encode(&self.data)?;
            Ok(())
        })
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_slice<T>(self, slice: impl AsRef<[T]>) -> Result<(), Self::Error>
where T: Encode<Self::Mode>,

Encode a slice as a sequence.

This defaults to using Encoder::encode_sequence and if specialized must implement the same format as would calling that method.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: Vec<String>
}

Implementing manually:

use musli::{Encode, Encoder};

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_slice(&self.data)
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_slices<T>( self, len: usize, slices: impl IntoIterator<Item: AsRef<[T]>>, ) -> Result<(), Self::Error>
where T: Encode<Self::Mode>,

Encode a sequence extracted from an iterator of slices with a trusted length.

This defaults to using Encoder::encode_sequence and if specialized must implement the same format as would calling that method.

§Examples

Deriving an implementation:

use std::collections::VecDeque;
use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: VecDeque<String>,
}

Implementing manually:

use musli::Encoder;

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let (a, b) = self.data.as_slices();
        encoder.encode_slices(self.data.len(), [a, b])
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_sequence( self, hint: impl SequenceHint, ) -> Result<Self::EncodeSequence, Self::Error>

Encode a sequence with a known length len.

A sequence encodes one element following another and must in some way encode the length of the sequence in the underlying format. It is decoded with Decoder::decode_sequence.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
#[musli(packed)]
struct MyType {
    data: Vec<String>
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut seq = encoder.encode_sequence(self.data.len())?;

        for element in &self.data {
            seq.push(element)?;
        }

        seq.finish_sequence()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}

Encoding a tuple:

use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

struct PackedTuple(u32, [u8; 128]);

impl<M> Encode<M> for PackedTuple {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut tuple = encoder.encode_sequence(2)?;
        tuple.encode_next()?.encode(self.0)?;
        tuple.encode_next()?.encode(&self.1)?;
        tuple.finish_sequence()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_sequence_fn<F>( self, hint: impl SequenceHint, f: F, ) -> Result<(), Self::Error>
where F: FnOnce(&mut Self::EncodeSequence) -> Result<(), Self::Error>,

Encode a sequence using a closure.

§Examples
use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

impl<M> Encode<M> for MyType {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_sequence_fn(self.data.len(), |seq| {
            for element in &self.data {
                seq.push(element)?;
            }

            Ok(())
        })
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}

Encoding a tuple:

use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

struct PackedTuple(u32, [u8; 128]);

impl<M> Encode<M> for PackedTuple {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_sequence_fn(2, |tuple| {
            tuple.encode_next()?.encode(self.0)?;
            tuple.encode_next()?.encode(&self.1)?;
            Ok(())
        })
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_map(self, hint: impl MapHint) -> Result<Self::EncodeMap, Self::Error>

Encode a map with a known length len.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
struct Struct {
    name: String,
    age: u32,
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::MapEncoder;

impl<M> Encode<M> for Struct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut map = encoder.encode_map(2)?;
        map.insert_entry("name", &self.name)?;
        map.insert_entry("age", self.age)?;
        map.finish_map()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_map_fn<F>(self, hint: impl MapHint, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self::EncodeMap) -> Result<(), Self::Error>,

Encode a map using a closure.

§Examples
use musli::{Encode, Encoder};
use musli::en::MapEncoder;

struct Struct {
    name: String,
    age: u32
}

impl<M> Encode<M> for Struct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        encoder.encode_map_fn(2, |map| {
            map.insert_entry("name", &self.name)?;
            map.insert_entry("age", self.age)?;
            Ok(())
        })
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_map_entries( self, hint: impl MapHint, ) -> Result<Self::EncodeMapEntries, Self::Error>

Encode a map through pairs with a known length len.

§Examples
use musli::{Encode, Encoder};
use musli::en::EntriesEncoder;

struct Struct {
    name: String,
    age: u32,
}

impl<M> Encode<M> for Struct {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut m = encoder.encode_map_entries(2)?;

        // Simplified encoding.
        m.insert_entry("name", &self.name)?;

        // Key and value encoding as a stream.
        m.encode_entry_key()?.encode("age")?;
        m.encode_entry_value()?.encode(self.age)?;
        m.finish_entries()
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_variant(self) -> Result<Self::EncodeVariant, Self::Error>

Encode a variant.

§Examples
use musli::Encode;

#[derive(Encode)]
enum Enum {
    UnitVariant,
    TupleVariant(String),
    StructVariant {
        data: String,
        age: u32,
    }
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::{VariantEncoder, SequenceEncoder, MapEncoder};

impl<M> Encode<M> for Enum {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        let mut variant = encoder.encode_variant()?;

        match self {
            Enum::UnitVariant => {
                variant.insert_variant("UnitVariant", ())
            }
            Enum::TupleVariant(data) => {
                variant.encode_tag()?.encode_string("TupleVariant")?;

                let mut tuple = variant.encode_data()?.encode_sequence(1)?;
                tuple.push(data)?;
                tuple.finish_sequence()?;

                variant.finish_variant()
            }
            Enum::StructVariant { data, age } => {
                variant.encode_tag()?.encode_string("StructVariant")?;

                let mut st = variant.encode_data()?.encode_map(2)?;
                st.insert_entry("data", data)?;
                st.insert_entry("age", age)?;
                st.finish_map()?;

                variant.finish_variant()
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_variant_fn<F>(self, f: F) -> Result<(), Self::Error>
where F: FnOnce(&mut Self::EncodeVariant) -> Result<(), Self::Error>,

Encode a variant using a closure.

§Examples
use musli::{Encode, Encoder};
use musli::en::{VariantEncoder, SequenceEncoder, MapEncoder};

enum Enum {
    UnitVariant,
    TupleVariant(String),
    StructVariant {
        data: String,
        age: u32,
    }
}

impl<M> Encode<M> for Enum {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match self {
            Enum::UnitVariant => {
                encoder.encode_variant()?.insert_variant("variant1", ())
            }
            Enum::TupleVariant(data) => {
                encoder.encode_variant_fn(|variant| {
                    variant.encode_tag()?.encode("TupleVariant")?;

                    variant.encode_data()?.encode_sequence_fn(2, |tuple| {
                        tuple.push(data)?;
                        Ok(())
                    })?;

                    Ok(())
                })
            }
            Enum::StructVariant { data, age } => {
                encoder.encode_variant_fn(|variant| {
                    variant.encode_tag()?.encode("variant3")?;

                    variant.encode_data()?.encode_map_fn(2, |st| {
                        st.insert_entry("data", data)?;
                        st.insert_entry("age", age)?;
                        Ok(())
                    })?;

                    Ok(())
                })
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_unit_variant<T>(self, tag: &T) -> Result<(), Self::Error>
where T: ?Sized + Encode<Self::Mode>,

Simplified encoding for a unit variant.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
enum Enum {
    UnitVariant,
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::{VariantEncoder, MapEncoder, SequenceEncoder};

impl<M> Encode<M> for Enum {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match self {
            Enum::UnitVariant => {
                encoder.encode_unit_variant("variant1")
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_sequence_variant<T>( self, tag: &T, hint: impl SequenceHint, ) -> Result<Self::EncodeSequenceVariant, Self::Error>
where T: ?Sized + Encode<Self::Mode>,

Simplified encoding for a tuple variant.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
enum Enum {
    TupleVariant(String),
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::SequenceEncoder;

impl<M> Encode<M> for Enum {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match self {
            Enum::TupleVariant(data) => {
                let mut variant = encoder.encode_sequence_variant("variant2", 1)?;
                variant.push(data)?;
                variant.finish_sequence()
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}
Source

fn encode_map_variant<T>( self, tag: &T, hint: impl MapHint, ) -> Result<Self::EncodeMapVariant, Self::Error>
where T: ?Sized + Encode<Self::Mode>,

Simplified encoding for a struct variant.

§Examples

Deriving an implementation:

use musli::Encode;

#[derive(Encode)]
enum Enum {
    StructVariant {
        data: String,
        age: u32,
    }
}

Implementing manually:

use musli::{Encode, Encoder};
use musli::en::MapEncoder;

impl<M> Encode<M> for Enum {
    type Encode = Self;

    #[inline]
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
    where
        E: Encoder,
    {
        match self {
            Enum::StructVariant { data, age } => {
                let mut variant = encoder.encode_map_variant("variant3", 2)?;
                variant.insert_entry("data", data)?;
                variant.insert_entry("age", age)?;
                variant.finish_map()
            }
        }
    }

    #[inline]
    fn as_encode(&self) -> &Self::Encode {
        self
    }
}

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§