Trait crypto_common::hazmat::SerializableState

pub trait SerializableStatewhere
    Self: Sized,{
    type SerializedStateSize: ArraySize;

    // Required methods
    fn serialize(&self) -> SerializedState<Self>;
    fn deserialize(
        serialized_state: &SerializedState<Self>,
    ) -> Result<Self, DeserializeStateError>;
}

Expand description

Types which can serialize the internal state and be restored from it.

§SECURITY WARNING

Serialized state may contain sensitive data.

Required Associated Types§

type SerializedStateSize: ArraySize

Size of serialized internal state.

Required Methods§

fn serialize(&self) -> SerializedState<Self>

Serialize and return internal state.

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

Create an object from serialized internal state.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

impl SerializableState for u8

type SerializedStateSize = UInt<UTerm, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for u16

type SerializedStateSize = UInt<UInt<UTerm, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for u32

type SerializedStateSize = UInt<UInt<UInt<UTerm, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for u64

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for u128

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 1]

type SerializedStateSize = UInt<UTerm, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 2]

type SerializedStateSize = UInt<UInt<UTerm, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 3]

type SerializedStateSize = UInt<UInt<UTerm, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 4]

type SerializedStateSize = UInt<UInt<UInt<UTerm, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 5]

type SerializedStateSize = UInt<UInt<UInt<UTerm, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 6]

type SerializedStateSize = UInt<UInt<UInt<UTerm, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 7]

type SerializedStateSize = UInt<UInt<UInt<UTerm, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 8]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 9]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 10]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 11]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 12]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 13]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 14]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 15]

type SerializedStateSize = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 16]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 17]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 18]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 19]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 20]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 21]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 22]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 23]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 24]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 25]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 26]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 27]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 28]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 29]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 30]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 31]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 32]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 33]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 34]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 35]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 36]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 37]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 38]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 39]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 40]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 41]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 42]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 43]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 44]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 45]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 46]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 47]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 48]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 49]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 50]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 51]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 52]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 53]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 54]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 55]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 56]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 57]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 58]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 59]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 60]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 61]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 62]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 63]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 64]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 96]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 128]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 192]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 256]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 384]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 448]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 512]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 768]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 896]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 1024]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 2048]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 4096]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u8; 8192]

type SerializedStateSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 1]

type SerializedStateSize = <UInt<UTerm, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 2]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B0> as Mul>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 3]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 4]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 5]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 6]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 7]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 8]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 9]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 10]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 11]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 12]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 13]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 14]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 15]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 16]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 17]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 18]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 19]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 20]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 21]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 22]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 23]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 24]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 25]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 26]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 27]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 28]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 29]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 30]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 31]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 32]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 48]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 96]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 128]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 192]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 256]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 384]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 448]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 512]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 2048]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u16; 4096]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UTerm, B1>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 1]

type SerializedStateSize = <UInt<UTerm, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 2]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 3]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 4]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Mul>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 5]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 6]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 7]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 8]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 9]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 10]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 11]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 12]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 13]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 14]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 15]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 16]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 24]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 32]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 48]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 64]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 96]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 128]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 192]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 256]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 512]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 1024]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u32; 2048]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 1]

type SerializedStateSize = <UInt<UTerm, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 2]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 3]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 4]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 5]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 6]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 7]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 8]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0> as Mul>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 12]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 16]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 24]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 32]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 48]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 64]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 96]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 128]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 256]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 512]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u64; 1024]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 1]

type SerializedStateSize = <UInt<UTerm, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 2]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 3]

type SerializedStateSize = <UInt<UInt<UTerm, B1>, B1> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 4]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 6]

type SerializedStateSize = <UInt<UInt<UInt<UTerm, B1>, B1>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 8]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0> as Mul>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 12]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 16]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 24]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 32]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 48]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 64]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 128]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 256]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

impl SerializableState for [u128; 512]

type SerializedStateSize = <UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0> as Mul<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>>::Output

fn serialize(&self) -> SerializedState<Self>

fn deserialize( serialized_state: &SerializedState<Self>, ) -> Result<Self, DeserializeStateError>

Implementors§