Trait concordium_std::Serial

pub trait Serial {
    pub fn serial<W>(&self, _out: &mut W) -> Result<(), <W as Write>::Err>
    where
        W: Write;
}

The Serial trait provides a means of writing structures into byte-sinks (Write).

Can be derived using #[derive(Serial)] for most cases.

Required methods

pub fn serial<W>(&self, _out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

Attempt to write the structure into the provided writer, failing if only part of the structure could be written.

NB: We use Result instead of Option for better composability with other constructs.

Loading content...

Implementations on Foreign Types

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for u32

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for u8

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for u16

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for i8

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for u64

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for i64

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<T> Serial for Box<T, Global> where
    T: Serial, 

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for i32

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for bool

Serialization of bool encodes it as a single byte, false is represented by 0u8 and true is only represented by 1u8.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialized if the Option is a None we write 0u8. If Some, we write 1u8 followed by the serialization of the contained T.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for i16

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

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

Serialize the array by writing elements consecutively starting at 0. Since the length of the array is known statically it is not written out explicitly. Thus serialization of the array A and the slice &A[..] differ.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<X, Y> Serial for (X, Y) where
    Y: Serial,
    X: Serial, 

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

Loading content...

Implementors

impl Serial for Address

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Fields

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for SizeLength

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Type

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Contract

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Module

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for AccountAddress

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Amount

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for AttributeTag

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for ChainMetadata

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for ContractAddress

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Duration

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Policy<Vec<(AttributeTag, Vec<u8, Global>), Global>>

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for String

Serialized by writing an u32 representing the number of bytes for a utf8-encoding of the string, then writing the bytes. Similar to Vec<_>.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl Serial for Timestamp

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<C> Serial for PhantomData<C> where
    C: ?Sized, 

pub fn serial<W>(&self, _out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<K> Serial for BTreeSet<K> where
    K: Serial + Ord, 

The serialization of sets encodes their size as a u32. This should be sufficient for all realistic use cases in smart contracts. They are serialized in canonical order (increasing)

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<K, V> Serial for BTreeMap<K, V> where
    K: Serial + Ord,
    V: Serial, 

The serialization of maps encodes their size as a u32. This should be sufficient for all realistic use cases in smart contracts. They are serialized in ascending order.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

impl<T> Serial for Vec<T, Global> where
    T: Serial, 

Serialized by writing an u32 representing the number of elements, followed by the elements serialized according to their type T.

pub fn serial<W>(&self, out: &mut W) -> Result<(), <W as Write>::Err> where
    W: Write, 

Loading content...