Skip to main content

AnchorSerialize

light_sdk_types

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", so this trait is not object safe.

Implementations on Foreign Types§

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 QueueType

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

impl BorshSerialize for TreeType

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 ()

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 BorshSerialize for String

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 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 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 CompressedAccount
where Pubkey: BorshSerialize, u64: BorshSerialize, Option<[u8; 32]>: BorshSerialize, Option<CompressedAccountData>: BorshSerialize,

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

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

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

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

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

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

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

impl BorshSerialize for InCompressedAccountWithMerkleContext
where InCompressedAccount: BorshSerialize, MerkleContext: BorshSerialize,

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

impl BorshSerialize for MerkleContext
where Pubkey: BorshSerialize, u32: BorshSerialize, bool: BorshSerialize, TreeType: BorshSerialize,

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

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

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

impl BorshSerialize for PackedInCompressedAccountWithMerkleContext
where InCompressedAccount: BorshSerialize, PackedMerkleContext: BorshSerialize, u16: BorshSerialize,

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

impl BorshSerialize for PackedMerkleContext
where u8: BorshSerialize, u32: BorshSerialize, bool: BorshSerialize,

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

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

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

impl BorshSerialize for ReadOnlyCompressedAccount
where [u8; 32]: BorshSerialize, MerkleContext: BorshSerialize, u16: 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 ValidityProof

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

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

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

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

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

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

impl BorshSerialize for NewAddressParamsAssigned
where [u8; 32]: BorshSerialize, Pubkey: BorshSerialize, u16: BorshSerialize, Option<u8>: BorshSerialize,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl BorshSerialize for CompressedAccountInfo
where Option<[u8; 32]>: BorshSerialize, Option<InAccountInfo>: BorshSerialize, Option<OutAccountInfo>: BorshSerialize,

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

impl BorshSerialize for InAccountInfo
where [u8; 8]: BorshSerialize, [u8; 32]: BorshSerialize, PackedMerkleContext: BorshSerialize, u16: BorshSerialize, u64: BorshSerialize,

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

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

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

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

impl BorshSerialize for InAccount
where [u8; 8]: BorshSerialize, [u8; 32]: BorshSerialize, PackedMerkleContext: BorshSerialize, u16: BorshSerialize, u64: BorshSerialize, Option<[u8; 32]>: BorshSerialize,

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

impl BorshSerialize for InstructionDataInvokeCpiWithReadOnly
where u8: BorshSerialize, Pubkey: BorshSerialize, u64: BorshSerialize, bool: BorshSerialize, CompressedCpiContext: BorshSerialize, Option<CompressedProof>: BorshSerialize, Vec<NewAddressParamsAssignedPacked>: BorshSerialize, Vec<InAccount>: BorshSerialize, Vec<OutputCompressedAccountWithPackedContext>: BorshSerialize, Vec<PackedReadOnlyAddress>: BorshSerialize, Vec<PackedReadOnlyCompressedAccount>: BorshSerialize,

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

impl BorshSerialize for Pubkey

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

impl BorshSerialize for CompressionInfo
where u16: BorshSerialize, u8: BorshSerialize, u32: BorshSerialize, [u8; 32]: BorshSerialize, u64: BorshSerialize, RentConfig: BorshSerialize,

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

impl BorshSerialize for CompressibleConfig
where u16: BorshSerialize, u8: BorshSerialize, Pubkey: BorshSerialize, RentConfig: BorshSerialize, [Pubkey; 4]: BorshSerialize, [u8; 32]: BorshSerialize,

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

impl BorshSerialize for CreateCompressibleConfig
where RentConfig: BorshSerialize, Pubkey: BorshSerialize, bool: BorshSerialize,

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

impl BorshSerialize for CreateConfigCounter

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

impl BorshSerialize for Pubkey

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

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

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

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

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<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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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<T> BorshSerialize for Cow<'_, T>
where T: BorshSerialize + ToOwned + ?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 &T
where T: BorshSerialize + ?Sized,

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,

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

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

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

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

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

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

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

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

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

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

impl<T> BorshSerialize for Vec<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, 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, H> BorshSerialize for HashSet<T, H>
where T: BorshSerialize + PartialOrd, H: BuildHasher,

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,

Implementors§

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 CompressionState

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

impl BorshSerialize for CompressedAccountMeta
where PackedStateTreeInfo: BorshSerialize, [u8; 32]: BorshSerialize, u8: BorshSerialize,

impl BorshSerialize for CompressedAccountMetaInitIfNeeded
where bool: BorshSerialize, u8: BorshSerialize, [u8; 32]: BorshSerialize, Option<PackedStateTreeInfo>: BorshSerialize,

impl BorshSerialize for CompressedAccountMetaNoAddress
where PackedStateTreeInfo: BorshSerialize, u8: BorshSerialize, u64: BorshSerialize,

impl BorshSerialize for CompressedAccountMetaNoLamportsNoAddress
where PackedStateTreeInfo: BorshSerialize, u8: BorshSerialize,

impl BorshSerialize for CompressedAccountMetaReadOnly
where PackedStateTreeInfo: BorshSerialize, [u8; 32]: BorshSerialize,

impl BorshSerialize for CompressedAccountMetaWithLamports
where PackedStateTreeInfo: BorshSerialize, u64: BorshSerialize, [u8; 32]: BorshSerialize, u8: BorshSerialize,

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

impl BorshSerialize for PackedStateTreeInfo
where u16: BorshSerialize, bool: BorshSerialize, u8: BorshSerialize, u32: BorshSerialize,

impl BorshSerialize for light_sdk_types::interface::account::compression_info::CompressionInfo
where u64: BorshSerialize, u32: BorshSerialize, u16: BorshSerialize, CompressionState: BorshSerialize, u8: BorshSerialize, RentConfig: BorshSerialize,

impl BorshSerialize for CreateAccountsProof
where ValidityProof: BorshSerialize, PackedAddressTreeInfo: BorshSerialize, u8: BorshSerialize, Option<u8>: BorshSerialize,

impl BorshSerialize for CompressAndCloseParams
where ValidityProof: BorshSerialize, Vec<CompressedAccountMetaNoLamportsNoAddress>: BorshSerialize, u8: BorshSerialize,

impl BorshSerialize for InitializeLightConfigParams
where [u8; 32]: BorshSerialize, RentConfig: BorshSerialize, u32: BorshSerialize, Vec<[u8; 32]>: BorshSerialize, u8: BorshSerialize,

impl BorshSerialize for LightConfig
where u8: BorshSerialize, u32: BorshSerialize, [u8; 32]: BorshSerialize, RentConfig: BorshSerialize, Vec<[u8; 32]>: BorshSerialize,

impl BorshSerialize for UpdateLightConfigParams
where Option<[u8; 32]>: BorshSerialize, Option<RentConfig>: BorshSerialize, Option<u32>: BorshSerialize, Option<Vec<[u8; 32]>>: BorshSerialize,

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

impl BorshSerialize for RentSponsor
where [u8; 32]: BorshSerialize, u8: BorshSerialize,

impl<T> BorshSerialize for light_sdk_types::interface::account::compression_info::CompressedAccountData<T>
where PackedStateTreeInfo: BorshSerialize, T: BorshSerialize,

impl<V> BorshSerialize for DecompressIdempotentParams<V>
where V: AnchorSerialize + AnchorDeserialize + Clone, u8: BorshSerialize, ValidityProof: BorshSerialize, Vec<CompressedAccountData<V>>: BorshSerialize,