Struct CNodeCap 

pub struct CNodeCap<O = Box<Cap>> {
    pub slots: CNodeSlots<O>,
}

CNode cap: a sparse, direct Key -> CapHashOrRef<O> map.

rkyv (the wire form) is derived; the derive adds a slots: Archive field bound, which for the wire payload resolves via CapHashOrRef<Box<Cap>>: Archive (gated on Box<Cap>: WireOwned, a leaf marker — no recursion into Cap: Archive). A non-wire payload such as Box<CachedCap> does not satisfy the field bound, so a CNodeCap<Box<CachedCap>> has no rkyv impl and cannot cross the wire — non-serialisable by construction. Clone / Debug / Default / HashTreeRoot are hand-rolled with payload-specific bounds (a blanket derive would over-constrain Box<Cap>, which is not Default, and ssz_derive::HashTreeRoot adds no bound at all, so it would not compile for a generic field).

Fields

slots: CNodeSlots<O>

Sparse slot table keyed by logical Key. Absent keys are empty; a Missing(h) entry substitutes losslessly for the value rooting at h.

Implementations

impl<O> CNodeCap<O>

pub fn new() -> Self

Construct an empty CNode (no slots). A CNode grows on demand and is bounded by storage quota, not a fixed slot count.

pub fn commitment_key(key: &Key) -> [u8; 32]

Commitment radix key for a logical key: Hasher(key).

This is intentionally not used by ordinary get / set / take.

pub fn peek_key(&self, k: &[u8]) -> Option<&CapHashOrRef<O>>

Borrow the cap bound to logical key k without cloning — the read-only peek used to inspect an Owned cap (e.g. read a callee’s image_hash to price a CALL) before deciding whether to take_key it. None for an absent key or a Missing(_) placeholder.

pub fn set_key( &mut self, k: &[u8], target: Option<CapHashOrRef<O>>, ) -> Option<CapHashOrRef<O>>

Bind logical key k to target, or clear the binding if target is None. Returns the prior materialized target, if any — moved out, not cloned, so a CapHashOrRef::Owned(O) transfers with no deep copy (the zero-copy cnode move).

pub fn take_key(&mut self, k: &[u8]) -> Option<CapHashOrRef<O>>

Take the binding at logical key k, leaving it empty. Returns the prior materialized target (or None), moved out — the zero-copy half of an Owned cnode-to-cnode (or frame-to-frame) move.

pub fn set( &mut self, key: &Key, target: Option<CapHashOrRef<O>>, ) -> Result<Option<CapHashOrRef<O>>, CapError>

Bind key to target, or clear it if None. Returns the prior materialized target, if any. The radix map is unbounded, so this is infallible; the Result is retained for ABI compatibility with the pervasive ?-using call sites.

pub fn take(&mut self, key: &Key) -> Result<Option<CapHashOrRef<O>>, CapError>

Take the binding at key, leaving it empty. Returns the prior materialized target (or None).

impl<O: Clone> CNodeCap<O>

pub fn get_key(&self, k: &[u8]) -> Option<CapHashOrRef<O>>

Look up the cap bound to logical key k. Returns None for an absent key or a Missing(_) placeholder (callers needing to tell “absent” from “missing placeholder” apart inspect self.slots).

pub fn get(&self, key: &Key) -> Option<CapHashOrRef<O>>

Look up the slot named by key. See CNodeCap::get_key for the placeholder semantics.

Trait Implementations

impl<O> Archive for CNodeCap<O>

where CNodeSlots<O>: Archive,

type Archived = ArchivedCNodeCap<O>

The archived representation of this type.

type Resolver = CNodeCapResolver<O>

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.

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<O: Clone> Clone for CNodeCap<O>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug> Debug for CNodeCap<O>

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

Formats the value using the given formatter.

impl<O> Default for CNodeCap<O>

fn default() -> Self

Returns the “default value” for a type.

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

where CNodeSlots<O>: Archive, <CNodeSlots<O> as Archive>::Archived: Deserialize<CNodeSlots<O>, __D>,

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

Deserializes using the given deserializer

impl<O> HashTreeRoot for CNodeCap<O>

where O: Clone, CapHashOrRef<O>: HashTreeRoot,

fn hash_tree_root<D: Digest<OutputSize = U32>>(&self) -> [u8; 32]

Compute the hash tree root using D as the underlying hash.

impl<__S: Fallible + ?Sized, O> Serialize<__S> for CNodeCap<O>

where CNodeSlots<O>: 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.