Trait workflow_serializer::prelude::BorshDeserialize

pub trait BorshDeserialize: Sized {
    // Required method
    fn deserialize_reader<R>(reader: &mut R) -> Result<Self, Error>
       where R: Read;

    // Provided methods
    fn deserialize(buf: &mut &[u8]) -> Result<Self, Error> { ... }
    fn try_from_slice(v: &[u8]) -> Result<Self, Error> { ... }
    fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>
       where R: Read { ... }
}

A data-structure that can be de-serialized from binary format by NBOR.

Required Methods

fn deserialize_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

Provided Methods

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl BorshDeserialize for SocketAddr

fn deserialize_reader<R>(reader: &mut R) -> Result<SocketAddr, Error>

where R: Read,

impl BorshDeserialize for bool

fn deserialize_reader<R>(reader: &mut R) -> Result<bool, Error>

where R: Read,

impl BorshDeserialize for f32

fn deserialize_reader<R>(reader: &mut R) -> Result<f32, Error>

where R: Read,

impl BorshDeserialize for f64

fn deserialize_reader<R>(reader: &mut R) -> Result<f64, Error>

where R: Read,

impl BorshDeserialize for i8

fn deserialize_reader<R>(reader: &mut R) -> Result<i8, Error>

where R: Read,

impl BorshDeserialize for i16

fn deserialize_reader<R>(reader: &mut R) -> Result<i16, Error>

where R: Read,

impl BorshDeserialize for i32

fn deserialize_reader<R>(reader: &mut R) -> Result<i32, Error>

where R: Read,

impl BorshDeserialize for i64

fn deserialize_reader<R>(reader: &mut R) -> Result<i64, Error>

where R: Read,

impl BorshDeserialize for i128

fn deserialize_reader<R>(reader: &mut R) -> Result<i128, Error>

where R: Read,

impl BorshDeserialize for isize

fn deserialize_reader<R>(reader: &mut R) -> Result<isize, Error>

where R: Read,

impl BorshDeserialize for u8

fn deserialize_reader<R>(reader: &mut R) -> Result<u8, Error>

where R: Read,

impl BorshDeserialize for u16

fn deserialize_reader<R>(reader: &mut R) -> Result<u16, Error>

where R: Read,

impl BorshDeserialize for u32

fn deserialize_reader<R>(reader: &mut R) -> Result<u32, Error>

where R: Read,

impl BorshDeserialize for u64

fn deserialize_reader<R>(reader: &mut R) -> Result<u64, Error>

where R: Read,

impl BorshDeserialize for u128

fn deserialize_reader<R>(reader: &mut R) -> Result<u128, Error>

where R: Read,

impl BorshDeserialize for ()

fn deserialize_reader<R>(_reader: &mut R) -> Result<(), Error>

where R: Read,

impl BorshDeserialize for usize

fn deserialize_reader<R>(reader: &mut R) -> Result<usize, Error>

where R: Read,

impl BorshDeserialize for String

fn deserialize_reader<R>(reader: &mut R) -> Result<String, Error>

where R: Read,

impl BorshDeserialize for Ipv4Addr

fn deserialize_reader<R>(reader: &mut R) -> Result<Ipv4Addr, Error>

where R: Read,

impl BorshDeserialize for Ipv6Addr

fn deserialize_reader<R>(reader: &mut R) -> Result<Ipv6Addr, Error>

where R: Read,

impl BorshDeserialize for SocketAddrV4

fn deserialize_reader<R>(reader: &mut R) -> Result<SocketAddrV4, Error>

where R: Read,

impl BorshDeserialize for SocketAddrV6

fn deserialize_reader<R>(reader: &mut R) -> Result<SocketAddrV6, Error>

where R: Read,

impl BorshDeserialize for NonZero<i8>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<i8>, Error>

where R: Read,

impl BorshDeserialize for NonZero<i16>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<i16>, Error>

where R: Read,

impl BorshDeserialize for NonZero<i32>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<i32>, Error>

where R: Read,

impl BorshDeserialize for NonZero<i64>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<i64>, Error>

where R: Read,

impl BorshDeserialize for NonZero<i128>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<i128>, Error>

where R: Read,

impl BorshDeserialize for NonZero<u8>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<u8>, Error>

where R: Read,

impl BorshDeserialize for NonZero<u16>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<u16>, Error>

where R: Read,

impl BorshDeserialize for NonZero<u32>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<u32>, Error>

where R: Read,

impl BorshDeserialize for NonZero<u64>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<u64>, Error>

where R: Read,

impl BorshDeserialize for NonZero<u128>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<u128>, Error>

where R: Read,

impl BorshDeserialize for NonZero<usize>

fn deserialize_reader<R>(reader: &mut R) -> Result<NonZero<usize>, Error>

where R: Read,

impl BorshDeserialize for RangeFull

fn deserialize_reader<R>(_reader: &mut R) -> Result<RangeFull, Error>

where R: Read,

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

where K: BorshDeserialize + Ord, V: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<BTreeMap<K, V>, Error>

where R: Read,

impl<K, V, H> BorshDeserialize for HashMap<K, V, H>

where K: BorshDeserialize + Eq + Hash + Ord, V: BorshDeserialize, H: BuildHasher + Default,

fn deserialize_reader<R>(reader: &mut R) -> Result<HashMap<K, V, H>, Error>

where R: Read,

impl<T0> BorshDeserialize for (T0,)

where T0: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0,), Error>

where R: Read,

impl<T0, T1> BorshDeserialize for (T0, T1)

where T0: BorshDeserialize, T1: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0, T1), Error>

where R: Read,

impl<T0, T1, T2> BorshDeserialize for (T0, T1, T2)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0, T1, T2), Error>

where R: Read,

impl<T0, T1, T2, T3> BorshDeserialize for (T0, T1, T2, T3)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0, T1, T2, T3), Error>

where R: Read,

impl<T0, T1, T2, T3, T4> BorshDeserialize for (T0, T1, T2, T3, T4)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0, T1, T2, T3, T4), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5> BorshDeserialize for (T0, T1, T2, T3, T4, T5)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize, T15: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize, T15: BorshDeserialize, T16: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize, T15: BorshDeserialize, T16: BorshDeserialize, T17: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize, T15: BorshDeserialize, T16: BorshDeserialize, T17: BorshDeserialize, T18: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Error>

where R: Read,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> BorshDeserialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)

where T0: BorshDeserialize, T1: BorshDeserialize, T2: BorshDeserialize, T3: BorshDeserialize, T4: BorshDeserialize, T5: BorshDeserialize, T6: BorshDeserialize, T7: BorshDeserialize, T8: BorshDeserialize, T9: BorshDeserialize, T10: BorshDeserialize, T11: BorshDeserialize, T12: BorshDeserialize, T13: BorshDeserialize, T14: BorshDeserialize, T15: BorshDeserialize, T16: BorshDeserialize, T17: BorshDeserialize, T18: BorshDeserialize, T19: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Error>

where R: Read,

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

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

fn deserialize_reader<R>(reader: &mut R) -> Result<Cow<'_, T>, Error>

where R: Read,

impl<T> BorshDeserialize for Option<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<Option<T>, Error>

where R: Read,

impl<T> BorshDeserialize for BTreeSet<T>

where T: BorshDeserialize + Ord,

fn deserialize_reader<R>(reader: &mut R) -> Result<BTreeSet<T>, Error>

where R: Read,

impl<T> BorshDeserialize for LinkedList<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<LinkedList<T>, Error>

where R: Read,

impl<T> BorshDeserialize for VecDeque<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<VecDeque<T>, Error>

where R: Read,

impl<T> BorshDeserialize for Rc<T>

where Box<T>: BorshDeserialize, T: ?Sized,

This impl requires the ["rc"] Cargo feature of borsh.

Deserializing a data structure containing Rc will not attempt to deduplicate Rc references to the same data. Every deserialized Rc will end up with a strong count of 1.

fn deserialize_reader<R>(reader: &mut R) -> Result<Rc<T>, Error>

where R: Read,

impl<T> BorshDeserialize for Arc<T>

where Box<T>: BorshDeserialize, T: ?Sized,

This impl requires the ["rc"] Cargo feature of borsh.

Deserializing a data structure containing Arc will not attempt to deduplicate Arc references to the same data. Every deserialized Arc will end up with a strong count of 1.

fn deserialize_reader<R>(reader: &mut R) -> Result<Arc<T>, Error>

where R: Read,

impl<T> BorshDeserialize for Vec<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<Vec<T>, Error>

where R: Read,

impl<T> BorshDeserialize for Cell<T>

where T: BorshDeserialize + Copy,

fn deserialize_reader<R>(reader: &mut R) -> Result<Cell<T>, Error>

where R: Read,

impl<T> BorshDeserialize for RefCell<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RefCell<T>, Error>

where R: Read,

impl<T> BorshDeserialize for PhantomData<T>

where T: ?Sized,

fn deserialize_reader<R>(_: &mut R) -> Result<PhantomData<T>, Error>

where R: Read,

impl<T> BorshDeserialize for Range<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<Range<T>, Error>

where R: Read,

impl<T> BorshDeserialize for RangeFrom<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RangeFrom<T>, Error>

where R: Read,

impl<T> BorshDeserialize for RangeInclusive<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RangeInclusive<T>, Error>

where R: Read,

impl<T> BorshDeserialize for RangeTo<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RangeTo<T>, Error>

where R: Read,

impl<T> BorshDeserialize for RangeToInclusive<T>

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RangeToInclusive<T>, Error>

where R: Read,

impl<T, E> BorshDeserialize for Result<T, E>

where T: BorshDeserialize, E: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<Result<T, E>, Error>

where R: Read,

impl<T, H> BorshDeserialize for HashSet<T, H>

where T: BorshDeserialize + Eq + Hash + Ord, H: BuildHasher + Default,

fn deserialize_reader<R>(reader: &mut R) -> Result<HashSet<T, H>, Error>

where R: Read,

impl<T, U> BorshDeserialize for Box<T>

where U: Into<Box<T>> + Borrow<T>, T: ToOwned<Owned = U> + ?Sized, <T as ToOwned>::Owned: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<Box<T>, Error>

where R: Read,

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

where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<[T; N], Error>

where R: Read,

Implementors

impl<T> BorshDeserialize for Serializable<T>

where T: SerializerT + DeserializerT,