Struct scale_info::Registry

pub struct Registry { /* fields omitted */ }

The registry for compaction of type identifiers and definitions.

The registry consists of a cache for already compactified type identifiers and definitions.

Whenever using the registry to compact a type all of its sub-types are going to be registered recursively as well. A type is a sub-type of another type if it is used by its identifier or structure.

Note

A type can be a sub-type of itself. In this case the registry has a builtin mechanism to stop recursion before going into an infinite loop.

Implementations

impl Registry

pub fn new() -> Self

Creates a new empty registry.

pub fn register_type(&mut self, ty: &MetaType) -> UntrackedSymbol<TypeId>

Registers the given type into the registry and returns its associated type ID symbol.

Note

Due to safety requirements the returns type ID symbol cannot be used later to resolve back to the associated type definition. However, since this facility is going to be used for serialization purposes this functionality isn't needed anyway.

pub fn register_types<I>(&mut self, iter: I) -> Vec<UntrackedSymbol<TypeId>> where
    I: IntoIterator<Item = MetaType>, 

Calls register_type for each MetaType in the given iter

pub fn map_into_compact<I, T>(&mut self, iter: I) -> Vec<T::Output> where
    I: IntoIterator<Item = T>,
    T: IntoCompact, 

Converts an iterator into a Vec of the equivalent compact representations

Trait Implementations

impl Debug for Registry

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

Formats the value using the given formatter.

impl Default for Registry

fn default() -> Self

Returns the "default value" for a type.

impl Encode for Registry

fn size_hint(&self) -> usize

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

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

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

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.

impl Eq for Registry

impl From<Registry> for RegistryReadOnly

fn from(registry: Registry) -> Self

Performs the conversion.

impl PartialEq<Registry> for Registry

fn eq(&self, other: &Registry) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Registry) -> bool

This method tests for !=.

impl Serialize for Registry

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

Serialize this value into the given Serde serializer.

impl StructuralEq for Registry

impl StructuralPartialEq for Registry