用户定义类型

有两种用户定义类型：Composite 和 Variant。

两者在其定义中都使用了 Path 和 Field 类型。

字段

表示用户定义类型的基本构建块是定义字段类型及其可选名称的 Field 结构体。用户定义类型的构建器强制执行不变性，即所有字段都有名称（例如，结构体）或所有字段都是未命名的（例如，元组）。

路径

类型的路径是一系列标识符的唯一序列。Rust 类型通常从命名空间和标识符构造路径，例如 foo::bar::Baz 转换为路径 ["foo", "bar", "Baz"]。

复合类型

复合数据类型 由一系列 Fields 组成。

结构体 由一组 命名 字段表示，在构建期间强制执行。

struct Foo<T> {
    bar: T,
    data: u64,
}

impl<T> TypeInfo for Foo<T>
where
    T: TypeInfo + 'static,
{
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .type_params(vec![MetaType::new::<T>()])
            .composite(Fields::named()
                .field(|f| f.ty::<T>().name("bar").type_name("T"))
                .field(|f| f.ty::<u64>().name("data").type_name("u64"))
            )
    }
}

元组 由一组 未命名 字段表示，在构建期间强制执行。

struct Foo(u32, bool);

impl TypeInfo for Foo {
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .composite(Fields::unnamed()
                .field(|f| f.ty::<u32>().type_name("u32"))
                .field(|f| f.ty::<bool>().type_name("bool"))
            )
    }
}

变体

变体类型 也称为枚举或标记联合，由一系列变体组成。变体可以具有未命名字段、命名字段或没有字段。

enum Foo<T>{
    A(T),
    B { f: u32 },
    C,
}

impl<T> TypeInfo for Foo<T>
where
    T: TypeInfo + 'static,
{
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .type_params(vec![MetaType::new::<T>()])
            .variant(
                Variants::new()
                   .variant("A", |v| v.fields(Fields::unnamed().field(|f| f.ty::<T>())))
                   .variant("B", |v| v.fields(Fields::named().field(|f| f.ty::<u32>().name("f").type_name("u32"))))
                   .variant_unit("C")
            )
    }
}

如果没有变体包含字段，则可以显式设置区分符，由构建器在构建期间强制执行。

enum Foo {
    A,
    B,
    C = 33,
}

impl TypeInfo for Foo {
    type Identity = Self;

    fn type_info() -> Type {
        Type::builder()
            .path(Path::new("Foo", module_path!()))
            .variant(
                Variants::new()
                    .variant("A", |v| v.index(1))
                    .variant("B", |v| v.index(2))
                    .variant("C", |v| v.index(33))
            )
    }
}

注册表

类型信息在所谓的类型注册表（Registry）中提供。类型定义在那里注册，并与唯一的ID关联，外部可以引用这些ID，从而提供一种轻量级的方法来减少开销，而不是使用类型标识符。

所有具体的 TypeInfo 结构体有两种形式

• 一种元形式（MetaType），充当与其他形式之间的桥梁
• 一种适合序列化的便携式形式。

还必须实现 IntoPortable 特性，以便使用类型注册表的实例准备类型定义以进行序列化。

转换后，所有类型定义都存储在类型注册表中。请注意，类型注册表应作为元数据结构的一部分进行序列化，其中注册的类型被利用，以便允许消费者解析类型。

编码

类型注册表可以编码为：

• JSON（启用“serde”功能）。
• SCALE自身（使用parity-scale-codec）。

功能

以下可选的cargo功能可用：

• serde包括对类型注册表进行JSON序列化和反序列化的支持。请参阅示例这里。
• derive重新导出scale-info-derive包。

已知问题

当为具有泛型紧凑字段的类型派生TypeInfo，例如：

#[derive(Encode, TypeInfo)]
struct Foo<S> { #[codec(compact)] a: S }

当使用此泛型类型且没有正确的界限时，您可能会遇到以下错误：

error[E0275]: overflow evaluating the requirement `_::_parity_scale_codec::Compact<_>: Decode`

有关更多信息，请参阅https://github.com/paritytech/scale-info/issues/65。

资源

• 请参阅描述ink!智能合约元数据的用法。
• 原始设计草案（已过时）