Trait Encode 

pub trait Encode<M> {
    type Encode: ?Sized + Encode<M>;

    const IS_BITWISE_ENCODE: bool = false;

    // Required methods
    fn encode<E>(&self, encoder: E) -> Result<(), E::Error>
       where E: Encoder<Mode = M>;
    fn as_encode(&self) -> &Self::Encode;

    // Provided method
    fn size_hint(&self) -> Option<usize> { ... }
}

Trait governing how types are encoded.

This is typically implemented automatically using the Encode derive.

Examples

use musli::Encode;

#[derive(Encode)]
struct MyType {
    data: [u32; 8],
}

Implementing manually:

use musli::{Encode, Encoder};

struct MyType {
    data: [u32; 8],
}

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

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

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

Provided Associated Constants

const IS_BITWISE_ENCODE: bool = false

Whether the type is packed. Packed types can be bitwise copied if the representation of the serialization format is identical to the memory layout of the type.

Note that setting this to true has safety implications, since it implies that assuming the type is correctly aligned it can be validly bitwise copied when encoded. Setting it to false is always safe.

This being set to true also implies that the type is Copy, and must not have a Drop implementation.

Required Associated Types

type Encode: ?Sized + Encode<M>

The underlying type being encoded.

This is used to “peek through” types like references being encoded.

Required Methods

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

Encode the given output.

fn as_encode(&self) -> &Self::Encode

Coerce into the underlying value being encoded.

Provided Methods

fn size_hint(&self) -> Option<usize>

The number of fields in the type.

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.

Implementations on Foreign Types

impl Encode<Binary> for Ipv4Addr

const IS_BITWISE_ENCODE: bool = false

type Encode = Ipv4Addr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl Encode<Binary> for Ipv6Addr

const IS_BITWISE_ENCODE: bool = false

type Encode = Ipv6Addr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Binary>,

fn as_encode(&self) -> &Self::Encode

impl Encode<Binary> for SocketAddrV4

const IS_BITWISE_ENCODE: bool = false

type Encode = SocketAddrV4

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Binary>,

fn as_encode(&self) -> &Self::Encode

impl Encode<Binary> for SocketAddrV6

const IS_BITWISE_ENCODE: bool = false

type Encode = SocketAddrV6

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Binary>,

fn as_encode(&self) -> &Self::Encode

impl Encode<Text> for Ipv4Addr

const IS_BITWISE_ENCODE: bool = false

type Encode = Ipv4Addr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl Encode<Text> for Ipv6Addr

const IS_BITWISE_ENCODE: bool = false

type Encode = Ipv6Addr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Text>,

fn as_encode(&self) -> &Self::Encode

impl Encode<Text> for SocketAddrV4

const IS_BITWISE_ENCODE: bool = false

type Encode = SocketAddrV4

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Text>,

fn as_encode(&self) -> &Self::Encode

impl Encode<Text> for SocketAddrV6

const IS_BITWISE_ENCODE: bool = false

type Encode = SocketAddrV6

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = Text>,

fn as_encode(&self) -> &Self::Encode

impl<'de, M, K, V> Encode<M> for BTreeMap<K, V>

where K: Encode<M>, V: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = BTreeMap<K, V>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<'de, M, K, V, S> Encode<M> for HashMap<K, V, S>

where K: Encode<M>, V: Encode<M>, S: BuildHasher + Default,

Available on crate feature std only.

const IS_BITWISE_ENCODE: bool = false

type Encode = HashMap<K, V, S>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for Cow<'_, str>

const IS_BITWISE_ENCODE: bool = false

type Encode = str

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for Cow<'_, CStr>

const IS_BITWISE_ENCODE: bool = false

type Encode = CStr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for IpAddr

where IpAddrTag: Encode<M>, Ipv4Addr: Encode<M>, Ipv6Addr: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = IpAddr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for SocketAddr

where SocketAddrTag: Encode<M>, SocketAddrV4: Encode<M>, SocketAddrV6: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = SocketAddr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for bool

const IS_BITWISE_ENCODE: bool = true

type Encode = bool

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for char

const IS_BITWISE_ENCODE: bool = true

type Encode = char

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for f32

const IS_BITWISE_ENCODE: bool = true

type Encode = f32

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for f64

const IS_BITWISE_ENCODE: bool = true

type Encode = f64

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for i8

const IS_BITWISE_ENCODE: bool = true

type Encode = i8

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for i16

const IS_BITWISE_ENCODE: bool = true

type Encode = i16

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for i32

const IS_BITWISE_ENCODE: bool = true

type Encode = i32

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for i64

const IS_BITWISE_ENCODE: bool = true

type Encode = i64

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for i128

const IS_BITWISE_ENCODE: bool = true

type Encode = i128

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for isize

const IS_BITWISE_ENCODE: bool = true

type Encode = isize

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for str

const IS_BITWISE_ENCODE: bool = false

type Encode = str

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for u8

const IS_BITWISE_ENCODE: bool = true

type Encode = u8

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for u16

const IS_BITWISE_ENCODE: bool = true

type Encode = u16

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for u32

const IS_BITWISE_ENCODE: bool = true

type Encode = u32

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for u64

const IS_BITWISE_ENCODE: bool = true

type Encode = u64

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for u128

const IS_BITWISE_ENCODE: bool = true

type Encode = u128

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for ()

const IS_BITWISE_ENCODE: bool = true

type Encode = ()

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for usize

const IS_BITWISE_ENCODE: bool = true

type Encode = usize

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for CString

const IS_BITWISE_ENCODE: bool = false

type Encode = CStr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for String

const IS_BITWISE_ENCODE: bool = false

type Encode = str

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for CStr

const IS_BITWISE_ENCODE: bool = false

type Encode = CStr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for RangeFull

const IS_BITWISE_ENCODE: bool = false

type Encode = RangeFull

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for OsStr

where PlatformTag: Encode<M>,

Available on crate feature std and (Unix or Windows) only.

const IS_BITWISE_ENCODE: bool = false

type Encode = OsStr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for OsString

where PlatformTag: Encode<M>,

Available on crate feature std and (Unix or Windows) only.

const IS_BITWISE_ENCODE: bool = false

type Encode = OsStr

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for Path

where PlatformTag: Encode<M>,

Available on crate feature std and (Unix or Windows) only.

const IS_BITWISE_ENCODE: bool = false

type Encode = Path

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for PathBuf

where PlatformTag: Encode<M>,

Available on crate feature std and (Unix or Windows) only.

const IS_BITWISE_ENCODE: bool = false

type Encode = PathBuf

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroI8

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<i8>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroI16

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<i16>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroI32

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<i32>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroI64

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<i64>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroI128

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<i128>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroIsize

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<isize>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroU8

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<u8>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroU16

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<u16>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroU32

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<u32>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroU64

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<u64>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroU128

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<u128>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M> Encode<M> for NonZeroUsize

const IS_BITWISE_ENCODE: bool = true

type Encode = NonZero<usize>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<M, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: Encode<M>, T1: Encode<M>, T2: Encode<M>, T3: Encode<M>, T4: Encode<M>, T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T1: Encode<M>, T2: Encode<M>, T3: Encode<M>, T4: Encode<M>, T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T2: Encode<M>, T3: Encode<M>, T4: Encode<M>, T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T3: Encode<M>, T4: Encode<M>, T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T4: Encode<M>, T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T5: Encode<M>, T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T6: Encode<M>, T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T7, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T7: Encode<M>, T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T7, T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T8, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T8, T9, T10, T11, T12, T13, T14, T15)

where T8: Encode<M>, T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T8, T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T9, T10, T11, T12, T13, T14, T15> Encode<M> for (T9, T10, T11, T12, T13, T14, T15)

where T9: Encode<M>, T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T9, T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T10, T11, T12, T13, T14, T15> Encode<M> for (T10, T11, T12, T13, T14, T15)

where T10: Encode<M>, T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T10, T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T11, T12, T13, T14, T15> Encode<M> for (T11, T12, T13, T14, T15)

where T11: Encode<M>, T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T11, T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T12, T13, T14, T15> Encode<M> for (T12, T13, T14, T15)

where T12: Encode<M>, T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T12, T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T13, T14, T15> Encode<M> for (T13, T14, T15)

where T13: Encode<M>, T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T13, T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T14, T15> Encode<M> for (T14, T15)

where T14: Encode<M>, T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T14, T15)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T15> Encode<M> for (T15,)

where T15: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = (T15,)

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for [T]

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = [T]

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for Box<T>

where T: ?Sized + Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = T

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for BinaryHeap<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = BinaryHeap<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for BTreeSet<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = BTreeSet<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for VecDeque<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = VecDeque<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for Rc<T>

where T: ?Sized + Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = T

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for Arc<T>

where T: ?Sized + Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = T

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for Vec<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = Vec<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for Range<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = Range<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for RangeFrom<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = RangeFrom<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for RangeInclusive<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = RangeInclusive<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for RangeTo<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = RangeTo<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T> Encode<M> for RangeToInclusive<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = RangeToInclusive<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T, S> Encode<M> for HashSet<T, S>

where T: Encode<M>, S: BuildHasher + Default,

Available on crate feature std only.

const IS_BITWISE_ENCODE: bool = false

type Encode = HashSet<T, S>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<M, T, const N: usize> Encode<M> for [T; N]

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool

type Encode = [T; N]

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<T, M> Encode<M> for Option<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = Option<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<T, M> Encode<M> for &T

where T: ?Sized + Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = T

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn size_hint(&self) -> Option<usize>

fn as_encode(&self) -> &Self::Encode

impl<T, M> Encode<M> for &mut T

where T: ?Sized + Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = T

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn size_hint(&self) -> Option<usize>

fn as_encode(&self) -> &Self::Encode

impl<T, M> Encode<M> for PhantomData<T>

const IS_BITWISE_ENCODE: bool = true

type Encode = PhantomData<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder,

fn as_encode(&self) -> &Self::Encode

impl<T, M> Encode<M> for Wrapping<T>

where T: Encode<M>,

const IS_BITWISE_ENCODE: bool = T::IS_BITWISE_ENCODE

type Encode = Wrapping<T>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

impl<T, U, M> Encode<M> for Result<T, U>

where T: Encode<M>, U: Encode<M>, ResultTag: Encode<M>,

const IS_BITWISE_ENCODE: bool = false

type Encode = Result<T, U>

fn encode<E>(&self, encoder: E) -> Result<(), E::Error>

where E: Encoder<Mode = M>,

fn as_encode(&self) -> &Self::Encode

Implementors

impl<M, A> Encode<M> for musli_core::alloc::String<A>

where A: Allocator,

const IS_BITWISE_ENCODE: bool = false

type Encode = str

impl<M, T, A> Encode<M> for musli_core::alloc::Vec<T, A>

where T: Encode<M>, A: Allocator,

const IS_BITWISE_ENCODE: bool = false

type Encode = Vec<T, A>