#[repr(u8)]pub enum IoTypeMetadataKind {
Show 113 variants
Unit = 0,
Bool = 1,
U8 = 2,
U16 = 3,
U32 = 4,
U64 = 5,
U128 = 6,
I8 = 7,
I16 = 8,
I32 = 9,
I64 = 10,
I128 = 11,
Struct = 12,
Struct0 = 13,
Struct1 = 14,
Struct2 = 15,
Struct3 = 16,
Struct4 = 17,
Struct5 = 18,
Struct6 = 19,
Struct7 = 20,
Struct8 = 21,
Struct9 = 22,
Struct10 = 23,
Struct11 = 24,
Struct12 = 25,
Struct13 = 26,
Struct14 = 27,
Struct15 = 28,
Struct16 = 29,
TupleStruct = 30,
TupleStruct1 = 31,
TupleStruct2 = 32,
TupleStruct3 = 33,
TupleStruct4 = 34,
TupleStruct5 = 35,
TupleStruct6 = 36,
TupleStruct7 = 37,
TupleStruct8 = 38,
TupleStruct9 = 39,
TupleStruct10 = 40,
TupleStruct11 = 41,
TupleStruct12 = 42,
TupleStruct13 = 43,
TupleStruct14 = 44,
TupleStruct15 = 45,
TupleStruct16 = 46,
Enum = 47,
Enum1 = 48,
Enum2 = 49,
Enum3 = 50,
Enum4 = 51,
Enum5 = 52,
Enum6 = 53,
Enum7 = 54,
Enum8 = 55,
Enum9 = 56,
Enum10 = 57,
Enum11 = 58,
Enum12 = 59,
Enum13 = 60,
Enum14 = 61,
Enum15 = 62,
Enum16 = 63,
EnumNoFields = 64,
EnumNoFields1 = 65,
EnumNoFields2 = 66,
EnumNoFields3 = 67,
EnumNoFields4 = 68,
EnumNoFields5 = 69,
EnumNoFields6 = 70,
EnumNoFields7 = 71,
EnumNoFields8 = 72,
EnumNoFields9 = 73,
EnumNoFields10 = 74,
EnumNoFields11 = 75,
EnumNoFields12 = 76,
EnumNoFields13 = 77,
EnumNoFields14 = 78,
EnumNoFields15 = 79,
EnumNoFields16 = 80,
Array8b = 81,
Array16b = 82,
Array32b = 83,
ArrayU8x8 = 84,
ArrayU8x16 = 85,
ArrayU8x32 = 86,
ArrayU8x64 = 87,
ArrayU8x128 = 88,
ArrayU8x256 = 89,
ArrayU8x512 = 90,
ArrayU8x1024 = 91,
ArrayU8x2028 = 92,
ArrayU8x4096 = 93,
VariableBytes8b = 94,
VariableBytes16b = 95,
VariableBytes32b = 96,
VariableBytes512 = 97,
VariableBytes1024 = 98,
VariableBytes2028 = 99,
VariableBytes4096 = 100,
VariableBytes8192 = 101,
VariableBytes16384 = 102,
VariableBytes32768 = 103,
VariableBytes65536 = 104,
VariableBytes131072 = 105,
VariableBytes262144 = 106,
VariableBytes524288 = 107,
VariableBytes1048576 = 108,
VariableBytes2097152 = 109,
VariableBytes4194304 = 110,
VariableBytes8388608 = 111,
VariableBytes16777216 = 112,
}Expand description
Metadata types contained in TrivialType::METADATA and IoType::METADATA.
Metadata encoding consists of this enum variant treated as u8 followed by optional metadata
encoding rules specific to metadata type variant (see variant’s description).
This metadata is enough to fully reconstruct the hierarchy of the type to generate language bindings, auto-generate UI forms, etc.
Variants§
Unit = 0
()
Bool = 1
bool
U8 = 2
u8
U16 = 3
u16
U32 = 4
u32
U64 = 5
u64
U128 = 6
u128
I8 = 7
i8
I16 = 8
i16
I32 = 9
i32
I64 = 10
i64
I128 = 11
i128
Struct = 12
struct S {..}
Structs with named fields are encoded af follows:
- Length of struct name in bytes (u8)
- Struct name as UTF-8 bytes
- Number of fields (u8)
Each field is encoded follows:
- Length of the field name in bytes (u8)
- Field name as UTF-8 bytes
- Recursive metadata of the field’s type
Struct0 = 13
Similar to Self::Struct, but for exactly 0 struct fields and thus skips number of
fields after struct name
Struct1 = 14
Similar to Self::Struct, but for exactly 1 struct fields and thus skips number of
fields after struct name
Struct2 = 15
Similar to Self::Struct, but for exactly 2 struct fields and thus skips number of
fields after struct name
Struct3 = 16
Similar to Self::Struct, but for exactly 3 struct fields and thus skips number of
fields after struct name
Struct4 = 17
Similar to Self::Struct, but for exactly 4 struct fields and thus skips number of
fields after struct name
Struct5 = 18
Similar to Self::Struct, but for exactly 5 struct fields and thus skips number of
fields after struct name
Struct6 = 19
Similar to Self::Struct, but for exactly 6 struct fields and thus skips number of
fields after struct name
Struct7 = 20
Similar to Self::Struct, but for exactly 7 struct fields and thus skips number of
fields after struct name
Struct8 = 21
Similar to Self::Struct, but for exactly 8 struct fields and thus skips number of
fields after struct name
Struct9 = 22
Similar to Self::Struct, but for exactly 9 struct fields and thus skips number of
fields after struct name
Struct10 = 23
Similar to Self::Struct, but for exactly 10 struct fields and thus skips number of
fields after struct name
Struct11 = 24
Similar to Self::Struct, but for exactly 11 struct fields and thus skips number of
fields after struct name
Struct12 = 25
Similar to Self::Struct, but for exactly 12 struct fields and thus skips number of
fields after struct name
Struct13 = 26
Similar to Self::Struct, but for exactly 13 struct fields and thus skips number of
fields after struct name
Struct14 = 27
Similar to Self::Struct, but for exactly 14 struct fields and thus skips number of
fields after struct name
Struct15 = 28
Similar to Self::Struct, but for exactly 15 struct fields and thus skips number of
fields after struct name
Struct16 = 29
Similar to Self::Struct, but for exactly 16 struct fields and thus skips number of
fields after struct name
TupleStruct = 30
struct S(..);
Tuple structs are encoded af follows:
- Length of struct name in bytes (u8)
- Struct name as UTF-8 bytes
- Number of fields (u8)
Each field is encoded follows:
- Recursive metadata of the field’s type
TupleStruct1 = 31
Similar to Self::TupleStruct, but for exactly 1 struct fields and thus skips number of
fields after struct name
TupleStruct2 = 32
Similar to Self::TupleStruct, but for exactly 2 struct fields and thus skips number of
fields after struct name
TupleStruct3 = 33
Similar to Self::TupleStruct, but for exactly 3 struct fields and thus skips number of
fields after struct name
TupleStruct4 = 34
Similar to Self::TupleStruct, but for exactly 4 struct fields and thus skips number of
fields after struct name
TupleStruct5 = 35
Similar to Self::TupleStruct, but for exactly 5 struct fields and thus skips number of
fields after struct name
TupleStruct6 = 36
Similar to Self::TupleStruct, but for exactly 6 struct fields and thus skips number of
fields after struct name
TupleStruct7 = 37
Similar to Self::TupleStruct, but for exactly 7 struct fields and thus skips number of
fields after struct name
TupleStruct8 = 38
Similar to Self::TupleStruct, but for exactly 8 struct fields and thus skips number of
fields after struct name
TupleStruct9 = 39
Similar to Self::TupleStruct, but for exactly 9 struct fields and thus skips number of
fields after struct name
TupleStruct10 = 40
Similar to Self::TupleStruct, but for exactly 10 struct fields and thus skips number
of fields after struct name
TupleStruct11 = 41
Similar to Self::TupleStruct, but for exactly 11 struct fields and thus skips number
of fields after struct name
TupleStruct12 = 42
Similar to Self::TupleStruct, but for exactly 12 struct fields and thus skips number
of fields after struct name
TupleStruct13 = 43
Similar to Self::TupleStruct, but for exactly 13 struct fields and thus skips number
of fields after struct name
TupleStruct14 = 44
Similar to Self::TupleStruct, but for exactly 14 struct fields and thus skips number
of fields after struct name
TupleStruct15 = 45
Similar to Self::TupleStruct, but for exactly 15 struct fields and thus skips number
of fields after struct name
TupleStruct16 = 46
Similar to Self::TupleStruct, but for exactly 16 struct fields and thus skips number
of fields after struct name
Enum = 47
enum E { Variant {..} }
Enums with variants that have fields are encoded as follows:
- Length of enum name in bytes (u8)
- Enum name as UTF-8 bytes
- Number of variants (u8)
- Each enum variant as if it was a struct with fields, see
Self::Structfor details
Enum1 = 48
Similar to Self::Enum, but for exactly 1 enum variants and thus skips number of
variants after enum name
Enum2 = 49
Similar to Self::Enum, but for exactly 2 enum variants and thus skips number of
variants after enum name
Enum3 = 50
Similar to Self::Enum, but for exactly 3 enum variants and thus skips number of
variants after enum name
Enum4 = 51
Similar to Self::Enum, but for exactly 4 enum variants and thus skips number of
variants after enum name
Enum5 = 52
Similar to Self::Enum, but for exactly 5 enum variants and thus skips number of
variants after enum name
Enum6 = 53
Similar to Self::Enum, but for exactly 6 enum variants and thus skips number of
variants after enum name
Enum7 = 54
Similar to Self::Enum, but for exactly 7 enum variants and thus skips number of
variants after enum name
Enum8 = 55
Similar to Self::Enum, but for exactly 8 enum variants and thus skips number of
variants after enum name
Enum9 = 56
Similar to Self::Enum, but for exactly 9 enum variants and thus skips number of
variants after enum name
Enum10 = 57
Similar to Self::Enum, but for exactly 10 enum variants and thus skips number of
variants after enum name
Enum11 = 58
Similar to Self::Enum, but for exactly 11 enum variants and thus skips number of
variants after enum name
Enum12 = 59
Similar to Self::Enum, but for exactly 12 enum variants and thus skips number of
variants after enum name
Enum13 = 60
Similar to Self::Enum, but for exactly 13 enum variants and thus skips number of
variants after enum name
Enum14 = 61
Similar to Self::Enum, but for exactly 14 enum variants and thus skips number of
variants after enum name
Enum15 = 62
Similar to Self::Enum, but for exactly 15 enum variants and thus skips number of
variants after enum name
Enum16 = 63
Similar to Self::Enum, but for exactly 16 enum variants and thus skips number of
variants after enum name
EnumNoFields = 64
enum E { A, B }
Enums with variants that have no fields are encoded as follows:
- Length of enum name in bytes (u8)
- Enum name as UTF-8 bytes
- Number of variants (u8)
Each enum variant is encoded follows:
- Length of the variant name in bytes (u8)
- Variant name as UTF-8 bytes
EnumNoFields1 = 65
Similar to Self::EnumNoFields, but for exactly 1 enum variants and thus skips number
of variants after enum name
EnumNoFields2 = 66
Similar to Self::EnumNoFields, but for exactly 2 enum variants and thus skips number
of variants after enum name
EnumNoFields3 = 67
Similar to Self::EnumNoFields, but for exactly 3 enum variants and thus skips number
of variants after enum name
EnumNoFields4 = 68
Similar to Self::EnumNoFields, but for exactly 4 enum variants and thus skips number
of variants after enum name
EnumNoFields5 = 69
Similar to Self::EnumNoFields, but for exactly 5 enum variants and thus skips number
of variants after enum name
EnumNoFields6 = 70
Similar to Self::EnumNoFields, but for exactly 6 enum variants and thus skips number
of variants after enum name
EnumNoFields7 = 71
Similar to Self::EnumNoFields, but for exactly 7 enum variants and thus skips number
of variants after enum name
EnumNoFields8 = 72
Similar to Self::EnumNoFields, but for exactly 8 enum variants and thus skips number
of variants after enum name
EnumNoFields9 = 73
Similar to Self::EnumNoFields, but for exactly 9 enum variants and thus skips number
of variants after enum name
EnumNoFields10 = 74
Similar to Self::EnumNoFields, but for exactly 10 enum variants and thus skips number
of variants after enum name
EnumNoFields11 = 75
Similar to Self::EnumNoFields, but for exactly 11 enum variants and thus skips number
of variants after enum name
EnumNoFields12 = 76
Similar to Self::EnumNoFields, but for exactly 12 enum variants and thus skips number
of variants after enum name
EnumNoFields13 = 77
Similar to Self::EnumNoFields, but for exactly 13 enum variants and thus skips number
of variants after enum name
EnumNoFields14 = 78
Similar to Self::EnumNoFields, but for exactly 14 enum variants and thus skips number
of variants after enum name
EnumNoFields15 = 79
Similar to Self::EnumNoFields, but for exactly 15 enum variants and thus skips number
of variants after enum name
EnumNoFields16 = 80
Similar to Self::EnumNoFields, but for exactly 16 enum variants and thus skips number
of variants after enum name
Array8b = 81
Array [T; N] with up to 2^8 elements.
Arrays with up to 2^8 encoded as follows:
- 1 byte number of elements
- Recursive metadata of contained type
Array16b = 82
Array [T; N] with up to 2^16 elements.
Arrays with up to 2^16 encoded as follows:
- 2 bytes number of elements (little-endian)
- Recursive metadata of contained type
Array32b = 83
Array [T; N] with up to 2^32 elements.
Arrays with up to 2^32 encoded as follows:
- 4 bytes number of elements (little-endian)
- Recursive metadata of contained type
ArrayU8x8 = 84
Compact alias for [u8; 8]
ArrayU8x16 = 85
Compact alias for [u8; 16]
ArrayU8x32 = 86
Compact alias for [u8; 32]
ArrayU8x64 = 87
Compact alias for [u8; 64]
ArrayU8x128 = 88
Compact alias for [u8; 128]
ArrayU8x256 = 89
Compact alias for [u8; 256]
ArrayU8x512 = 90
Compact alias for [u8; 512]
ArrayU8x1024 = 91
Compact alias for [u8; 1024]
ArrayU8x2028 = 92
Compact alias for [u8; 2028]
ArrayU8x4096 = 93
Compact alias for [u8; 4096]
VariableBytes8b = 94
Variable bytes with up to 2^8 bytes recommended allocation.
Variable bytes with up to 2^8 encoded as follows:
- 1 byte recommended allocation in bytes
VariableBytes16b = 95
Variable bytes with up to 2^16 bytes recommended allocation.
Variable bytes with up to 2^16 encoded as follows:
- 2 bytes recommended allocation in bytes (little-endian)
VariableBytes32b = 96
Variable bytes with up to 2^32 bytes recommended allocation.
Variable bytes with up to 2^8 encoded as follows:
- 4 bytes recommended allocation in bytes (little-endian)
VariableBytes512 = 97
Compact alias VariableBytes<512>
VariableBytes1024 = 98
Compact alias VariableBytes<1024>
VariableBytes2028 = 99
Compact alias VariableBytes<2028>
VariableBytes4096 = 100
Compact alias VariableBytes<4096>
VariableBytes8192 = 101
Compact alias VariableBytes<8192>
VariableBytes16384 = 102
Compact alias VariableBytes<16384>
VariableBytes32768 = 103
Compact alias VariableBytes<32768>
VariableBytes65536 = 104
Compact alias VariableBytes<65536>
VariableBytes131072 = 105
Compact alias VariableBytes<131072>
VariableBytes262144 = 106
Compact alias VariableBytes<262144>
VariableBytes524288 = 107
Compact alias VariableBytes<524288>
VariableBytes1048576 = 108
Compact alias VariableBytes<1048576>
VariableBytes2097152 = 109
Compact alias VariableBytes<2097152>
VariableBytes4194304 = 110
Compact alias VariableBytes<4194304>
VariableBytes8388608 = 111
Compact alias VariableBytes<8388608>
VariableBytes16777216 = 112
Compact alias VariableBytes<16777216>
Implementations§
Source§impl IoTypeMetadataKind
impl IoTypeMetadataKind
Sourcepub const fn try_from_u8(byte: u8) -> Option<Self>
pub const fn try_from_u8(byte: u8) -> Option<Self>
Try to create an instance from its u8 representation
Sourcepub const fn compact<'i, 'o>(
input: &'i [u8],
output: &'o mut [u8],
) -> Option<(&'i [u8], &'o mut [u8])>
pub const fn compact<'i, 'o>( input: &'i [u8], output: &'o mut [u8], ) -> Option<(&'i [u8], &'o mut [u8])>
Produce compact metadata.
Compact metadata retains the shape, but throws some details. Specifically, the following transformations are applied to metadata:
- Struct names, enum names and enum variant names are removed (replaced with zero bytes names)
- Structs and enum variants are turned into tuple variants (removing field names)
This is typically called by higher-level functions and doesn’t need to be used directly.
This function takes an input that starts with metadata defined in IoTypeMetadataKind
and output where compact metadata must be written. Since input might have other data past
the data structure to be processed, the remainder of input and output are returned to the
caller.
Unexpected metadata kind results in None being returned.
Sourcepub const fn recommended_capacity(metadata: &[u8]) -> Option<(u32, &[u8])>
pub const fn recommended_capacity(metadata: &[u8]) -> Option<(u32, &[u8])>
Decode type, return its recommended capacity that should be allocated by the host.
If actual data is larger, it will be passed down to the guest as it is, if smaller than host should allocate recommended capacity for guest anyway.
Returns recommended capacity and whatever slice of bytes from input that is left after
type decoding.
Trait Implementations§
Source§impl Clone for IoTypeMetadataKind
impl Clone for IoTypeMetadataKind
Source§fn clone(&self) -> IoTypeMetadataKind
fn clone(&self) -> IoTypeMetadataKind
1.0.0 · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read more