Struct PortableRegistry 

pub struct PortableRegistry {
    pub types: Vec<PortableType>,
}

A read-only registry containing types in their portable form for serialization.

Fields

types: Vec<PortableType>

The types contained by the PortableRegistry.

Implementations

impl PortableRegistry

pub fn resolve(&self, id: u32) -> Option<&Type<PortableForm>>

Returns the type definition for the given identifier, None if no type found for that ID.

pub fn types(&self) -> &[PortableType]

👎Deprecated since 2.5.0: Prefer to access the fields directly; this getter will be removed in the next major version

Returns all types with their associated identifiers.

pub fn retain<F>(&mut self, filter: F) -> BTreeMap<u32, u32>

where F: FnMut(u32) -> bool,

Retains only the portable types needed to express the provided ids.

The type IDs retained are returned as key to the BTreeMap. The value of the map represents the new ID of that type.

Note

A given type ID can be defined by nesting type IDs, such as the case of a TypeDef::Composite and others. To retain a valid PortableRegistry all the types needed to express an ID are included. Therefore, the number of elements defined by the result equals or exceeds the number of provided IDs.

Trait Implementations

impl Clone for PortableRegistry

fn clone(&self) -> PortableRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PortableRegistry

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

Formats the value using the given formatter.

impl Decode for PortableRegistry

fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<PortableRegistry, Error>

where __CodecInputEdqy: Input,

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<'de> Deserialize<'de> for PortableRegistry

fn deserialize<__D>( __deserializer: __D, ) -> Result<PortableRegistry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for PortableRegistry

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

where __CodecOutputEdqy: Output + ?Sized,

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<__CodecOutputReturn, __CodecUsingEncodedCallback>( &self, f: __CodecUsingEncodedCallback, ) -> __CodecOutputReturn

where __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<Registry> for PortableRegistry

fn from(registry: Registry) -> PortableRegistry

Converts to this type from the input type.

impl PartialEq for PortableRegistry

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

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 TypeResolver for PortableRegistry

type TypeId = u32

An identifier which points to some type that we’d like information on.

type Error = Error

An error that can be handed back in the process of trying to resolve a type.

fn resolve_type<'this, V>( &'this self, type_id: <PortableRegistry as TypeResolver>::TypeId, visitor: V, ) -> Result<<V as ResolvedTypeVisitor<'this>>::Value, <PortableRegistry as TypeResolver>::Error>

where V: ResolvedTypeVisitor<'this, TypeId = <PortableRegistry as TypeResolver>::TypeId>,

Given a type ID, this calls a method on the provided ResolvedTypeVisitor describing the outcome of resolving the SCALE encoding information.

impl EncodeLike for PortableRegistry

impl Eq for PortableRegistry

impl StructuralPartialEq for PortableRegistry