Enum TypePathType 

pub enum TypePathType {
    Path {
        path: Path,
        params: Vec<TypePath>,
    },
    Vec {
        of: Box<TypePath>,
    },
    Array {
        len: usize,
        of: Box<TypePath>,
    },
    Tuple {
        elements: Vec<TypePath>,
    },
    Primitive {
        def: TypeDefPrimitive,
    },
    Compact {
        inner: Box<TypePath>,
        is_field: bool,
        compact_type_path: Path,
    },
    BitVec {
        bit_order_type: Box<TypePath>,
        bit_store_type: Box<TypePath>,
        decoded_bits_type_path: Path,
    },
}

The path of a Concrete type

Variants

Path

A user-defined type (non-builtin struct or enum)

Fields

path: Path

Type path

params: Vec<TypePath>

Generic type parameters

Vec

A variable sized sequences of elements of some type. See std::vec::Vec.

Fields

of: Box<TypePath>

Type of elements in the vector.

Array

A fixed length array that contains len elements of some type.

Fields

len: usize

number of elements in the array

of: Box<TypePath>

Type path

Tuple

A Tuple type

Fields

elements: Vec<TypePath>

Types that make up this tuple

Primitive

Primitive type

Fields

def: TypeDefPrimitive

A primitive Rust type.

Compact

A compact encoded type

Fields

inner: Box<TypePath>

The type that is being compact encoded

is_field: bool

is this type used as a field of a struct or enum right now?

compact_type_path: Path

path to the Compact type (usually [parity_scale_codec::Compact])

BitVec

A bit vector

Fields

bit_order_type: Box<TypePath>

Order type

bit_store_type: Box<TypePath>

Store type

decoded_bits_type_path: Path

A user defined wrapper type around scale_bits::Bits. Should be generic over the order and store types.

Implementations

impl TypePathType

pub fn from_type_def_path( path: &Path<PortableForm>, root_mod_ident: Ident, params: Vec<TypePath>, alloc_crate_path: &AllocCratePath, ) -> Self

Constructs a TypePathType from some context information.

pub fn is_compact(&self) -> bool

Returns true, if this is a concrete compact type.

pub fn is_string(&self) -> bool

Returns true, if this is a string type.

Trait Implementations

impl Clone for TypePathType

fn clone(&self) -> TypePathType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypePathType

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

Formats the value using the given formatter.