Trait anchor_lang::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.

Object Safety§

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 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 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 StakeFlags

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 Delegation

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 Meta

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<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 BorshSchemaContainer
where String: BorshSerialize, HashMap<String, Definition>: BorshSerialize,

impl BorshSerialize for Pubkey