Enum DataOrHash

pub enum DataOrHash<H, L>
where
    H: Hash,
{
    Data(L),
    Hash(<H as Hash>::Output),
}

An element representing either full data or its hash.

See Compact to see how it may be used in practice to reduce the size of proofs in case multiple LeafDataProviders are composed together. This is also used internally by the MMR to differentiate leaf nodes (data) and inner nodes (hashes).

DataOrHash::hash method calculates the hash of this element in its compact form, so should be used instead of hashing the encoded form (which will always be non-compact).

Variants

Data(L)

Arbitrary data in its full form.

Hash(<H as Hash>::Output)

A hash of some data.

Implementations

impl<H, L> DataOrHash<H, L>

where H: Hash, L: FullLeaf,

pub fn hash(&self) -> <H as Hash>::Output

Retrieve a hash of this item.

Depending on the node type it’s going to either be a contained value for DataOrHash::Hash node, or a hash of SCALE-encoded DataOrHash::Data data.

Trait Implementations

impl<H, L> Clone for DataOrHash<H, L>

where H: Clone + Hash, L: Clone, <H as Hash>::Output: Clone,

fn clone(&self) -> DataOrHash<H, L>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<H, L> Debug for DataOrHash<H, L>

where H: Hash + Debug, L: Debug,

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

Formats the value using the given formatter.

impl<H, L> Decode for DataOrHash<H, L>

where H: Hash, L: FullLeaf + Decode,

fn decode<I>(value: &mut I) -> Result<DataOrHash<H, L>, Error>

where I: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<H, L> Encode for DataOrHash<H, L>

where H: Hash, L: FullLeaf,

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

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

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<H, L> From<L> for DataOrHash<H, L>

where H: Hash,

fn from(l: L) -> DataOrHash<H, L>

Converts to this type from the input type.

impl<H, L> PartialEq for DataOrHash<H, L>

where H: PartialEq + Hash, L: PartialEq, <H as Hash>::Output: PartialEq,

fn eq(&self, other: &DataOrHash<H, L>) -> 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<H, L> StructuralPartialEq for DataOrHash<H, L>

where H: Hash,