Skip to main content

AnchorDeserialize

light_system_program::invoke_cpi::processor

Trait AnchorDeserialize

pub trait AnchorDeserialize: 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 { ... }
}

Expand description

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,

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types§

impl BorshDeserialize for ()

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

impl BorshDeserialize for AccessMetadata
where Pubkey: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<AccessMetadata, Error>
where R: Read,

impl BorshDeserialize for AddressMerkleTreeAccount
where MerkleTreeMetadata: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<AddressMerkleTreeAccount, Error>
where R: Read,

impl BorshDeserialize for AddressMerkleTreeConfig
where u32: BorshDeserialize, u64: BorshDeserialize, Option<u64>: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<AddressMerkleTreeConfig, Error>
where R: Read,

impl BorshDeserialize for AppendLeavesToMerkleTrees
where Vec<(u8, [u8; 32])>: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<AppendLeavesToMerkleTrees, Error>
where R: Read,

impl BorshDeserialize for Authorized

fn deserialize_reader<R>(reader: &mut R) -> Result<Authorized, Error>
where R: Read,

impl BorshDeserialize for ChangelogEvent
where [u8; 32]: BorshDeserialize, Vec<Vec<PathNode>>: BorshDeserialize, u64: BorshDeserialize, u32: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<ChangelogEvent, Error>
where R: Read,

impl BorshDeserialize for CompressedProof
where [u8; 32]: BorshDeserialize, [u8; 64]: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<CompressedProof, Error>
where R: Read,

impl BorshDeserialize for Delegation

fn deserialize_reader<R>(reader: &mut R) -> Result<Delegation, Error>
where R: Read,

impl BorshDeserialize for DeregisterProgram

fn deserialize_reader<R>(reader: &mut R) -> Result<DeregisterProgram, Error>
where R: Read,

impl BorshDeserialize for GroupAuthority
where Pubkey: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<GroupAuthority, Error>
where R: Read,

impl BorshDeserialize for IndexedMerkleTreeEvent
where [u8; 32]: BorshDeserialize, Vec<IndexedMerkleTreeUpdate<usize>>: BorshDeserialize, u64: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<IndexedMerkleTreeEvent, Error>
where R: Read,

impl BorshDeserialize for InitializeAddressMerkleTreeAndQueue
where u64: BorshDeserialize, Option<Pubkey>: BorshDeserialize, AddressMerkleTreeConfig: BorshDeserialize, NullifierQueueConfig: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<InitializeAddressMerkleTreeAndQueue, Error>
where R: Read,

impl BorshDeserialize for InitializeGroupAuthority
where Pubkey: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<InitializeGroupAuthority, Error>
where R: Read,

impl BorshDeserialize for InitializeStateMerkleTreeAndNullifierQueue
where u64: BorshDeserialize, Option<Pubkey>: BorshDeserialize, StateMerkleTreeConfig: BorshDeserialize, NullifierQueueConfig: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<InitializeStateMerkleTreeAndNullifierQueue, Error>
where R: Read,

impl BorshDeserialize for InsertAddresses
where Vec<[u8; 32]>: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<InsertAddresses, Error>
where R: Read,

impl BorshDeserialize for InsertIntoNullifierQueues
where Vec<[u8; 32]>: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<InsertIntoNullifierQueues, Error>
where R: Read,

impl BorshDeserialize for Ipv4Addr

Available on crate feature std only.

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

impl BorshDeserialize for Ipv6Addr

Available on crate feature std only.

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

impl BorshDeserialize for Lockup

fn deserialize_reader<R>(reader: &mut R) -> Result<Lockup, Error>
where R: Read,

impl BorshDeserialize for MerkleTreeEvent
where ChangelogEvent: BorshDeserialize, NullifierEvent: BorshDeserialize, IndexedMerkleTreeEvent: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<MerkleTreeEvent, Error>
where R: Read,

impl BorshDeserialize for MerkleTreeEvents
where Vec<MerkleTreeEvent>: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<MerkleTreeEvents, Error>
where R: Read,

impl BorshDeserialize for MerkleTreeMetadata
where AccessMetadata: BorshDeserialize, RolloverMetadata: BorshDeserialize, Pubkey: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<MerkleTreeMetadata, Error>
where R: Read,

impl BorshDeserialize for Meta

fn deserialize_reader<R>(reader: &mut R) -> Result<Meta, 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 NullifierEvent
where [u8; 32]: BorshDeserialize, Vec<u64>: BorshDeserialize, u64: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<NullifierEvent, Error>
where R: Read,

impl BorshDeserialize for NullifierQueueConfig
where u16: BorshDeserialize, u64: BorshDeserialize, Option<u64>: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<NullifierQueueConfig, Error>
where R: Read,

impl BorshDeserialize for NullifyLeaves
where Vec<u64>: BorshDeserialize, Vec<u16>: BorshDeserialize, Vec<Vec<[u8; 32]>>: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<NullifyLeaves, Error>
where R: Read,

impl BorshDeserialize for PathNode
where [u8; 32]: BorshDeserialize, u32: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<PathNode, Error>
where R: Read,

impl BorshDeserialize for QueueAccount
where QueueMetadata: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<QueueAccount, Error>
where R: Read,

impl BorshDeserialize for QueueMetadata
where AccessMetadata: BorshDeserialize, RolloverMetadata: BorshDeserialize, Pubkey: BorshDeserialize, u64: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<QueueMetadata, Error>
where R: Read,

impl BorshDeserialize for QueueType

fn deserialize_reader<R>(reader: &mut R) -> Result<QueueType, Error>
where R: Read,

impl BorshDeserialize for RegisterProgramToGroup

fn deserialize_reader<R>( reader: &mut R, ) -> Result<RegisterProgramToGroup, Error>
where R: Read,

impl BorshDeserialize for RegisteredProgram
where Pubkey: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RegisteredProgram, Error>
where R: Read,

impl BorshDeserialize for RolloverAddressMerkleTreeAndQueue

fn deserialize_reader<R>( reader: &mut R, ) -> Result<RolloverAddressMerkleTreeAndQueue, Error>
where R: Read,

impl BorshDeserialize for RolloverMetadata
where u64: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RolloverMetadata, Error>
where R: Read,

impl BorshDeserialize for RolloverStateMerkleTreeAndNullifierQueue

fn deserialize_reader<R>( reader: &mut R, ) -> Result<RolloverStateMerkleTreeAndNullifierQueue, Error>
where R: Read,

impl BorshDeserialize for SocketAddr

Available on crate feature std only.

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

impl BorshDeserialize for SocketAddrV4

Available on crate feature std only.

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

impl BorshDeserialize for SocketAddrV6

Available on crate feature std only.

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

impl BorshDeserialize for Stake

fn deserialize_reader<R>(reader: &mut R) -> Result<Stake, Error>
where R: Read,

impl BorshDeserialize for StakeFlags

fn deserialize_reader<R>(reader: &mut R) -> Result<StakeFlags, Error>
where R: Read,

impl BorshDeserialize for StakeState

fn deserialize_reader<R>(reader: &mut R) -> Result<StakeState, Error>
where R: Read,

impl BorshDeserialize for StakeStateV2

fn deserialize_reader<R>(reader: &mut R) -> Result<StakeStateV2, Error>
where R: Read,

impl BorshDeserialize for StateMerkleTreeAccount
where MerkleTreeMetadata: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<StateMerkleTreeAccount, Error>
where R: Read,

impl BorshDeserialize for StateMerkleTreeConfig
where u32: BorshDeserialize, u64: BorshDeserialize, Option<u64>: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<StateMerkleTreeConfig, Error>
where R: Read,

impl BorshDeserialize for UpdateAddressMerkleTree
where u16: BorshDeserialize, u64: BorshDeserialize, [u8; 32]: BorshDeserialize, [[u8; 32]; 16]: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<UpdateAddressMerkleTree, Error>
where R: Read,

impl BorshDeserialize for UpdateGroupAuthority
where Pubkey: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<UpdateGroupAuthority, 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 usize

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

impl<I> BorshDeserialize for IndexedMerkleTreeUpdate<I>
where I: Clone, RawIndexedElement<I>: BorshDeserialize, [u8; 32]: BorshDeserialize,

fn deserialize_reader<R>( reader: &mut R, ) -> Result<IndexedMerkleTreeUpdate<I>, Error>
where R: Read,

impl<I> BorshDeserialize for RawIndexedElement<I>
where I: Clone + BorshDeserialize, [u8; 32]: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<RawIndexedElement<I>, 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<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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> 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> BorshDeserialize for (T0,)
where T0: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<(T0,), 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, const N: usize> BorshDeserialize for [T; N]
where T: BorshDeserialize,

fn deserialize_reader<R>(reader: &mut R) -> Result<[T; N], 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 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,

Implementors§

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

impl BorshDeserialize for CompressedAccount
where Pubkey: BorshDeserialize, u64: BorshDeserialize, Option<[u8; 32]>: BorshDeserialize, Option<CompressedAccountData>: BorshDeserialize,

impl BorshDeserialize for CompressedAccountData
where [u8; 8]: BorshDeserialize, Vec<u8>: BorshDeserialize, [u8; 32]: BorshDeserialize,

impl BorshDeserialize for CompressedAccountWithMerkleContext
where CompressedAccount: BorshDeserialize, MerkleContext: BorshDeserialize,

impl BorshDeserialize for CompressedCpiContext
where bool: BorshDeserialize, u8: BorshDeserialize,

impl BorshDeserialize for light_system_program::invoke::processor::CompressedProof
where [u8; 32]: BorshDeserialize, [u8; 64]: BorshDeserialize,

impl BorshDeserialize for CompressedSolPda

impl BorshDeserialize for CpiContextAccount
where Pubkey: BorshDeserialize, Vec<InstructionDataInvokeCpi>: BorshDeserialize,

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

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

impl BorshDeserialize for InitCpiContextAccount

impl BorshDeserialize for Invoke
where Vec<u8>: BorshDeserialize,

impl BorshDeserialize for InvokeCpi
where Vec<u8>: BorshDeserialize,

impl BorshDeserialize for MerkleContext
where Pubkey: BorshDeserialize, u32: BorshDeserialize, Option<QueueIndex>: BorshDeserialize,

impl BorshDeserialize for MerkleTreeSequenceNumber
where Pubkey: BorshDeserialize, u64: BorshDeserialize,

impl BorshDeserialize for NewAddressParams
where [u8; 32]: BorshDeserialize, Pubkey: BorshDeserialize, u16: BorshDeserialize,

impl BorshDeserialize for NewAddressParamsPacked
where [u8; 32]: BorshDeserialize, u8: BorshDeserialize, u16: BorshDeserialize,

impl BorshDeserialize for OutputCompressedAccountWithContext
where CompressedAccount: BorshDeserialize, Pubkey: BorshDeserialize,

impl BorshDeserialize for OutputCompressedAccountWithPackedContext
where CompressedAccount: BorshDeserialize, u8: BorshDeserialize,

impl BorshDeserialize for PackedCompressedAccountWithMerkleContext
where CompressedAccount: BorshDeserialize, PackedMerkleContext: BorshDeserialize, u16: BorshDeserialize, bool: BorshDeserialize,

impl BorshDeserialize for PackedMerkleContext
where u8: BorshDeserialize, u32: BorshDeserialize, Option<QueueIndex>: BorshDeserialize,

impl BorshDeserialize for Pubkey

impl BorshDeserialize for QueueIndex
where u8: BorshDeserialize, u16: BorshDeserialize,

impl BorshDeserialize for String

impl BorshDeserialize for StubIdlBuild
where InstructionDataInvoke: BorshDeserialize, InstructionDataInvokeCpi: BorshDeserialize, PublicTransactionEvent: BorshDeserialize,

impl<K, V, H> BorshDeserialize for HashMap<K, V, H>
where K: BorshDeserialize + Eq + Hash, V: BorshDeserialize, H: BuildHasher + Default,

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

impl<T, H> BorshDeserialize for HashSet<T, H>
where T: BorshDeserialize + Eq + Hash, H: BuildHasher + Default,

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

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

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

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

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

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

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