Struct LeafNode 

pub struct LeafNode {
    pub partial: Nibbles,
    pub value: ValueRLP,
}

Leaf Node of an an Ethereum Compatible Patricia Merkle Trie Contains the node’s hash, value & path

Fields

partial: Nibbles

value: ValueRLP

Implementations

impl LeafNode

pub const fn new(partial: Nibbles, value: ValueRLP) -> Self

Creates a new leaf node and stores the given (path, value) pair

pub fn get(&self, path: Nibbles) -> Result<Option<ValueRLP>, TrieError>

Returns the stored value if the given path matches the stored path

pub fn insert( &mut self, path: Nibbles, value: ValueOrHash, ) -> Result<Option<Node>, TrieError>

Stores the received value and returns the new root of the subtrie previously consisting of self

pub fn remove( &mut self, path: Nibbles, ) -> Result<(Option<NodeRemoveResult>, Option<ValueRLP>), TrieError>

Removes own value if the path matches own path and returns self and the value if it was removed

pub fn compute_hash(&self, crypto: &dyn Crypto) -> NodeHash

Computes the node’s hash

pub fn compute_hash_no_alloc( &self, buf: &mut Vec<u8>, crypto: &dyn Crypto, ) -> NodeHash

Computes the node’s hash, using the provided buffer

pub fn get_path(&self, node_path: &mut Vec<Vec<u8>>) -> Result<(), TrieError>

Encodes the node and appends it to node_path if the encoded node is 32 or more bytes long

pub fn take(&mut self) -> Self

Creates a new node by emptying self partial and its value

This is a way to “consume” the node when we just have a mutable reference to it

Trait Implementations

impl Archive for LeafNode

where Nibbles: Archive, ValueRLP: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedLeafNode

The archived representation of this type.

type Resolver = LeafNodeResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for LeafNode

fn clone(&self) -> LeafNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LeafNode

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

Formats the value using the given formatter.

impl Default for LeafNode

fn default() -> LeafNode

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LeafNode

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<LeafNode, __D> for Archived<LeafNode>

where Nibbles: Archive, <Nibbles as Archive>::Archived: Deserialize<Nibbles, __D>, ValueRLP: Archive, <ValueRLP as Archive>::Archived: Deserialize<ValueRLP, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<LeafNode, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Eq for LeafNode

impl From<LeafNode> for Node

fn from(val: LeafNode) -> Self

Converts to this type from the input type.

impl PartialEq for LeafNode

fn eq(&self, other: &LeafNode) -> 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 RLPEncode for LeafNode

fn encode(&self, buf: &mut dyn BufMut)

fn length(&self) -> usize

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

impl Serialize for LeafNode

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for LeafNode

where Nibbles: Serialize<__S>, ValueRLP: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl StructuralPartialEq for LeafNode