rustmax::sha2::digest::common::hazmat

Trait SerializableState

pub trait SerializableState: Sized {
    type SerializedStateSize: ArraySize;

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

Expand description

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

§Compatibility

Serialized state can be assumed to be stable across backwards compatible versions of an implementation crate, i.e. any 0.x.y version of a crate should be able to decode data serialized with any other 0.x.z version, but it may not be able to correctly decode data serialized with a non-x version.

This guarantee is a subject to issues such as security fixes.

§SECURITY WARNING

Serialized state may contain sensitive data.

Required Associated Types§

Source

type SerializedStateSize: ArraySize

Size of serialized internal state.

Required Methods§

Source

fn serialize(&self) -> Array<u8, Self::SerializedStateSize>

Serialize and return internal state.

Source

fn deserialize( serialized_state: &Array<u8, Self::SerializedStateSize>, ) -> Result<Self, DeserializeStateError>

Create an object from serialized internal state.

§Errors

If the serialized state could not be deserialized successfully.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Trait SerializableState Copy item path

§Compatibility

§SECURITY WARNING

Required Associated Types§

type SerializedStateSize: ArraySize

Required Methods§

fn serialize(&self) -> Array<u8, Self::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, Self::SerializedStateSize>, ) -> Result<Self, DeserializeStateError>

§Errors

Dyn Compatibility§

Implementations on Foreign Types§

impl SerializableState for Sha1

type SerializedStateSize = <<Sha1Core as SerializableState>::SerializedStateSize as Add<<<Sha1Core as BlockSizeUser>::BlockSize as Add<<<Sha1Core as BufferKindUser>::BufferKind as Sealed>::Overhead>>::Output>>::Output

fn serialize( &self, ) -> Array<u8, <Sha1 as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <Sha1 as SerializableState>::SerializedStateSize>, ) -> Result<Sha1, DeserializeStateError>

impl SerializableState for Sha1Core

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

fn serialize( &self, ) -> Array<u8, <Sha1Core as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <Sha1Core as SerializableState>::SerializedStateSize>, ) -> Result<Sha1Core, DeserializeStateError>

impl SerializableState for [u8; 1]

type SerializedStateSize = UInt<UTerm, B1>

fn serialize( &self, ) -> Array<u8, <[u8; 1] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 1] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 1], DeserializeStateError>

impl SerializableState for [u8; 2]

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

fn serialize( &self, ) -> Array<u8, <[u8; 2] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 2] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 2], DeserializeStateError>

impl SerializableState for [u8; 3]

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

fn serialize( &self, ) -> Array<u8, <[u8; 3] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 3] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 3], DeserializeStateError>

impl SerializableState for [u8; 4]

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

fn serialize( &self, ) -> Array<u8, <[u8; 4] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 4] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 4], DeserializeStateError>

impl SerializableState for [u8; 5]

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

fn serialize( &self, ) -> Array<u8, <[u8; 5] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 5] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 5], DeserializeStateError>

impl SerializableState for [u8; 6]

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

fn serialize( &self, ) -> Array<u8, <[u8; 6] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 6] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 6], DeserializeStateError>

impl SerializableState for [u8; 7]

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

fn serialize( &self, ) -> Array<u8, <[u8; 7] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 7] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 7], DeserializeStateError>

impl SerializableState for [u8; 8]

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

fn serialize( &self, ) -> Array<u8, <[u8; 8] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 8] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 8], DeserializeStateError>

impl SerializableState for [u8; 9]

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

fn serialize( &self, ) -> Array<u8, <[u8; 9] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 9] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 9], DeserializeStateError>

impl SerializableState for [u8; 10]

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

fn serialize( &self, ) -> Array<u8, <[u8; 10] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 10] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 10], DeserializeStateError>

impl SerializableState for [u8; 11]

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

fn serialize( &self, ) -> Array<u8, <[u8; 11] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 11] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 11], DeserializeStateError>

impl SerializableState for [u8; 12]

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

fn serialize( &self, ) -> Array<u8, <[u8; 12] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 12] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 12], DeserializeStateError>

impl SerializableState for [u8; 13]

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

fn serialize( &self, ) -> Array<u8, <[u8; 13] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 13] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 13], DeserializeStateError>

impl SerializableState for [u8; 14]

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

fn serialize( &self, ) -> Array<u8, <[u8; 14] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 14] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 14], DeserializeStateError>

impl SerializableState for [u8; 15]

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

fn serialize( &self, ) -> Array<u8, <[u8; 15] as SerializableState>::SerializedStateSize>

fn deserialize( serialized_state: &Array<u8, <[u8; 15] as SerializableState>::SerializedStateSize>, ) -> Result<[u8; 15], DeserializeStateError>

impl SerializableState for [u8; 16]

Trait SerializableState