Trait concordium_std::Deserial

pub trait Deserial {
    pub fn deserial<R>(_source: &mut R) -> Result<Self, ParseError>
    where
        R: Read;
}

The Deserial trait provides a means of reading structures from byte-sinks (Read).

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

Required methods

pub fn deserial<R>(_source: &mut R) -> Result<Self, ParseError> where
    R: Read, 

Attempt to read a structure from a given source, failing if an error occurs during deserialization or reading.

Loading content...

Implementations on Foreign Types

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 14], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 15], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 19], ParseError> where
    R: Read, 

impl Deserial for String

Deserial by reading an u32 representing the number of bytes, then takes that number of bytes and tries to decode using utf8.

pub fn deserial<R>(source: &mut R) -> Result<String, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 8], ParseError> where
    R: Read, 

impl Deserial for i8

pub fn deserial<R>(source: &mut R) -> Result<i8, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 18], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<Box<T, Global>, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 12], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 5], ParseError> where
    R: Read, 

impl Deserial for u16

pub fn deserial<R>(source: &mut R) -> Result<u16, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 20], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<(X, Y), ParseError> where
    R: Read, 

impl Deserial for u8

pub fn deserial<R>(source: &mut R) -> Result<u8, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 23], ParseError> where
    R: Read, 

impl Deserial for i16

pub fn deserial<R>(source: &mut R) -> Result<i16, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 31], ParseError> where
    R: Read, 

impl Deserial for bool

Deserializing a bool reads one byte, and returns the value false if the byte is 0u8 and true if the byte is 1u8, every other value results in an error.

pub fn deserial<R>(source: &mut R) -> Result<bool, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 10], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 2], ParseError> where
    R: Read, 

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

Deserial by reading one byte, where 0u8 represents None and 1u8 represents Some, every other value results in an error. In the case of Some we deserialize using the contained T.

pub fn deserial<R>(source: &mut R) -> Result<Option<T>, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 26], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 3], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 27], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 11], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 16], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 13], ParseError> where
    R: Read, 

impl Deserial for i64

pub fn deserial<R>(source: &mut R) -> Result<i64, ParseError> where
    R: Read, 

impl Deserial for i32

pub fn deserial<R>(source: &mut R) -> Result<i32, ParseError> where
    R: Read, 

impl Deserial for u32

pub fn deserial<R>(source: &mut R) -> Result<u32, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 22], ParseError> where
    R: Read, 

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

Deserialized by reading an u32 representing the number of elements, then deserializing that many elements of type T.

pub fn deserial<R>(source: &mut R) -> Result<Vec<T, Global>, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 25], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 29], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 6], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 1], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 21], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 28], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 24], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 9], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 7], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 17], ParseError> where
    R: Read, 

impl Deserial for u64

pub fn deserial<R>(source: &mut R) -> Result<u64, ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 30], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 32], ParseError> where
    R: Read, 

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

pub fn deserial<R>(source: &mut R) -> Result<[T; 4], ParseError> where
    R: Read, 

Loading content...

Implementors

impl Deserial for Address

pub fn deserial<R>(source: &mut R) -> Result<Address, ParseError> where
    R: Read, 

impl Deserial for Fields

pub fn deserial<R>(source: &mut R) -> Result<Fields, ParseError> where
    R: Read, 

impl Deserial for SizeLength

pub fn deserial<R>(source: &mut R) -> Result<SizeLength, ParseError> where
    R: Read, 

impl Deserial for Type

pub fn deserial<R>(source: &mut R) -> Result<Type, ParseError> where
    R: Read, 

impl Deserial for Contract

pub fn deserial<R>(source: &mut R) -> Result<Contract, ParseError> where
    R: Read, 

impl Deserial for Module

pub fn deserial<R>(source: &mut R) -> Result<Module, ParseError> where
    R: Read, 

impl Deserial for AccountAddress

pub fn deserial<R>(source: &mut R) -> Result<AccountAddress, ParseError> where
    R: Read, 

impl Deserial for Amount

pub fn deserial<R>(source: &mut R) -> Result<Amount, ParseError> where
    R: Read, 

impl Deserial for AttributeTag

pub fn deserial<R>(source: &mut R) -> Result<AttributeTag, ParseError> where
    R: Read, 

impl Deserial for ChainMetadata

pub fn deserial<R>(source: &mut R) -> Result<ChainMetadata, ParseError> where
    R: Read, 

impl Deserial for ContractAddress

pub fn deserial<R>(source: &mut R) -> Result<ContractAddress, ParseError> where
    R: Read, 

impl Deserial for Duration

pub fn deserial<R>(source: &mut R) -> Result<Duration, ParseError> where
    R: Read, 

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

pub fn deserial<R>(
    source: &mut R
) -> Result<Policy<Vec<(AttributeTag, Vec<u8, Global>), Global>>, ParseError> where
    R: Read, 

impl Deserial for Timestamp

pub fn deserial<R>(source: &mut R) -> Result<Timestamp, ParseError> where
    R: Read, 

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

The deserialization of sets assumes their size as a u32.

WARNING: Deserialization does not ensure the ordering of the keys, it only ensures that there are no duplicates. Serializing a BTreeSet via its Serial instance will lay out elements by the increasing order. As a consequence deserializing, and serializing back is in general not the identity. This could have consequences if the data is hashed, or the byte representation is used in some other way directly. In those cases the a canonical order should be ensured to avoid subtle, difficult to diagnose, bugs.

pub fn deserial<R>(source: &mut R) -> Result<BTreeSet<K>, ParseError> where
    R: Read, 

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

The deserialization of maps assumes their size as a u32.

WARNING: Deserialization does not ensure the ordering of the keys, it only ensures that there are no duplicates. Serializing a BTreeMap via its Serial instance will lay out elements by the increasing order of keys. As a consequence deserializing, and serializing back is in general not the identity. This could have consequences if the data is hashed, or the byte representation is used in some other way directly. In those cases the a canonical order should be ensured to avoid subtle, difficult to diagnose, bugs.

pub fn deserial<R>(source: &mut R) -> Result<BTreeMap<K, V>, ParseError> where
    R: Read, 

Loading content...