Trait musli::de::Decode

pub trait Decode<'de, M>: Sized {
    // Required method
    fn decode<D>(
        cx: &<D as Decoder<'de>>::Cx,
        decoder: D
    ) -> Result<Self, <D as Decoder<'de>>::Error>
       where D: Decoder<'de, Mode = M>;
}

Trait governing how types are decoded.

This is typically implemented automatically using the Decode derive.

Examples

use musli::Decode;

#[derive(Decode)]
struct MyType {
    data: [u8; 128],
}

Implementing manually:

use musli::{Decode, Decoder};

struct MyType {
    data: [u8; 128],
}

impl<'de, M> Decode<'de, M> for MyType {
    fn decode<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
    where
        D: Decoder<'de>,
    {
        Ok(Self {
            data: decoder.decode_array()?,
        })
    }
}

Required Methods

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

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

Decode the given input.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'de> Decode<'de, Binary> for Ipv4Addr

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

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

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

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

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

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

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

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

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

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

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

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

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

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

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

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

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

where D: Decoder<'de>,

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

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

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

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

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

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

where D: Decoder<'de>,

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

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

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

impl<'de, M> Decode<'de, M> for AtomicBool

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicI8

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicI16

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicI32

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicI64

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicIsize

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicU8

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicU16

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicU32

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicU64

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

where D: Decoder<'de>,

impl<'de, M> Decode<'de, M> for AtomicUsize

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

where D: Decoder<'de>,

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

where PlatformTag: Decode<'de, M>,

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

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

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

where PlatformTag: Decode<'de, M>,

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

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

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

fn decode<D>( _: &<D as Decoder<'de>>::Cx, 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>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where T15: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

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

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

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

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

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

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

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

where D: Decoder<'de>,

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

where T: Decode<'de, M>,

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

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

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

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

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

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

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

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

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

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

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

where T: Decode<'de, M>,

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

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

Implementors

impl<'de, M> Decode<'de, M> for Value

Available on crate feature value only.

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

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

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

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

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

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

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

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

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