Trait BorshSerialize 

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

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

use borsh::BorshSerialize;

/// derive is only available if borsh is built with `features = ["derive"]`
#[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,

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 IpAddr

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

where W: Write,

impl BorshSerialize for Ipv4Addr

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

where W: Write,

impl BorshSerialize for Ipv6Addr

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 RangeFull

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

where W: Write,

impl BorshSerialize for SocketAddr

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

where W: Write,

impl BorshSerialize for SocketAddrV4

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

where W: Write,

impl BorshSerialize for SocketAddrV6

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 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<K, V, H> BorshSerialize for HashMap<K, V, H>

where K: BorshSerialize + Ord, V: BorshSerialize, H: BuildHasher,

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<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, H> BorshSerialize for HashSet<T, H>

where T: BorshSerialize + Ord, 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,

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 Arc<T>

where T: BorshSerialize + ?Sized,

This impl requires the ["rc"] Cargo feature of borsh.

Serializing a data structure containing Arc will serialize a copy of the contents of the Arc each time the Arc is referenced within the data structure. Serialization will not attempt to deduplicate these repeated data.

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 Box<T>

where T: BorshSerialize + ?Sized,

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

where W: Write,

impl<T> BorshSerialize for Cell<T>

where T: BorshSerialize + Copy,

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 LinkedList<T>

where T: BorshSerialize,

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 RangeFrom<T>

where T: BorshSerialize,

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

where W: Write,

impl<T> BorshSerialize for RangeInclusive<T>

where T: BorshSerialize,

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

where W: Write,

impl<T> BorshSerialize for RangeTo<T>

where T: BorshSerialize,

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

where W: Write,

impl<T> BorshSerialize for RangeToInclusive<T>

where T: BorshSerialize,

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

where W: Write,

impl<T> BorshSerialize for Rc<T>

where T: BorshSerialize + ?Sized,

This impl requires the ["rc"] Cargo feature of borsh.

Serializing a data structure containing Rc will serialize a copy of the contents of the Rc each time the Rc is referenced within the data structure. Serialization will not attempt to deduplicate these repeated data.

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

where W: Write,

impl<T> BorshSerialize for RefCell<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 VecDeque<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<T> BorshSerialize for Serializable<T>

where T: SerializerT + DeserializerT,