Trait concordium_std::Serial

pub trait Serial {
    // Required method
    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

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.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Serial for &str

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

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.

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

where W: Write,

impl Serial for i8

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

where W: Write,

impl Serial for i16

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

where W: Write,

impl Serial for i32

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

where W: Write,

impl Serial for i64

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

where W: Write,

impl Serial for i128

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

where W: Write,

impl Serial for u8

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

where W: Write,

impl Serial for u16

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

where W: Write,

impl Serial for u32

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

where W: Write,

impl Serial for u64

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

where W: Write,

impl Serial for u128

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

where W: Write,

impl Serial for ()

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

where W: Write,

impl<A> Serial for &A

where A: Serial,

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

where W: Write,

impl<A, B> Serial for (A, B)

where A: Serial, B: Serial,

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

where W: Write,

impl<A, B, C> Serial for (A, B, C)

where A: Serial, B: Serial, C: Serial,

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

where W: Write,

impl<A, B, C, D> Serial for (A, B, C, D)

where A: Serial, B: Serial, C: Serial, D: Serial,

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

where W: Write,

impl<A, B, C, D, E> Serial for (A, B, C, D, E)

where A: Serial, B: Serial, C: Serial, D: Serial, E: Serial,

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

where W: Write,

impl<A, B, C, D, E, F> Serial for (A, B, C, D, E, F)

where A: Serial, B: Serial, C: Serial, D: Serial, E: Serial, F: Serial,

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

where W: Write,

impl<K> Serial for HashSet<K, BuildHasherDefault<FnvHasher>>

where K: Serial,

sufficient for all realistic use cases in smart contracts. They are serialized in no particular order.

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

where W: Write,

impl<K, V> Serial for HashMap<K, V, BuildHasherDefault<FnvHasher>>

where K: Serial, 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 no particular order.

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.

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

where W: Write,

impl<T, const N: usize> Serial for [T; N]

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.

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

where W: Write,

Implementors

impl Serial for Address

impl Serial for PublicKey

impl Serial for Signature

impl Serial for Fields

impl Serial for FunctionV1

impl Serial for SizeLength

impl Serial for Type

impl Serial for VersionedModuleSchema

impl Serial for ContractV0

impl Serial for ContractV1

impl Serial for ContractV2

impl Serial for ContractV3

impl Serial for FunctionV2

impl Serial for ModuleV0

impl Serial for ModuleV1

impl Serial for ModuleV2

impl Serial for ModuleV3

impl Serial for AccountAddress

impl Serial for AccountBalance

impl Serial for AccountPublicKeys

impl Serial for AccountSignatures

impl Serial for Amount

impl Serial for AttributeTag

impl Serial for AttributeValue

impl Serial for ChainMetadata

impl Serial for ContractAddress

impl Serial for CredentialPublicKeys

impl Serial for CredentialSignatures

impl Serial for Duration

impl Serial for ExchangeRate

impl Serial for ExchangeRates

impl Serial for HashKeccak256

impl Serial for HashSha2256

impl Serial for HashSha3256

impl Serial for MetadataUrl

impl Serial for OwnedContractName

impl Serial for OwnedEntrypointName

impl Serial for OwnedParameter

impl Serial for OwnedReceiveName

impl Serial for Policy<Vec<(AttributeTag, AttributeValue)>>

impl Serial for PublicKeyEcdsaSecp256k1

impl Serial for PublicKeyEd25519

impl Serial for SignatureEcdsaSecp256k1

impl Serial for SignatureEd25519

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 &str.

impl Serial for Timestamp

impl<'a> Serial for ContractName<'a>

impl<'a> Serial for EntrypointName<'a>

impl<'a> Serial for Parameter<'a>

impl<'a> Serial for ReceiveName<'a>

impl<C> Serial for PhantomData<C>

where C: ?Sized,

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)

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.

impl<K, V, S> Serial for StateMap<K, V, S>

impl<K, V, const M: usize> Serial for StateBTreeMap<K, V, M>

where K: Serial, V: Serial,

impl<Kind> Serial for NonZeroThresholdU8<Kind>

impl<Purpose> Serial for HashBytes<Purpose>

impl<T> Serial for Box<T>

where T: Serial,

impl<T> Serial for Vec<T>

where T: Serial,

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

impl<T, S> Serial for StateSet<T, S>

impl<T: Serial, S: HasStateApi> Serial for StateBox<T, S>

impl<const M: usize, K> Serial for StateBTreeSet<K, M>