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", so this trait is not object safe.

Implementations on Foreign Types

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 SocketAddr

fn decode<D>(decoder: &mut D) -> Result<SocketAddr, 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 ()

fn decode<D>(_: &mut D) -> Result<(), 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<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 Rc<str>

fn decode<D>(decoder: &mut D) -> Result<Rc<str>, 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 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 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 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 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 AtomicBool

Available on target_has_atomic=8 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicI8

Available on target_has_atomic=8 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicI16

Available on target_has_atomic=16 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicI32

Available on target_has_atomic=32 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicI64

Available on target_has_atomic=64 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicIsize

Available on target_has_atomic=ptr only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicU8

Available on target_has_atomic=8 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicU16

Available on target_has_atomic=16 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicU32

Available on target_has_atomic=32 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicU64

Available on target_has_atomic=64 only.

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

where D: Decoder,

impl<Context> Decode<Context> for AtomicUsize

Available on target_has_atomic=ptr only.

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

where D: Decoder,

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 PathBuf

fn decode<D>(decoder: &mut D) -> Result<PathBuf, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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 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 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 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 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 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 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 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 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 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 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 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 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 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 PhantomData<T>

fn decode<D>(_: &mut D) -> Result<PhantomData<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, 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 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 RwLock<T>

where T: Decode<Context>,

fn decode<D>(decoder: &mut D) -> Result<RwLock<T>, 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<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

impl<Context> Decode<Context> for Change<'static, String>

impl<Context> Decode<Context> for Moment

impl<__Context> Decode<__Context> for Selection

impl<__Context> Decode<__Context> for VPoint

impl<__Context> Decode<__Context> for Point

impl<__Context> Decode<__Context> for TwoPoints