Enum DynRawFallback

pub enum DynRawFallback<T> {
    Raw {
        module_instance_id: ModuleInstanceId,
        raw: Vec<u8>,
    },
    Decoded(T),
}

A type that decodes module_instance_id-prefixed Ts even when corresponding Decoder is not available.

All dyn-module types are encoded as:

module_instance_id | len_u64 | data

So clients that don’t have a corresponding module, can read the len_u64 and skip the amount of data specified in it.

This type makes it more convenient. It’s possible to attempt to retry decoding after more modules become available by using DynRawFallback::redecode_raw.

Notably this struct does not ignore any errors. It only skips decoding when the module decoder is not available.

Variants

Raw

Fields

module_instance_id: ModuleInstanceId

raw: Vec<u8>

Decoded(T)

Implementations

impl<T> DynRawFallback<T>

where T: Decodable + 'static,

pub fn decoded(self) -> Option<T>

Get the decoded T or None if not decoded yet

pub fn expect_decoded(self) -> T

Convert into the decoded T and panic if not decoded yet

pub fn expect_decoded_ref(&self) -> &T

Get the decoded T and panic if not decoded yet

pub fn redecode_raw( self, decoders: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Attempt to re-decode raw values with new set of of modules

In certain contexts it might be necessary to try again with a new set of modules.

Trait Implementations

impl<T: Clone> Clone for DynRawFallback<T>

fn clone(&self) -> DynRawFallback<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for DynRawFallback<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Decodable for DynRawFallback<T>

where T: Decodable + 'static,

fn consensus_decode_from_finite_reader<R: Read>( reader: &mut R, decoders: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode Self from a size-limited reader.

fn consensus_decode<R: Read>( r: &mut R, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode an object with a well-defined format.

fn consensus_decode_hex( hex: &str, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

Decode an object from hex

fn consensus_decode_vec( bytes: Vec<u8>, modules: &ModuleDecoderRegistry, ) -> Result<Self, DecodeError>

impl<'de, T> Deserialize<'de> for DynRawFallback<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Encodable for DynRawFallback<T>

where T: Encodable,

fn consensus_encode<W: Write>(&self, writer: &mut W) -> Result<usize, Error>

Encode an object with a well-defined format. Returns the number of bytes written on success.

fn consensus_encode_to_vec(&self) -> Vec<u8>

Self::consensus_encode to newly allocated Vec<u8>

fn consensus_encode_to_hex(&self) -> String

Encode and convert to hex string representation

fn consensus_encode_to_len(&self) -> usize

Encode without storing the encoding, return the size

fn consensus_hash<H>(&self) -> H

where H: Hash, H::Engine: Write,

Generate a SHA256 hash of the consensus encoding using the default hash engine for H.

impl<T> From<T> for DynRawFallback<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq> PartialEq for DynRawFallback<T>

fn eq(&self, other: &DynRawFallback<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for DynRawFallback<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for DynRawFallback<T>

impl<T> StructuralPartialEq for DynRawFallback<T>