Crate scale_type_resolver

scale-type-resolver provides a generic TypeResolver trait which can be implemented for any type that is capable of being given a type ID and resolving that into information about how the type is SCALE encoded. This allows libraries like scale-decode to be able to decode SCALE encoded bytes using either a modern type resolver like scale_info::PortableRegistry, or using entirely custom type resolvers (which we would need in order decode blocks from pre-V14 metadata).

It’s unlikely that you’d depend on this library directly; more likely you’d depend on a library like scale-decode which uses and re-exports the TypeResolver trait itself.

This crate is no_std by default and doesn’t require alloc except for tests.

Modules

• portable_registry
  An implementation and associated things related to scale_info::PortableRegistry.
• visitor
  A concrete ResolvedTypeVisitor implementation that allows you to provide closures to configure it. Using this is often a lot easier than implementing ResolvedTypeVisitor yourself, but does require an additional dependency and may be a touch less performant.

Structs

• Field
  Information about a composite field.
• Variant
  Information about a specific variant type.

Enums

• BitsOrderFormat
  This is a runtime representation of the order that bits will be written to the specified BitsStoreFormat.
• BitsStoreFormat
  This is a runtime representation of the store type that we’re targeting. These are equivalent to the bitvec store types u8, u16 and so on.
• Primitive
  This is handed to ResolvedTypeVisitor::visit_primitive(), and denotes the exact shape of the primitive type that we have resolved.
• UnhandledKind
  If any of the ResolvedTypeVisitor methods are not implemented, then ResolvedTypeVisitor::visit_unhandled() is called, and given an instance of this enum to denote which method was unhandled.

Traits

• FieldIter
  An iterator over a set of fields.
• ResolvedTypeVisitor
  A glorified set of callbacks, exactly one of which will fire depending on the outcome of calling TypeResolver::resolve_type(). These don’t typically need to be implemented by the user, and instead are implemented internally in eg scale-decode to drive the decoding of types.
• TypeId
  A trait representing a type ID.
• TypeResolver
  This trait can be implemented for any type that is capable of describing how some type (identified by a TypeResolver::TypeId) is represented in terms of SCALE encoded bytes.
• VariantIter
  An iterator over a set of variants.