Trait Decode 

pub trait Decode<Context>: Sized {
    // Required method
    fn decode<D>(decoder: &mut D) -> Result<Self, DecodeError>
       where D: Decoder<Context = Context>;
}

Trait that makes a type able to be decoded, akin to serde’s DeserializeOwned trait.

Some types may require specific contexts. For example, to decode arena-based collections, an arena allocator must be provided as a context. In these cases, the context type Context should be specified or bounded.

This trait should be implemented for types which do not have references to data in the reader. For types that contain e.g. &str and &[u8], implement BorrowDecode instead.

Whenever you derive Decode for your type, the base trait BorrowDecode is automatically implemented.

This trait will be automatically implemented with unbounded Context if you enable the derive feature and add #[derive(bincode::Decode)] to your type. Note that if the type contains any lifetimes, BorrowDecode will be implemented instead.

Implementing this trait manually

If you want to implement this trait for your type, the easiest way is to add a #[derive(bincode::Decode)], build and check your target/generated/bincode/ folder. This should generate a <Struct name>_Decode.rs file.

For this struct:

struct Entity {
    pub x: f32,
    pub y: f32,
}

It will look something like:

impl<Context> bincode::Decode<Context> for Entity {
    fn decode<D: bincode::de::Decoder<Context = Context>>(
        decoder: &mut D,
    ) -> core::result::Result<Self, bincode::error::DecodeError> {
        Ok(Self {
            x: bincode::Decode::decode(decoder)?,
            y: bincode::Decode::decode(decoder)?,
        })
    }
}
impl<'de, Context> bincode::BorrowDecode<'de, Context> for Entity {
    fn borrow_decode<D: bincode::de::BorrowDecoder<'de, Context = Context>>(
        decoder: &mut D,
    ) -> core::result::Result<Self, bincode::error::DecodeError> {
        Ok(Self {
            x: bincode::BorrowDecode::borrow_decode(decoder)?,
            y: bincode::BorrowDecode::borrow_decode(decoder)?,
        })
    }
}

From here you can add/remove fields, or add custom logic.

To get specific integer types, you can use:

let x: u8 = bincode::Decode::<Context>::decode(decoder)?;
let x = <u8 as bincode::Decode::<Context>>::decode(decoder)?;

You can use Context to require contexts for decoding a type:

use bincode::de::Decoder;
use bincode::error::DecodeError;
struct BytesInArena<'a>(bumpalo::collections::Vec<'a, u8>);
impl<'a> bincode::Decode<&'a bumpalo::Bump> for BytesInArena<'a> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
        todo!()
    }

Required Methods

fn decode<D>(decoder: &mut D) -> Result<Self, DecodeError>

where D: Decoder<Context = Context>,

Attempt to decode this type with the given Decode.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>, L: Decode<Context>, M: Decode<Context>, N: Decode<Context>, O: Decode<Context>, P: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>, L: Decode<Context>, M: Decode<Context>, N: Decode<Context>, O: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>, L: Decode<Context>, M: Decode<Context>, N: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J, K, L, M> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>, L: Decode<Context>, M: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J, K, L> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>, L: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J, K> Decode<Context> for (A, B, C, D, E, F, G, H, I, J, K)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>, K: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I, J> Decode<Context> for (A, B, C, D, E, F, G, H, I, J)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>, J: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I, J), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H, I> Decode<Context> for (A, B, C, D, E, F, G, H, I)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>, I: Decode<Context>,

fn decode<DE>( decoder: &mut DE, ) -> Result<(A, B, C, D, E, F, G, H, I), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G, H> Decode<Context> for (A, B, C, D, E, F, G, H)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>, H: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C, D, E, F, G, H), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F, G> Decode<Context> for (A, B, C, D, E, F, G)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>, G: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C, D, E, F, G), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E, F> Decode<Context> for (A, B, C, D, E, F)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>, F: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C, D, E, F), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D, E> Decode<Context> for (A, B, C, D, E)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>, E: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C, D, E), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C, D> Decode<Context> for (A, B, C, D)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>, D: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C, D), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B, C> Decode<Context> for (A, B, C)

where A: Decode<Context>, B: Decode<Context>, C: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B, C), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A, B> Decode<Context> for (A, B)

where A: Decode<Context>, B: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A, B), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, A> Decode<Context> for (A,)

where A: Decode<Context>,

fn decode<DE>(decoder: &mut DE) -> Result<(A,), DecodeError>

where DE: Decoder<Context = Context>,

impl<Context, K, V, S> Decode<Context> for HashMap<K, V, S>

where K: Decode<Context> + Eq + Hash, V: Decode<Context>, S: BuildHasher + Default,

fn decode<D>(decoder: &mut D) -> Result<HashMap<K, V, S>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, K, V> Decode<Context> for BTreeMap<K, V>

where K: Decode<Context> + Ord, V: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<BTreeMap<K, V>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T, S> Decode<Context> for HashSet<T, S>

where T: Decode<Context> + Eq + Hash, S: BuildHasher + Default,

fn decode<D>(decoder: &mut D) -> Result<HashSet<T, S>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T, U> Decode<Context> for Result<T, U>

where T: Decode<Context>, U: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Result<T, U>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T, const N: usize> Decode<Context> for [T; N]

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<[T; N], DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Arc<T>

where T: Decode<Context>,

Available on target_has_atomic=ptr only.

fn decode<D>(decoder: &mut D) -> Result<Arc<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Arc<[T]>

where T: Decode<Context> + 'static,

Available on target_has_atomic=ptr only.

fn decode<D>(decoder: &mut D) -> Result<Arc<[T]>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for BTreeSet<T>

where T: Decode<Context> + Ord,

fn decode<D>(decoder: &mut D) -> Result<BTreeSet<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for BinaryHeap<T>

where T: Decode<Context> + Ord,

fn decode<D>(decoder: &mut D) -> Result<BinaryHeap<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Box<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Box<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Box<[T]>

where T: Decode<Context> + 'static,

fn decode<D>(decoder: &mut D) -> Result<Box<[T]>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Cell<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Cell<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Cow<'_, T>

where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Cow<'_, T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Mutex<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Mutex<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Option<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Option<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for PhantomData<T>

fn decode<D>(_: &mut D) -> Result<PhantomData<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Range<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Range<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for RangeInclusive<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<RangeInclusive<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Rc<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Rc<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Rc<[T]>

where T: Decode<Context> + 'static,

fn decode<D>(decoder: &mut D) -> Result<Rc<[T]>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for RefCell<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<RefCell<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Reverse<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Reverse<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for RwLock<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<RwLock<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Vec<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Vec<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for VecDeque<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<VecDeque<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context, T> Decode<Context> for Wrapping<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Wrapping<T>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for ()

fn decode<D>(_: &mut D) -> Result<(), DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Arc<str>

Available on target_has_atomic=ptr only.

fn decode<D>(decoder: &mut D) -> Result<Arc<str>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Atomic<bool>

Available on target_has_atomic=8 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<bool>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<i8>

Available on target_has_atomic=8 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<i8>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<i16>

Available on target_has_atomic=16 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<i16>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<i32>

Available on target_has_atomic=32 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<i32>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<i64>

Available on target_has_atomic=64 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<i64>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<isize>

Available on target_has_atomic=ptr only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<isize>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<u8>

Available on target_has_atomic=8 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<u8>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<u16>

Available on target_has_atomic=16 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<u16>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<u32>

Available on target_has_atomic=32 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<u32>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<u64>

Available on target_has_atomic=64 only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<u64>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Atomic<usize>

Available on target_has_atomic=ptr only.

fn decode<D>(decoder: &mut D) -> Result<Atomic<usize>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for Box<str>

fn decode<D>(decoder: &mut D) -> Result<Box<str>, DecodeError>

where D: Decoder,

impl<Context> Decode<Context> for CString

fn decode<D>(decoder: &mut D) -> Result<CString, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Duration

fn decode<D>(decoder: &mut D) -> Result<Duration, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for IpAddr

fn decode<D>(decoder: &mut D) -> Result<IpAddr, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Ipv4Addr

fn decode<D>(decoder: &mut D) -> Result<Ipv4Addr, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Ipv6Addr

fn decode<D>(decoder: &mut D) -> Result<Ipv6Addr, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<i8>

fn decode<D>(decoder: &mut D) -> Result<NonZero<i8>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<i16>

fn decode<D>(decoder: &mut D) -> Result<NonZero<i16>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<i32>

fn decode<D>(decoder: &mut D) -> Result<NonZero<i32>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<i64>

fn decode<D>(decoder: &mut D) -> Result<NonZero<i64>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<i128>

fn decode<D>(decoder: &mut D) -> Result<NonZero<i128>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<isize>

fn decode<D>(decoder: &mut D) -> Result<NonZero<isize>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<u8>

fn decode<D>(decoder: &mut D) -> Result<NonZero<u8>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<u16>

fn decode<D>(decoder: &mut D) -> Result<NonZero<u16>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<u32>

fn decode<D>(decoder: &mut D) -> Result<NonZero<u32>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<u64>

fn decode<D>(decoder: &mut D) -> Result<NonZero<u64>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<u128>

fn decode<D>(decoder: &mut D) -> Result<NonZero<u128>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for NonZero<usize>

fn decode<D>(decoder: &mut D) -> Result<NonZero<usize>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for PathBuf

fn decode<D>(decoder: &mut D) -> Result<PathBuf, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for Rc<str>

fn decode<D>(decoder: &mut D) -> Result<Rc<str>, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for SocketAddr

fn decode<D>(decoder: &mut D) -> Result<SocketAddr, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for SocketAddrV4

fn decode<D>(decoder: &mut D) -> Result<SocketAddrV4, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for SocketAddrV6

fn decode<D>(decoder: &mut D) -> Result<SocketAddrV6, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for String

fn decode<D>(decoder: &mut D) -> Result<String, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for SystemTime

fn decode<D>(decoder: &mut D) -> Result<SystemTime, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for bool

fn decode<D>(decoder: &mut D) -> Result<bool, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for char

fn decode<D>(decoder: &mut D) -> Result<char, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for f32

fn decode<D>(decoder: &mut D) -> Result<f32, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for f64

fn decode<D>(decoder: &mut D) -> Result<f64, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for i8

fn decode<D>(decoder: &mut D) -> Result<i8, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for i16

fn decode<D>(decoder: &mut D) -> Result<i16, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for i32

fn decode<D>(decoder: &mut D) -> Result<i32, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for i64

fn decode<D>(decoder: &mut D) -> Result<i64, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for i128

fn decode<D>(decoder: &mut D) -> Result<i128, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for isize

fn decode<D>(decoder: &mut D) -> Result<isize, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for u8

fn decode<D>(decoder: &mut D) -> Result<u8, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for u16

fn decode<D>(decoder: &mut D) -> Result<u16, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for u32

fn decode<D>(decoder: &mut D) -> Result<u32, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for u64

fn decode<D>(decoder: &mut D) -> Result<u64, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for u128

fn decode<D>(decoder: &mut D) -> Result<u128, DecodeError>

where D: Decoder<Context = Context>,

impl<Context> Decode<Context> for usize

fn decode<D>(decoder: &mut D) -> Result<usize, DecodeError>

where D: Decoder<Context = Context>,

impl<T, Context> Decode<Context> for Bound<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<Bound<T>, DecodeError>

where D: Decoder<Context = Context>,

Implementors