Trait borsh::ser::BorshSerialize[−][src]

pub trait BorshSerialize {
    fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>;

    fn try_to_vec(&self) -> Result<Vec<u8>> { ... }
}

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: Write>(&self, writer: &mut W) -> Result<()>

Provided methods

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

Serialize this instance into a vector of bytes.

Implementations on Foreign Types

impl BorshSerialize for u8

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

fn u8_slice(slice: &[Self]) -> Option<&[u8 ]>

impl BorshSerialize for i8

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

impl BorshSerialize for i16

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

impl BorshSerialize for i32

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

impl BorshSerialize for i64

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

impl BorshSerialize for i128

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

impl BorshSerialize for u16

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

impl BorshSerialize for u32

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

impl BorshSerialize for u64

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

impl BorshSerialize for u128

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

impl BorshSerialize for usize

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

impl BorshSerialize for f32

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

impl BorshSerialize for f64

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

impl BorshSerialize for bool

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

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

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

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

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

impl BorshSerialize for str

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

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

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

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

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

impl BorshSerialize for SocketAddr

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

impl BorshSerialize for SocketAddrV4

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

impl BorshSerialize for SocketAddrV6

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

impl BorshSerialize for Ipv4Addr

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

impl BorshSerialize for Ipv6Addr

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl BorshSerialize for ()

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

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

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

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

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

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

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

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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: Write>(&self, writer: &mut W) -> Result<()>

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

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

Implementors

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

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

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

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

impl BorshSerialize for String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl BorshSerialize for AgnosticOrderbookInstruction where Params: BorshSerialize, Params: BorshSerialize, Params: BorshSerialize, Params: BorshSerialize,`

`impl BorshSerialize for AccountTag`

`impl BorshSerialize for Side`

`impl BorshSerialize for SelfTradeBehavior`

`impl BorshSerialize for MarketState where AccountTag: BorshSerialize, Pubkey: BorshSerialize, Pubkey: BorshSerialize, Pubkey: BorshSerialize, Pubkey: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize,`

`impl BorshSerialize for Event where Side: BorshSerialize, u128: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, Vec<u8>: BorshSerialize, Vec<u8>: BorshSerialize, Side: BorshSerialize, u128: BorshSerialize, u64: BorshSerialize, bool: BorshSerialize, Vec<u8>: BorshSerialize,`

`impl BorshSerialize for EventQueueHeader where AccountTag: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u32: BorshSerialize,`

`impl BorshSerialize for OrderSummary where Option<u128>: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize,`

`impl BorshSerialize for Params where u128: BorshSerialize,`

`impl BorshSerialize for Params`

`impl BorshSerialize for Params where u64: BorshSerialize,`

`impl BorshSerialize for Params where Pubkey: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize,`

`impl BorshSerialize for Params where u64: BorshSerialize, u64: BorshSerialize, u64: BorshSerialize, Side: BorshSerialize, u64: BorshSerialize, Vec<u8>: BorshSerialize, bool: BorshSerialize, bool: BorshSerialize, SelfTradeBehavior: BorshSerialize,`

`impl BorshSerialize for Hash`

`impl BorshSerialize for Hash`

`impl BorshSerialize for Pubkey`

`impl BorshSerialize for Secp256k1Pubkey`