Trait Decode

Source

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

Expand description

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§

Source

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

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.

Trait Decode Copy item path

§Implementing this trait manually

Required Methods§

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

Dyn Compatibility§

Implementations on Foreign Types§

impl<Context> Decode<Context> for IpAddr

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

impl<Context> Decode<Context> for SocketAddr

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

impl<Context> Decode<Context> for bool

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

impl<Context> Decode<Context> for char

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

impl<Context> Decode<Context> for f32

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

impl<Context> Decode<Context> for f64

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

impl<Context> Decode<Context> for i8

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

impl<Context> Decode<Context> for i16

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

impl<Context> Decode<Context> for i32

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

impl<Context> Decode<Context> for i64

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

impl<Context> Decode<Context> for i128

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

impl<Context> Decode<Context> for isize

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

impl<Context> Decode<Context> for u8

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

impl<Context> Decode<Context> for u16

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

impl<Context> Decode<Context> for u32

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

impl<Context> Decode<Context> for u64

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

impl<Context> Decode<Context> for u128

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

impl<Context> Decode<Context> for ()

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

impl<Context> Decode<Context> for usize

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

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

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

impl<Context> Decode<Context> for CString

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

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

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

impl<Context> Decode<Context> for String

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

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

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

impl<Context> Decode<Context> for Ipv4Addr

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

impl<Context> Decode<Context> for Ipv6Addr

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

impl<Context> Decode<Context> for SocketAddrV4

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

impl<Context> Decode<Context> for SocketAddrV6

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

impl<Context> Decode<Context> for AtomicBool

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

impl<Context> Decode<Context> for AtomicI8

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

impl<Context> Decode<Context> for AtomicI16

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

impl<Context> Decode<Context> for AtomicI32

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

impl<Context> Decode<Context> for AtomicI64

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

impl<Context> Decode<Context> for AtomicIsize

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

impl<Context> Decode<Context> for AtomicU8

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

impl<Context> Decode<Context> for AtomicU16

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

impl<Context> Decode<Context> for AtomicU32

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

Trait Decode

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

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

impl<Context, A, B, C> Decode<Context> for (A, B, C)
where A: Decode<Context>, B: Decode<Context>, C: Decode<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>,

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>,

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>,

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>,

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>,

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>,