Trait anchor_lang::AnchorDeserialize

pub trait AnchorDeserialize {
    fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>;

    fn try_from_slice(v: &[u8]) -> Result<Self, Error> { ... }
    fn is_u8() -> bool { ... }
}

Borsh is the default serialization format for instructions and accounts. A data-structure that can be de-serialized from binary format by NBOR.

Required 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.

Provided methods

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

Deserialize this instance from a slice of bytes.

fn is_u8() -> bool

Whether Self is u8. NOTE: Vec<u8> is the most common use-case for serialization and deserialization, it’s worth handling it as a special case to improve performance. It’s a workaround for specific Vec<u8> implementation versus generic Vec<T> implementation. See https://github.com/rust-lang/rfcs/pull/1210 for details.

Implementations on Foreign Types

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

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

impl BorshDeserialize for u8

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

fn is_u8() -> bool

impl<K, V> BorshDeserialize for HashMap<K, V, RandomState> where
    K: BorshDeserialize + Eq + Hash,
    V: BorshDeserialize, 

fn deserialize(buf: &mut &[u8]) -> Result<HashMap<K, V, RandomState>, Error>

impl<T> BorshDeserialize for [T; 26] where
    T: BorshDeserialize + Default + Copy, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), Error>

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

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

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

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

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

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

impl BorshDeserialize for f64

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

impl BorshDeserialize for Definition where
    u32: BorshDeserialize,
    String: BorshDeserialize,
    Vec<String, Global>: BorshDeserialize,
    Vec<(String, String), Global>: BorshDeserialize,
    Fields: BorshDeserialize, 

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

impl<T> BorshDeserialize for [T; 13] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 30] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for SocketAddr

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

impl<T> BorshDeserialize for [T; 1024] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 23] where
    T: BorshDeserialize + Default + Copy, 

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

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(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3, T4, T5), Error>

impl<T> BorshDeserialize for [T; 12] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 32] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for i8

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

impl<T> BorshDeserialize for [T; 7] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 27] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 512] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for VecDeque<T, Global> where
    T: BorshDeserialize, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), Error>

impl<T> BorshDeserialize for [T; 5] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 3] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 65] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 18] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for ()

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

impl<T> BorshDeserialize for LinkedList<T> where
    T: BorshDeserialize, 

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

impl<T> BorshDeserialize for [T; 15] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 22] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 16] where
    T: BorshDeserialize + Default + Copy, 

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

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

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), Error>

impl BorshDeserialize for Ipv6Addr

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

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(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3, T4, T5, T6), Error>

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), Error>

impl<T> BorshDeserialize for [T; 9] where
    T: BorshDeserialize + Default + Copy, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), Error>

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(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3, T4), Error>

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), Error>

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), Error>

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), Error>

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), Error>

impl BorshDeserialize for Ipv4Addr

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

impl BorshDeserialize for bool

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

impl BorshDeserialize for BorshSchemaContainer where
    String: BorshDeserialize,
    HashMap<String, Definition, RandomState>: BorshDeserialize, 

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

impl BorshDeserialize for i64

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

impl<T> BorshDeserialize for [T; 2] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for f32

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

impl BorshDeserialize for u64

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

impl BorshDeserialize for i16

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

impl<T> BorshDeserialize for [T; 21] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 31] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for u32

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

impl BorshDeserialize for SocketAddrV4

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

impl<T> BorshDeserialize for [T; 17] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 64] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 25] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 6] where
    T: BorshDeserialize + Default + Copy, 

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

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

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), Error>

impl BorshDeserialize for u128

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

impl<T> BorshDeserialize for [T; 28] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 24] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for Vec<T, Global> where
    T: BorshDeserialize, 

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

impl<T> BorshDeserialize for [T; 1] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 256] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 8] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for u16

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

impl BorshDeserialize for SocketAddrV6

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

impl<T> BorshDeserialize for [T; 2048] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 11] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for Fields where
    Vec<(String, String), Global>: BorshDeserialize,
    Vec<String, Global>: BorshDeserialize, 

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

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

fn deserialize(buf: &mut &[u8]) -> Result<(T0, T1, T2, T3), Error>

impl BorshDeserialize for String

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

impl<T> BorshDeserialize for HashSet<T, RandomState> where
    T: BorshDeserialize + Eq + Hash, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), Error>

impl BorshDeserialize for i128

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

impl<T> BorshDeserialize for [T; 14] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 20] where
    T: BorshDeserialize + Default + Copy, 

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

impl<T> BorshDeserialize for [T; 19] where
    T: BorshDeserialize + Default + Copy, 

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

impl BorshDeserialize for i32

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

impl<T> BorshDeserialize for [T; 10] where
    T: BorshDeserialize + Default + Copy, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), Error>

impl<T> BorshDeserialize for [T; 0] where
    T: BorshDeserialize + Default + Copy, 

fn deserialize(_buf: &mut &[u8]) -> Result<[T; 0], Error>

impl<T> BorshDeserialize for [T; 128] where
    T: BorshDeserialize + Default + Copy, 

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

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

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

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

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

impl<T> BorshDeserialize for [T; 4] where
    T: BorshDeserialize + Default + Copy, 

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

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(
    buf: &mut &[u8]
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), Error>

impl<T> BorshDeserialize for [T; 29] where
    T: BorshDeserialize + Default + Copy, 

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

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

fn deserialize(buf: &mut &[u8]) -> Result<Cow<'_, T>, Error>

Implementors

impl BorshDeserialize for IdlInstruction where
    u64: BorshDeserialize,
    Vec<u8>: BorshDeserialize,
    Pubkey: BorshDeserialize, 

impl BorshDeserialize for IdlAccount where
    Pubkey: BorshDeserialize,
    Vec<u8>: BorshDeserialize, 

impl BorshDeserialize for Pubkey