Skip to main content

AnchorSerialize

light_system_program::invoke_cpi::processor

Trait AnchorSerialize

pub trait AnchorSerialize {
    // Required method
    fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
       where W: Write;

    // Provided method
    fn try_to_vec(&self) -> Result<Vec<u8>, Error> { ... }
}

Expand description

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

use borsh::BorshSerialize;

#[derive(BorshSerialize)]
struct MyBorshSerializableStruct {
    value: String,
}

let x = MyBorshSerializableStruct { value: "hello".to_owned() };
let mut buffer: Vec<u8> = Vec::new();
x.serialize(&mut buffer).unwrap();
let single_serialized_buffer_len = buffer.len();

x.serialize(&mut buffer).unwrap();
assert_eq!(buffer.len(), single_serialized_buffer_len * 2);

let mut buffer: Vec<u8> = vec![0; 1024 + single_serialized_buffer_len];
let mut buffer_slice_enough_for_the_data = &mut buffer[1024..1024 + single_serialized_buffer_len];
x.serialize(&mut buffer_slice_enough_for_the_data).unwrap();

Required Methods§

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

Provided Methods§

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

Dyn Compatibility§

This trait is not dyn compatible.

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

Implementations on Foreign Types§

impl BorshSerialize for ()

fn serialize<W>(&self, _writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for AppendLeaves
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Authorized

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Delegation

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for DeregisterProgram

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for DeregisterProgram
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for GroupAuthority
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for InitializeAddressMerkleTreeAndQueue
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for InitializeGroupAuthority
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for InitializeGroupAuthority
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for InitializeStateMerkleTreeAndNullifierQueue
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for InsertIntoQueues
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Ipv4Addr

Available on crate feature std only.

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Ipv6Addr

Available on crate feature std only.

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Lockup

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Meta

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<i8>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<i16>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<i32>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<i64>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<i128>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<u8>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<u16>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<u32>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<u64>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<u128>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NonZero<usize>

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NullifierEvent
where [u8; 32]: BorshSerialize, Vec<u64>: BorshSerialize, u64: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for NullifyLeaves
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for QueueType

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RegisterProgramToGroup

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RegisterProgramToGroup
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RegisteredProgram
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RolloverAddressMerkleTreeAndQueue

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RolloverAddressMerkleTreeAndQueue
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RolloverStateMerkleTreeAndNullifierQueue

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for RolloverStateMerkleTreeAndNullifierQueue
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for SocketAddr

Available on crate feature std only.

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for SocketAddrV4

Available on crate feature std only.

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for SocketAddrV6

Available on crate feature std only.

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for Stake

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for StakeFlags

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for StakeState

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for StakeStateV2

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for UpdateAddressMerkleTree
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for UpdateGroupAuthority
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for UpdateGroupAuthority
where Pubkey: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for bool

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for f32

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for f64

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for i8

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for i16

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for i32

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for i64

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for i128

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for isize

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for str

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for u8

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for u16

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for u32

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for u64

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for u128

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl BorshSerialize for usize

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T0, T1, T2, T3, T4, T5, T6, T7> BorshSerialize for (T0, T1, T2, T3, T4, T5, T6, T7)
where T0: BorshSerialize, T1: BorshSerialize, T2: BorshSerialize, T3: BorshSerialize, T4: BorshSerialize, T5: BorshSerialize, T6: BorshSerialize, T7: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T0, T1, T2, T3, T4, T5, T6> BorshSerialize for (T0, T1, T2, T3, T4, T5, T6)
where T0: BorshSerialize, T1: BorshSerialize, T2: BorshSerialize, T3: BorshSerialize, T4: BorshSerialize, T5: BorshSerialize, T6: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T0, T1, T2, T3, T4, T5> BorshSerialize for (T0, T1, T2, T3, T4, T5)
where T0: BorshSerialize, T1: BorshSerialize, T2: BorshSerialize, T3: BorshSerialize, T4: BorshSerialize, T5: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T0> BorshSerialize for (T0,)
where T0: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T> BorshSerialize for &T
where T: BorshSerialize + ?Sized,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

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

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T> BorshSerialize for PhantomData<T>
where T: ?Sized,

fn serialize<W>(&self, _: &mut W) -> Result<(), Error>
where W: Write,

impl<T> BorshSerialize for Range<T>
where T: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

impl<T> BorshSerialize for [T]
where T: BorshSerialize,

fn serialize<W>(&self, writer: &mut W) -> Result<(), Error>
where W: Write,

Implementors§

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

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

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

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

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

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

impl BorshSerialize for CompressedSolPda

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

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

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

impl BorshSerialize for InitCpiContextAccount

impl BorshSerialize for InitializeCpiContextAccount
where Pubkey: BorshSerialize,

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

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

impl BorshSerialize for InvokeCpiInstruction
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

impl BorshSerialize for InvokeInstruction
where Pubkey: BorshSerialize, Option<Pubkey>: BorshSerialize,

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

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

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

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

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

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

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

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

impl BorshSerialize for Pubkey

impl BorshSerialize for PublicTransactionEvent
where Vec<[u8; 32]>: BorshSerialize, Vec<OutputCompressedAccountWithPackedContext>: BorshSerialize, Vec<u32>: BorshSerialize, Vec<MerkleTreeSequenceNumber>: BorshSerialize, Option<u64>: BorshSerialize, bool: BorshSerialize, Vec<Pubkey>: BorshSerialize, Option<Vec<u8>>: BorshSerialize,

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

impl BorshSerialize for String

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

impl<K, V, H> BorshSerialize for HashMap<K, V, H>
where K: BorshSerialize + PartialOrd, V: BorshSerialize, H: BuildHasher,

impl<K, V> BorshSerialize for BTreeMap<K, V>
where K: BorshSerialize, V: BorshSerialize,

impl<T, H> BorshSerialize for HashSet<T, H>
where T: BorshSerialize + PartialOrd, H: BuildHasher,

impl<T> BorshSerialize for BTreeSet<T>
where T: BorshSerialize,

impl<T> BorshSerialize for BinaryHeap<T>
where T: BorshSerialize,

impl<T> BorshSerialize for Box<T>
where T: BorshSerialize + ?Sized,

impl<T> BorshSerialize for Cow<'_, T>
where T: BorshSerialize + ToOwned + ?Sized,

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

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

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