BorshSerialize

Trait BorshSerialize 

Source
pub trait BorshSerialize {
    // 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§

Source

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

Provided Methods§

Source

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§

Source§

impl BorshSerialize for SocketAddr

Source§

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

Source§

impl BorshSerialize for bool

Source§

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

Source§

impl BorshSerialize for f32

Source§

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

Source§

impl BorshSerialize for f64

Source§

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

Source§

impl BorshSerialize for i8

Source§

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

Source§

impl BorshSerialize for i16

Source§

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

Source§

impl BorshSerialize for i32

Source§

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

Source§

impl BorshSerialize for i64

Source§

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

Source§

impl BorshSerialize for i128

Source§

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

Source§

impl BorshSerialize for str

Source§

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

Source§

impl BorshSerialize for u8

Source§

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

Source§

impl BorshSerialize for u16

Source§

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

Source§

impl BorshSerialize for u32

Source§

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

Source§

impl BorshSerialize for u64

Source§

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

Source§

impl BorshSerialize for u128

Source§

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

Source§

impl BorshSerialize for ()

Source§

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

Source§

impl BorshSerialize for usize

Source§

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

Source§

impl BorshSerialize for String

Source§

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

Source§

impl BorshSerialize for Ipv4Addr

Source§

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

Source§

impl BorshSerialize for Ipv6Addr

Source§

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

Source§

impl BorshSerialize for SocketAddrV4

Source§

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

Source§

impl BorshSerialize for SocketAddrV6

Source§

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

Source§

impl BorshSerialize for NonZero<i8>

Source§

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

Source§

impl BorshSerialize for NonZero<i16>

Source§

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

Source§

impl BorshSerialize for NonZero<i32>

Source§

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

Source§

impl BorshSerialize for NonZero<i64>

Source§

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

Source§

impl BorshSerialize for NonZero<i128>

Source§

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

Source§

impl BorshSerialize for NonZero<u8>

Source§

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

Source§

impl BorshSerialize for NonZero<u16>

Source§

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

Source§

impl BorshSerialize for NonZero<u32>

Source§

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

Source§

impl BorshSerialize for NonZero<u64>

Source§

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

Source§

impl BorshSerialize for NonZero<u128>

Source§

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

Source§

impl BorshSerialize for NonZero<usize>

Source§

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

Source§

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

Source§

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

Source§

impl<K, V, H> BorshSerialize for HashMap<K, V, H>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

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)

Source§

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

Source§

impl<T> BorshSerialize for Cow<'_, T>

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

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

Source§

impl<T, H> BorshSerialize for HashSet<T, H>

Source§

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

Implementors§

Source§

impl BorshSerialize for DecisionStatus

Source§

impl BorshSerialize for Error

Source§

impl BorshSerialize for HandleError

Source§

impl BorshSerialize for Event

Source§

impl BorshSerialize for CipherOwner

Source§

impl BorshSerialize for MaskStatus

Source§

impl BorshSerialize for RandomMode

Source§

impl BorshSerialize for RandomSpec

Source§

impl BorshSerialize for RandomStatus

Source§

impl BorshSerialize for EntryType

Source§

impl BorshSerialize for GameStatus

Source§

impl BorshSerialize for RecipientSlotOwner

Source§

impl BorshSerialize for RecipientSlotType

Source§

impl BorshSerialize for SecretShare

Source§

impl BorshSerialize for SettleOp

Source§

impl BorshSerialize for VoteType

Source§

impl BorshSerialize for Definition

Source§

impl BorshSerialize for Fields

Source§

impl BorshSerialize for Answer

Source§

impl BorshSerialize for DecisionState

Source§

impl BorshSerialize for ActionTimeout

Source§

impl BorshSerialize for Ask

Source§

impl BorshSerialize for Assign

Source§

impl BorshSerialize for Effect

Source§

impl BorshSerialize for Release

Source§

impl BorshSerialize for Reveal

Source§

impl BorshSerialize for InitAccount

Source§

impl BorshSerialize for Message

Source§

impl BorshSerialize for Lock

Source§

impl BorshSerialize for LockedCiphertext

Source§

impl BorshSerialize for Mask

Source§

impl BorshSerialize for RandomState

Source§

impl BorshSerialize for Share

Source§

impl BorshSerialize for PlayerDeposit

Source§

impl BorshSerialize for PlayerJoin

Source§

impl BorshSerialize for RecipientSlot

Source§

impl BorshSerialize for RecipientSlotShare

Source§

impl BorshSerialize for SecretIdent

Source§

impl BorshSerialize for ServerJoin

Source§

impl BorshSerialize for Settle

Source§

impl BorshSerialize for Signature

Source§

impl BorshSerialize for Transfer

Source§

impl BorshSerialize for BorshSchemaContainer