Trait bincode::de::Decode

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

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

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 implement Decode for your type, the base trait BorrowDecode is automatically implemented.

This trait will be automatically implemented 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 bincode::Decode for Entity {
    fn decode<D: bincode::de::Decoder>(
        decoder: &mut D,
    ) -> core::result::Result<Self, bincode::error::DecodeError> {
        Ok(Self {
            x: bincode::Decode::decode(decoder)?,
            y: bincode::Decode::decode(decoder)?,
        })
    }
}
impl<'de> bincode::BorrowDecode<'de> for Entity {
    fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(
        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::decode(decoder)?;
let x = <u8 as bincode::Decode>::decode(decoder)?;

Required Methods

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

Attempt to decode this type with the given Decode.

Implementations on Foreign Types

impl Decode for NonZeroI32

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

impl Decode for AtomicI16

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

impl Decode for AtomicU16

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

impl Decode for u16

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

impl Decode for NonZeroI8

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

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

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

impl Decode for Duration

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

impl<T> Decode for Arc<[T]>where T: Decode + 'static,

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

impl Decode for SystemTime

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

impl<T> Decode for RefCell<T>where T: Decode,

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

impl<T> Decode for Arc<T>where T: Decode,

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

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

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

impl Decode for i16

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

impl Decode for u64

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

impl<K, V, S> Decode for HashMap<K, V, S>where K: Decode + Eq + Hash, V: Decode, S: BuildHasher + Default,

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

impl<T> Decode for Rc<[T]>where T: Decode + 'static,

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

impl<T> Decode for RwLock<T>where T: Decode,

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

impl Decode for i128

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

impl<T, S> Decode for HashSet<T, S>where T: Decode + Eq + Hash, S: BuildHasher + Default,

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

impl Decode for NonZeroU128

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

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

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

impl Decode for Ipv4Addr

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

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

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

impl Decode for i32

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

impl<T> Decode for BTreeSet<T>where T: Decode + Ord,

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

impl<K, V> Decode for BTreeMap<K, V>where K: Decode + Ord, V: Decode,

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

impl Decode for NonZeroU64

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

impl Decode for NonZeroI64

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

impl<T, const N: usize> Decode for [T; N]where T: Decode + Sized + 'static,

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

impl<T> Decode for Box<T>where T: Decode,

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

impl<T> Decode for Range<T>where T: Decode,

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

impl<T> Decode for Rc<T>where T: Decode,

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

impl Decode for AtomicU32

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

impl Decode for PathBuf

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

impl<A> Decode for (A,)where A: Decode,

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

impl Decode for f64

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

impl Decode for char

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

impl Decode for SocketAddr

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

impl Decode for NonZeroIsize

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

impl Decode for String

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

impl Decode for Arc<str>

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

impl<T> Decode for PhantomData<T>

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

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

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

impl<A, B, C> Decode for (A, B, C)where A: Decode, B: Decode, C: Decode,

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

impl Decode for bool

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

impl Decode for u8

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

impl Decode for CString

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

impl Decode for AtomicI64

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

impl Decode for NonZeroU16

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

impl Decode for AtomicBool

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

impl Decode for NonZeroI16

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

impl Decode for usize

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

impl Decode for u128

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

impl Decode for NonZeroU8

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

impl Decode for ()

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

impl Decode for AtomicI32

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

impl<T> Decode for Cell<T>where T: Decode,

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

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

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

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

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

impl Decode for u32

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

impl Decode for AtomicUsize

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

impl Decode for SocketAddrV4

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

impl Decode for i8

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

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

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

impl<T> Decode for Bound<T>where T: Decode,

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

impl Decode for Box<str>

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

impl Decode for AtomicU64

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

impl<'cow, T> Decode for Cow<'cow, T>where T: ToOwned + ?Sized, <T as ToOwned>::Owned: Decode,

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

impl Decode for isize

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

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

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

impl<T, U> Decode for Result<T, U>where T: Decode, U: Decode,

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

impl<T> Decode for Vec<T>where T: Decode + 'static,

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

impl Decode for SocketAddrV6

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

impl<T> Decode for VecDeque<T>where T: Decode,

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

impl Decode for NonZeroUsize

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

impl Decode for f32

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

impl<T> Decode for Option<T>where T: Decode,

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

impl Decode for AtomicU8

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

impl<T> Decode for BinaryHeap<T>where T: Decode + Ord,

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

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

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

impl<T> Decode for Mutex<T>where T: Decode,

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

impl Decode for i64

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

impl Decode for IpAddr

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

impl Decode for AtomicI8

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

impl<A, B> Decode for (A, B)where A: Decode, B: Decode,

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

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

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

impl<T> Decode for RangeInclusive<T>where T: Decode,

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

impl<T> Decode for Box<[T]>where T: Decode + 'static,

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

impl Decode for AtomicIsize

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

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

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

impl Decode for NonZeroI128

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

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

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

impl Decode for NonZeroU32

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

impl Decode for Ipv6Addr

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

Implementors

impl<T> Decode for Compat<T>where T: DeserializeOwned,

Available on crate feature serde only.