Struct Sp 

pub struct Sp<T, D = InMemoryDB>
where
    T: 'static + ?Sized,
    D: DB,
{
    pub child_repr: ArenaKey<<D as DB>::Hasher>,
    pub arena: Arena<D>,
    pub root: ArenaHash<<D as DB>::Hasher>,
    /* private fields */
}

A typed pointer to a value stored in the Arena.

An Sp<T> can be lazily initialized, in which case its internal T value won’t be loaded until access is attempted.

Fields

child_repr: ArenaKey<<D as DB>::Hasher>

This Sp represented as a child node (for easy access)

arena: Arena<D>

The arena this Sp points into

root: ArenaHash<<D as DB>::Hasher>

The persistent hash of data.

Implementations

impl<T, D> Sp<T, D>

where T: Storable<D>, D: DB,

pub fn new(value: T) -> Sp<T, D>

Allocates a new Sp against the default storage

impl<T, D> Sp<T, D>

where T: 'static + ?Sized, D: DB,

Constructors for Sp that take care of Arena ref counting.

pub fn into_tracked(&self) -> Sp<T, D>

Converts this Sp into one that is tracked directly, making it possible to lookup by its hash.

This forces the Sp to be considered a reference when used as a child of other Sps, and places it into internal caches, and eventually the database if persisted or a parent is persisted.

impl<D> Sp<dyn Any + Send + Sync, D>

where D: DB,

pub fn downcast<T>(&self) -> Option<Sp<T, D>>

where T: Any + Send + Sync,

Downcasts this dynamically typed pointer to a concrete type, if possible.

pub fn force_downcast<T>(&self) -> Sp<T, D>

where T: Any + Send + Sync,

Downcasts this dynamically typed pointer to a concrete type, but pushes through the cast regardless of the underlying type.

This will effectively unload the Sp, and construct a new lazy Sp with the same backing data. There is no way of knowing if this will succeed, as the lazy loading will defer failure to a context where a failure panics.

impl<T, D> Sp<T, D>

where T: Any + Send + Sync, D: DB,

pub fn upcast(&self) -> Sp<dyn Any + Send + Sync, D>

Casts this pointer into a dynamically typed Any pointer.

impl<T, D> Sp<T, D>

where D: DB, T: ?Sized,

pub fn is_lazy(&self) -> bool

Return true iff this Sp is lazy/unforced, i.e. its data has not yet been loaded.

If the Sp is lazy, it can be forced by dereferencing it.

pub fn hash(&self) -> ArenaHash<<D as DB>::Hasher>

Return hash of self and all children, cached from <T as Storable>::hash().

This is the root key of self, as a content-addressed Merkle node.

pub fn as_typed_key(&self) -> TypedArenaKey<T, <D as DB>::Hasher>

Returns the TypedArenaKey representation of this Sp, useful as a reference to persist.

pub fn as_child(&self) -> ArenaKey<<D as DB>::Hasher>

Returns the ArenaKey representation of this Sp, being either a ref to [Sp::hash], or the direct encoding for small children.

impl<T, D> Sp<T, D>

where T: Storable<D>, D: DB,

pub fn persist(&mut self)

Notify the storage back-end to increment the persist count on this object.

See [StorageBackend::persist].

Note: Due to a technicality in past behaviour, this converts the Sp into a Ref internally. In particular, this means that Sp::as_typed_key will provide different results before and after persisting. A change to this would be a major breaking change, and is therefore deferred.

pub fn unpersist(&self)

Notify the storage back-end to decrement the persist count on this object.

See [StorageBackend::unpersist].

pub fn into_inner(this: Sp<T, D>) -> Option<T>

Returns the content of this Sp, if this Sp is initialized, and is the only reference to its data. When the Sp is initialized, this behaves like Arc::into_inner.

impl<T, D> Sp<T, D>

where T: 'static + ?Sized, D: DB,

pub fn unload(&mut self)

Replace the self.data with an uninitialized lazy value.

Note: if there are multiple outstanding refs to the data in this Sp, e.g. because a clone of this Sp is owned by some larger data structure, then the underlying data won’t actually be dropped until all such Sps go out of scope or have unload called on them.

Warning: If this is the last reference to the Sp, and the Sp is not persisted, dereferencing it after unload may fail, because nothing is keeping the data alive.

impl<T, D> Sp<T, D>

where T: Storable<D>, D: DB,

pub fn serialize_to_node_list(&self) -> TopoSortedNodes

Topologically sort a sub-graph of storage into a sequence of nodes.

This will force and load all nodes in this sub-graph.

pub fn serialize_to_node_list_bounded( &self, raw_size_limit: u64, ) -> Option<TopoSortedNodes>

Topologically sort a sub-graph of storage into a sequence of nodes.

This will force and load all nodes in this sub-graph.

The size limit stops serialization if a specified serialized size limit is overstepped.

Only returns None if a size limit is provided and overstepped

Trait Implementations

impl<T, D> Clone for Sp<T, D>

where D: DB, T: ?Sized,

fn clone(&self) -> Sp<T, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, D> Debug for Sp<T, D>

where T: Debug, D: DB,

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

Formats the value using the given formatter.

impl<T, D> Deref for Sp<T, D>

where T: Storable<D>, D: DB,

fn deref(&self) -> &<Sp<T, D> as Deref>::Target

Access the inner data, forcing initialization if necessary.

type Target = T

The resulting type after dereferencing.

impl<T, D> Deserializable for Sp<T, D>

where T: Storable<D>, D: DB,

fn deserialize( reader: &mut impl Read, recursive_depth: u32, ) -> Result<Sp<T, D>, Error>

const LIMIT_RECURSION: bool = true

fn check_rec(depth: &mut u32) -> Result<(), Error>

impl<'a, T, D> Deserialize<'a> for Sp<T, D>

where T: Deserialize<'a> + Storable<D>, D: DB,

fn deserialize<D2>( deserializer: D2, ) -> Result<Sp<T, D>, <D2 as Deserializer<'a>>::Error>

where D2: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<T, D> Display for Sp<T, D>

where T: Display, D: DB,

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

Formats the value using the given formatter.

impl<T, D> Drop for Sp<T, D>

where T: 'static + ?Sized, D: DB,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, D> Hash for Sp<T, D>

where D: DB,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, D> Ord for Sp<T, D>

where T: Ord + Storable<D>, D: DB,

See warning on Sp::eq above.

fn cmp(&self, other: &Sp<T, D>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, D> PartialEq for Sp<T, D>

where D: DB,

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

An O(1) implementation of equality for Sp<T>.

Warning

It’s possible this implementation is inconsistent with the implementation for the underlying type T, if any, because:

• our equality is reflexive, but equality on T may not be, i.e. T might not implement Eq.

• our equality is maximally fine grained, but equality on the underlying type T could equate two values with different hashes.

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, D> PartialOrd for Sp<T, D>

where T: PartialOrd + Storable<D>, D: DB,

See warning on Sp::eq above.

fn partial_cmp(&self, other: &Sp<T, D>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, D> Serializable for Sp<T, D>

where T: Storable<D>, D: DB,

fn serialize(&self, writer: &mut impl Write) -> Result<(), Error>

fn serialized_size(&self) -> usize

impl<T, D> Serialize for Sp<T, D>

where T: Serialize + Storable<D>, D: DB,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<D, T> Storable<D> for Sp<T, D>

where D: DB, T: Storable<D>,

fn children(&self) -> Vec<ArenaKey<<D as DB>::Hasher>>

Provides an iterator over hashes of child Sps, if any. These hashes will be passed back into from_binary_repr when deserializing.

fn from_binary_repr<R>( reader: &mut R, child_hashes: &mut impl Iterator<Item = ArenaKey<<D as DB>::Hasher>>, loader: &impl Loader<D>, ) -> Result<Sp<T, D>, Error>

where R: Read,

Instantiates self, given hashes of any children, and loader that loads children given their hash.

fn to_binary_repr<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write,

Serializes self, omitting any children.

fn check_invariant(&self) -> Result<(), Error>

An invariant to check on deserialization. Should be invoked from within from_binary_repr.

fn as_child(&self) -> ArenaKey<<D as DB>::Hasher>

Represents self as a ArenaKey

impl<D> Storable<D> for Sp<dyn Any + Send + Sync, D>

where D: DB,

fn children(&self) -> Vec<ArenaKey<<D as DB>::Hasher>>

Provides an iterator over hashes of child Sps, if any. These hashes will be passed back into from_binary_repr when deserializing.

fn from_binary_repr<R>( reader: &mut R, child_nodes: &mut impl Iterator<Item = ArenaKey<<D as DB>::Hasher>>, loader: &impl Loader<D>, ) -> Result<Sp<dyn Any + Send + Sync, D>, Error>

where R: Read, Sp<dyn Any + Send + Sync, D>: Sized,

Instantiates self, given hashes of any children, and loader that loads children given their hash.

fn to_binary_repr<W>(&self, writer: &mut W) -> Result<(), Error>

where W: Write, Sp<dyn Any + Send + Sync, D>: Sized,

Serializes self, omitting any children.

fn check_invariant(&self) -> Result<(), Error>

An invariant to check on deserialization. Should be invoked from within from_binary_repr.

fn as_child(&self) -> ArenaKey<<D as DB>::Hasher>

Represents self as a ArenaKey

impl<T, D> Tagged for Sp<T, D>

where T: Tagged, D: DB,

fn tag() -> Cow<'static, str>

Retrieves the tag of Self. Returns a [Cow] as type arguments require allocation, but no allocation is preferred.

fn tag_unique_factor() -> String

A decomposition of this tag into primitive types (any type whose representation is not defined through other types), tuples (via (a,b)), and sum types (via [a,b]).

impl<T, D> Eq for Sp<T, D>

where D: DB,

See warning on Sp::eq above.