Enum NodeRef 

pub enum NodeRef {
    Node(Arc<Node>, OnceLock<NodeHash>),
    Hash(NodeHash),
}

A reference to a node.

Explicit rkyv bounds are needed because this is a recursive type, whose bounds can’t be automatically resolved.

Variants

Node(Arc<Node>, OnceLock<NodeHash>)

The node is embedded within the reference.

Hash(NodeHash)

The node is in the database, referenced by its hash.

Implementations

impl NodeRef

pub fn get_node( &self, db: &dyn TrieDB, path: Nibbles, ) -> Result<Option<Arc<Node>>, TrieError>

Gets a shared reference to the inner node. Requires that the trie is in a consistent state, ie that all leaves being pointed are in the database. Outside of snapsync this should always be the case.

pub fn get_node_checked( &self, db: &dyn TrieDB, path: Nibbles, ) -> Result<Option<Arc<Node>>, TrieError>

Gets a shared reference to the inner node, checking its hash. Returns Ok(None) if the hash is invalid.

Uses NativeCrypto directly because this function is only reachable from native storage/sync paths (get_root_node, get_proof, validate, verify_range, trie iterator) — never from the guest program path, which traverses via Node::get().

pub fn is_valid(&self) -> bool

pub fn commit( &mut self, path: Nibbles, acc: &mut Vec<(Nibbles, Vec<u8>)>, crypto: &dyn Crypto, ) -> NodeHash

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

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

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

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

pub fn clear_hash(&mut self)

Resets the memoized hash of this Node

This is used when mutating a node in place, in which case the memoized hash is not valid anymore.

Trait Implementations

impl Archive for NodeRef

where Skip: ArchiveWith<OnceLock<NodeHash>>, NodeHash: Archive,

type Archived = ArchivedNodeRef

The archived representation of this type.

type Resolver = NodeRefResolver

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 as Archive>::Resolver, out: Place<<Self as Archive>::Archived>, )

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

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.

impl Clone for NodeRef

fn clone(&self) -> NodeRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeRef

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

Formats the value using the given formatter.

impl Default for NodeRef

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NodeRef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<NodeRef, __D> for Archived<NodeRef>

where __D: Pooling + Fallible + ?Sized, __D::Error: Source, Skip: ArchiveWith<OnceLock<NodeHash>> + DeserializeWith<<Skip as ArchiveWith<OnceLock<NodeHash>>>::Archived, OnceLock<NodeHash>, __D>, NodeHash: Archive, <NodeHash as Archive>::Archived: Deserialize<NodeHash, __D>,

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

Deserializes using the given deserializer

impl From<Arc<Node>> for NodeRef

fn from(value: Arc<Node>) -> Self

Converts to this type from the input type.

impl From<Node> for NodeRef

fn from(value: Node) -> Self

Converts to this type from the input type.

impl From<NodeHash> for NodeRef

fn from(value: NodeHash) -> Self

Converts to this type from the input type.

impl PartialEq for NodeRef

fn eq(&self, other: &Self) -> 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 Serialize for NodeRef

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S> Serialize<__S> for NodeRef

where __S: Writer + Allocator + Sharing + Fallible + ?Sized, __S::Error: Source, Skip: SerializeWith<OnceLock<NodeHash>, __S>, NodeHash: 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.