Trait Decode 

pub trait Decode<'de, M, A>: Sized
where
    A: Allocator,
{
    const IS_BITWISE_DECODE: bool = false;

    // Required method
    fn decode<D>(decoder: D) -> Result<Self, <D as Decoder<'de>>::Error>
       where D: Decoder<'de, Mode = M, Allocator = A>;
}

Trait governing how types are decoded.

This is typically implemented automatically using the Decode derive.

Examples

use musli::Decode;

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

Implementing manually:

use musli::{Allocator, Decode, Decoder};

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

impl<'de, M, A> Decode<'de, M, A> for MyType
where
    A: Allocator,
{
    #[inline]
    fn decode<D>(decoder: D) -> Result<Self, D::Error>
    where
        D: Decoder<'de>,
    {
        Ok(Self {
            data: decoder.decode()?,
        })
    }
}

Provided Associated Constants

const IS_BITWISE_DECODE: 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 Methods

fn decode<D>(decoder: D) -> Result<Self, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

Decode the current value.

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<'de, A> Decode<'de, Binary, A> for Ipv4Addr

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Ipv4Addr, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, A> Decode<'de, Binary, A> for Ipv6Addr

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Ipv6Addr, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, A> Decode<'de, Binary, A> for SocketAddrV4

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<SocketAddrV4, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = Binary>,

impl<'de, A> Decode<'de, Binary, A> for SocketAddrV6

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<SocketAddrV6, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = Binary>,

impl<'de, A> Decode<'de, Text, A> for Ipv4Addr

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Ipv4Addr, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, A> Decode<'de, Text, A> for Ipv6Addr

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Ipv6Addr, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, A> Decode<'de, Text, A> for SocketAddrV4

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<SocketAddrV4, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, A> Decode<'de, Text, A> for SocketAddrV6

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<SocketAddrV6, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, K, V, A, M> Decode<'de, M, A> for BTreeMap<K, V>

where A: Allocator, K: Decode<'de, M, A> + Ord, V: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<BTreeMap<K, V>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, K: Decode<'de, M, A> + Eq + Hash, V: Decode<'de, M, A>, S: BuildHasher + Default,

Available on crate feature std only.

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<HashMap<K, V, S>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for &'de str

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<&'de str, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for &'de CStr

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<&'de CStr, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for &'de [u8]

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<&'de [u8], <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Cow<'de, str>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Cow<'de, str>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Cow<'de, CStr>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Cow<'de, CStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for IpAddr

where A: Allocator, IpAddrTag: Decode<'de, M, A>, Ipv4Addr: Decode<'de, M, A>, Ipv6Addr: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<IpAddr, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for SocketAddr

where A: Allocator, SocketAddrTag: Decode<'de, M, A>, SocketAddrV4: Decode<'de, M, A>, SocketAddrV6: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<SocketAddr, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for bool

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<bool, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for char

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<char, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for f32

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<f32, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for f64

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<f64, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for i8

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<i8, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for i16

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<i16, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for i32

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<i32, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for i64

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<i64, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for i128

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<i128, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for isize

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<isize, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for u8

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<u8, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for u16

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<u16, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for u32

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<u32, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for u64

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<u64, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for u128

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<u128, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for ()

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<(), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for usize

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<usize, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Box<str>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<str>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M>,

impl<'de, M, A> Decode<'de, M, A> for Box<CStr>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<CStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Box<OsStr>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<OsStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Box<Path>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<Path>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for CString

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<CString, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Rc<str>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<str>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M>,

impl<'de, M, A> Decode<'de, M, A> for Rc<CStr>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<CStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Rc<OsStr>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<OsStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Rc<Path>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<Path>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for String

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<String, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M>,

impl<'de, M, A> Decode<'de, M, A> for Arc<str>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<str>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M>,

impl<'de, M, A> Decode<'de, M, A> for Arc<CStr>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<CStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Arc<OsStr>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<OsStr>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Arc<Path>

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<Path>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<i8>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<i8>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<i16>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<i16>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<i32>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<i32>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<i64>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<i64>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<i128>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<i128>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<isize>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<isize>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<u8>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<u8>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<u16>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<u16>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<u32>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<u32>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<u64>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<u64>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<u128>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<u128>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for NonZero<usize>

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<NonZero<usize>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for RangeFull

where A: Allocator,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<RangeFull, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<bool>

where A: Allocator,

Available on target_has_atomic=8 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<bool>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<i8>

where A: Allocator,

Available on target_has_atomic=8 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<i8>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<i16>

where A: Allocator,

Available on target_has_atomic=16 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<i16>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<i32>

where A: Allocator,

Available on target_has_atomic=32 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<i32>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<i64>

where A: Allocator,

Available on target_has_atomic=64 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<i64>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<isize>

where A: Allocator,

Available on target_has_atomic=ptr only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<isize>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<u8>

where A: Allocator,

Available on target_has_atomic=8 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<u8>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<u16>

where A: Allocator,

Available on target_has_atomic=16 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<u16>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<u32>

where A: Allocator,

Available on target_has_atomic=32 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<u32>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<u64>

where A: Allocator,

Available on target_has_atomic=64 only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<u64>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for Atomic<usize>

where A: Allocator,

Available on target_has_atomic=ptr only.

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<Atomic<usize>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A> Decode<'de, M, A> for OsString

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<OsString, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A> Decode<'de, M, A> for PathBuf

where A: Allocator, PlatformTag: Decode<'de, M, A>,

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

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<PathBuf, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, T0: Decode<'de, M, A>, T1: Decode<'de, M, A>, T2: Decode<'de, M, A>, T3: Decode<'de, M, A>, T4: Decode<'de, M, A>, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, T1: Decode<'de, M, A>, T2: Decode<'de, M, A>, T3: Decode<'de, M, A>, T4: Decode<'de, M, A>, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, T2: Decode<'de, M, A>, T3: Decode<'de, M, A>, T4: Decode<'de, M, A>, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, T3: Decode<'de, M, A>, T4: Decode<'de, M, A>, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

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

where A: Allocator, T4: Decode<'de, M, A>, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where A: Allocator, T5: Decode<'de, M, A>, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where A: Allocator, T6: Decode<'de, M, A>, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T7, T8, T9, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T7, T8, T9, T10, T11, T12, T13, T14, T15)

where A: Allocator, T7: Decode<'de, M, A>, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T7, T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T8, T9, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T8, T9, T10, T11, T12, T13, T14, T15)

where A: Allocator, T8: Decode<'de, M, A>, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T8, T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T9, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T9, T10, T11, T12, T13, T14, T15)

where A: Allocator, T9: Decode<'de, M, A>, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T9, T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T10, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T10, T11, T12, T13, T14, T15)

where A: Allocator, T10: Decode<'de, M, A>, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T10, T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T11, T12, T13, T14, T15> Decode<'de, M, A> for (T11, T12, T13, T14, T15)

where A: Allocator, T11: Decode<'de, M, A>, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T11, T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T12, T13, T14, T15> Decode<'de, M, A> for (T12, T13, T14, T15)

where A: Allocator, T12: Decode<'de, M, A>, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<(T12, T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T13, T14, T15> Decode<'de, M, A> for (T13, T14, T15)

where A: Allocator, T13: Decode<'de, M, A>, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<(T13, T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T14, T15> Decode<'de, M, A> for (T14, T15)

where A: Allocator, T14: Decode<'de, M, A>, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<(T14, T15), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T15> Decode<'de, M, A> for (T15,)

where A: Allocator, T15: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<(T15,), <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Option<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Option<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Box<[T]>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<[T]>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Box<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Box<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for BinaryHeap<T>

where A: Allocator, T: Decode<'de, M, A> + Ord,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<BinaryHeap<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for BTreeSet<T>

where A: Allocator, T: Decode<'de, M, A> + Ord,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<BTreeSet<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for VecDeque<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<VecDeque<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Rc<[T]>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<[T]>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Rc<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Rc<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Arc<[T]>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<[T]>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Arc<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Arc<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for Vec<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Vec<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for PhantomData<T>

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

fn decode<D>(decoder: D) -> Result<PhantomData<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de>,

impl<'de, M, A, T> Decode<'de, M, A> for Range<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Range<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for RangeFrom<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<RangeFrom<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for RangeInclusive<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<RangeInclusive<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for RangeTo<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<RangeTo<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T> Decode<'de, M, A> for RangeToInclusive<T>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>( decoder: D, ) -> Result<RangeToInclusive<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T, S> Decode<'de, M, A> for HashSet<T, S>

where A: Allocator, T: Decode<'de, M, A> + Eq + Hash, S: BuildHasher + Default,

Available on crate feature std only.

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<HashSet<T, S>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, A, T, U> Decode<'de, M, A> for Result<T, U>

where A: Allocator, T: Decode<'de, M, A>, U: Decode<'de, M, A>, ResultTag: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

fn decode<D>(decoder: D) -> Result<Result<T, U>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, T, A> Decode<'de, M, A> for Saturating<T>

where T: Decode<'de, M, A>, A: Allocator,

const IS_BITWISE_DECODE: bool = T::IS_BITWISE_DECODE

fn decode<D>(decoder: D) -> Result<Saturating<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, T, A> Decode<'de, M, A> for Wrapping<T>

where T: Decode<'de, M, A>, A: Allocator,

const IS_BITWISE_DECODE: bool = T::IS_BITWISE_DECODE

fn decode<D>(decoder: D) -> Result<Wrapping<T>, <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

impl<'de, M, T, A, const N: usize> Decode<'de, M, A> for [T; N]

where T: Decode<'de, M, A>, A: Allocator,

const IS_BITWISE_DECODE: bool

fn decode<D>(decoder: D) -> Result<[T; N], <D as Decoder<'de>>::Error>

where D: Decoder<'de, Mode = M, Allocator = A>,

Implementors

impl<'de, M, A> Decode<'de, M, A> for musli::alloc::String<A>

where A: Allocator,

Decode implementation for a Müsli-allocated String.

Examples

use musli::alloc::String;
use musli::{Allocator, Decode};

#[derive(Decode)]
struct Struct<A> where A: Allocator {
    field: String<A>
}

const IS_BITWISE_DECODE: bool = false

impl<'de, M, A> Decode<'de, M, A> for Sequence<()>

where A: Allocator,

const IS_BITWISE_DECODE: bool = true

impl<'de, M, A, T> Decode<'de, M, A> for musli::alloc::Vec<T, A>

where A: Allocator, T: Decode<'de, M, A>,

const IS_BITWISE_DECODE: bool = false

impl<'de, T, A> Decode<'de, Binary, A> for Bytes<T>

where A: Allocator, T: EncodeBytes<Binary> + DecodeBytes<'de, Binary, A>,

const IS_BITWISE_DECODE: bool = false

impl<'de, T, A> Decode<'de, Binary, A> for Packed<T>

where A: Allocator, T: EncodePacked<Binary> + DecodePacked<'de, Binary, A>,

const IS_BITWISE_DECODE: bool = false

impl<'de, T, A> Decode<'de, Text, A> for Bytes<T>

where A: Allocator, T: EncodeBytes<Text> + DecodeBytes<'de, Text, A>,

const IS_BITWISE_DECODE: bool = false

impl<'de, T, A> Decode<'de, Text, A> for Packed<T>

where A: Allocator, T: EncodePacked<Text> + DecodePacked<'de, Text, A>,

const IS_BITWISE_DECODE: bool = false