Trait PlatformVersionedDecode 

pub trait PlatformVersionedDecode: Sized {
    // Required method
    fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>(
        decoder: &mut D,
        platform_version: &PlatformVersion,
    ) -> 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<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::decode(decoder)?;
let x = <u8 as bincode::Decode<Context>>::decode(decoder)?;

Required Methods

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> 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.

Implementations on Foreign Types

impl PlatformVersionedDecode for IpAddr

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for SocketAddr

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for bool

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for char

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for f32

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for f64

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for i8

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for i16

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for i32

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for i64

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for i128

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for isize

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for u8

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for u16

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for u32

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for u64

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for u128

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for ()

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( _: &mut D, _platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for usize

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for Box<str>

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for CString

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for String

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for Arc<str>

Available on target_has_atomic=ptr only.

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for Ipv4Addr

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for Ipv6Addr

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for SocketAddrV4

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for SocketAddrV6

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for Duration

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for PathBuf

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for SystemTime

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroI8

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroI16

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroI32

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroI64

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroI128

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroIsize

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroU8

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroU16

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroU32

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroU64

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroU128

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl PlatformVersionedDecode for NonZeroUsize

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, _: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<A> PlatformVersionedDecode for (A,)

where A: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<A, B> PlatformVersionedDecode for (A, B)

where A: PlatformVersionedDecode, B: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<A, B, C> PlatformVersionedDecode for (A, B, C)

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<A, B, C, D> PlatformVersionedDecode for (A, B, C, D)

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode, L: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode, L: PlatformVersionedDecode, M: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode, L: PlatformVersionedDecode, M: PlatformVersionedDecode, N: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode, L: PlatformVersionedDecode, M: PlatformVersionedDecode, N: PlatformVersionedDecode, O: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where A: PlatformVersionedDecode, B: PlatformVersionedDecode, C: PlatformVersionedDecode, D: PlatformVersionedDecode, E: PlatformVersionedDecode, F: PlatformVersionedDecode, G: PlatformVersionedDecode, H: PlatformVersionedDecode, I: PlatformVersionedDecode, J: PlatformVersionedDecode, K: PlatformVersionedDecode, L: PlatformVersionedDecode, M: PlatformVersionedDecode, N: PlatformVersionedDecode, O: PlatformVersionedDecode, P: PlatformVersionedDecode,

fn platform_versioned_decode<DE: Decoder<Context = BincodeContext>>( decoder: &mut DE, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<K, V> PlatformVersionedDecode for BTreeMap<K, V>

where K: PlatformVersionedDecode + Ord, V: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<K, V, S> PlatformVersionedDecode for HashMap<K, V, S>

where K: PlatformVersionedDecode + Eq + Hash, V: PlatformVersionedDecode, S: BuildHasher + Default,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Cow<'_, T>

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

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Bound<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Option<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Box<[T]>

where T: PlatformVersionedDecode + 'static,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Box<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for BinaryHeap<T>

where T: PlatformVersionedDecode + Ord,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for BTreeSet<T>

where T: PlatformVersionedDecode + Ord,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for VecDeque<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Rc<[T]>

where T: PlatformVersionedDecode + 'static,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_versioned: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Rc<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Arc<[T]>

where T: PlatformVersionedDecode + 'static,

Available on target_has_atomic=ptr only.

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Arc<T>

where T: PlatformVersionedDecode,

Available on target_has_atomic=ptr only.

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Vec<T>

where T: PlatformVersionedDecode + 'static,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Cell<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for RefCell<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for PhantomData<T>

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( _: &mut D, _platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Range<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for RangeInclusive<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for Mutex<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T> PlatformVersionedDecode for RwLock<T>

where T: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T, S> PlatformVersionedDecode for HashSet<T, S>

where T: PlatformVersionedDecode + Eq + Hash, S: BuildHasher + Default,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

impl<T, U> PlatformVersionedDecode for Result<T, U>

where T: PlatformVersionedDecode, U: PlatformVersionedDecode,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

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

where T: PlatformVersionedDecode + Sized + 'static,

fn platform_versioned_decode<D: Decoder<Context = BincodeContext>>( decoder: &mut D, platform_version: &PlatformVersion, ) -> Result<Self, DecodeError>

Implementors