Type Alias MetadataEntryV1 

pub type MetadataEntryV1 = MetadataValue;

Aliased Type

pub enum MetadataEntryV1 {
    String(String),
    Bool(bool),
    U8(u8),
    U32(u32),
    U64(u64),
    I32(i32),
    I64(i64),
    Decimal(Decimal),
    GlobalAddress(GlobalAddress),
    PublicKey(PublicKey),
    NonFungibleGlobalId(NonFungibleGlobalId),
    NonFungibleLocalId(NonFungibleLocalId),
    Instant(Instant),
    Url(UncheckedUrl),
    Origin(UncheckedOrigin),
    PublicKeyHash(PublicKeyHash),
    StringArray(Vec<String>),
    BoolArray(Vec<bool>),
    U8Array(Vec<u8>),
    U32Array(Vec<u32>),
    U64Array(Vec<u64>),
    I32Array(Vec<i32>),
    I64Array(Vec<i64>),
    DecimalArray(Vec<Decimal>),
    GlobalAddressArray(Vec<GlobalAddress>),
    PublicKeyArray(Vec<PublicKey>),
    NonFungibleGlobalIdArray(Vec<NonFungibleGlobalId>),
    NonFungibleLocalIdArray(Vec<NonFungibleLocalId>),
    InstantArray(Vec<Instant>),
    UrlArray(Vec<UncheckedUrl>),
    OriginArray(Vec<UncheckedOrigin>),
    PublicKeyHashArray(Vec<PublicKeyHash>),
}

Variants

String(String)

Bool(bool)

U8(u8)

U32(u32)

U64(u64)

I32(i32)

I64(i64)

Decimal(Decimal)

GlobalAddress(GlobalAddress)

PublicKey(PublicKey)

NonFungibleGlobalId(NonFungibleGlobalId)

NonFungibleLocalId(NonFungibleLocalId)

Instant(Instant)

Url(UncheckedUrl)

Origin(UncheckedOrigin)

PublicKeyHash(PublicKeyHash)

StringArray(Vec<String>)

BoolArray(Vec<bool>)

U8Array(Vec<u8>)

U32Array(Vec<u32>)

U64Array(Vec<u64>)

I32Array(Vec<i32>)

I64Array(Vec<i64>)

DecimalArray(Vec<Decimal>)

GlobalAddressArray(Vec<GlobalAddress>)

PublicKeyArray(Vec<PublicKey>)

NonFungibleGlobalIdArray(Vec<NonFungibleGlobalId>)

NonFungibleLocalIdArray(Vec<NonFungibleLocalId>)

InstantArray(Vec<Instant>)

UrlArray(Vec<UncheckedUrl>)

OriginArray(Vec<UncheckedOrigin>)

PublicKeyHashArray(Vec<PublicKeyHash>)

Trait Implementations

impl VersionedMetadataEntryVersion for MetadataEntryV1

const DISCRIMINATOR: u8 = 0u8

type Versioned = VersionedMetadataEntry

type OwnedSborVariant = SborFixedEnumVariant<$crate::eager_replace! { [!SET! #FullGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!SET! #ImplGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!SET! #TypeGenerics = $(< $( $lt ),+ >)?] [!SET! #VersionedType = $versioned_name $(< $( $lt ),+ >)?] [!SET! #VersionedTypePath = $versioned_name $(::< $( $lt ),+ >)?] [!SET! #VersionsType = $versions_name $(< $( $lt ),+ >)?] [!SET! #VersionsTypePath = $versions_name $(::< $( $lt ),+ >)?] [!SET:ident! #PermitSborAttributesAlias = $versioned_name _PermitSborAttributes] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #PermitSborAttributesAlias; #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!stringify! #VersionsType])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #FullGenerics { inner: Option<#VersionsType>, } impl #ImplGenerics #VersionedType { pub fn new(inner: #VersionsType) -> Self { Self { inner: Some(inner), } } } impl #ImplGenerics AsRef<#VersionsType> for #VersionedType { fn as_ref(&self) -> &#VersionsType { self.inner.as_ref().unwrap() } } impl #ImplGenerics AsMut<#VersionsType> for #VersionedType { fn as_mut(&mut self) -> &mut #VersionsType { self.inner.as_mut().unwrap() } } impl #ImplGenerics From<#VersionsType> for #VersionedType { fn from(value: #VersionsType) -> Self { Self::new(value) } } impl #ImplGenerics From<#VersionedType> for #VersionsType { fn from(value: #VersionedType) -> Self { value.inner.unwrap() } } impl #ImplGenerics Versioned for #VersionedType { type Versions = #VersionsType; type LatestVersion = $latest_version_type; fn is_fully_updated(&self) -> bool { self.as_ref().is_fully_updated() } fn in_place_fully_update(&mut self) -> &mut Self { if !self.is_fully_updated() { let current = self.inner.take().unwrap(); self.inner = Some(current.fully_update()); } self } fn fully_update_and_into_latest_version(self) -> Self::LatestVersion { self.inner.unwrap().fully_update_and_into_latest_version() } /// Constructs the versioned enum from the latest content fn from_latest_version(latest: Self::LatestVersion) -> Self { Self::new(latest.into()) } fn as_latest_version(&self) -> Option<&Self::LatestVersion> { self.as_ref().as_latest_version() } fn as_latest_version_mut(&mut self) -> Option<&mut Self::LatestVersion> { self.as_mut().as_latest_version_mut() } fn as_versions(&self) -> &Self::Versions { self.as_ref() } fn as_versions_mut(&mut self) -> &mut Self::Versions { self.as_mut() } fn into_versions(self) -> Self::Versions { self.inner.unwrap() } fn from_versions(version: Self::Versions) -> Self { Self::new(version) } } [!SET:ident! #discriminators = $versioned_name _discriminators] #[allow(non_snake_case)] mod #discriminators { // The initial version of this tool used 0-indexed/off-by-one discriminators accidentally. // We're stuck with these now unfortunately... // But we make them explicit in case versions are skipped. $($( pub const [!ident! VERSION_ $version_num]: u8 = $version_num - 1; )*)? pub const LATEST_VERSION: u8 = $latest_version - 1; } #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #FullGenerics { $($( #[sbor(discriminator(#discriminators::[!ident! VERSION_ $version_num]))] [!ident! V $version_num]($version_type), )*)? #[sbor(discriminator(#discriminators::LATEST_VERSION))] [!ident! V $latest_version]($latest_version_type), } #[allow(dead_code)] impl #ImplGenerics #VersionsType { /// Returns if update happened, and the updated versioned enum. fn attempt_single_update(self) -> (bool, Self) { match self { $($( Self::[!ident! V $version_num](value) => (true, Self::[!ident! V $update_to_version_num](value.into())), )*)? this @ Self::[!ident! V $latest_version](_) => (false, this), } } fn fully_update(mut self) -> Self { loop { let (did_update, updated) = self.attempt_single_update(); if did_update { // We should try updating self = updated; } else { // We're at latest - return return updated; } } } #[allow(unreachable_patterns)] pub fn is_fully_updated(&self) -> bool { match self { Self::[!ident! V $latest_version](_) => true, _ => false, } } #[allow(irrefutable_let_patterns)] fn fully_update_and_into_latest_version(self) -> $latest_version_type { let Self::[!ident! V $latest_version](latest) = self.fully_update() else { panic!("Invalid resolved latest version not equal to latest type") }; return latest; } fn from_latest_version(latest: $latest_version_type) -> Self { Self::[!ident! V $latest_version](latest) } #[allow(unreachable_patterns)] fn as_latest_version(&self) -> Option<&$latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } #[allow(unreachable_patterns)] fn as_latest_version_mut(&mut self) -> Option<&mut $latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } pub fn into_versioned(self) -> #VersionedType { #VersionedTypePath::new(self) } } $($( #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionsType { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionedType { fn from(value: $version_type) -> Self { Self::new(#VersionsTypePath::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionsType { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionedType { fn from(value: $latest_version_type) -> Self { Self::new($versions_name::[!ident! V $latest_version](value)) } } // This trait is similar to `SborEnumVariantFor<X, Versioned>`, but it's nicer to use as // it's got a better name and can be implemented without needing a specific CustomValueKind. [!SET:ident! #VersionTrait = $versioned_name Version] #[allow(dead_code)] $vis trait #VersionTrait { // Note: We need to use an explicit associated type to capture the generics. type Versioned: sbor::Versioned; const DISCRIMINATOR: u8; type OwnedSborVariant; type BorrowedSborVariant<'a> where Self: 'a; /// Can be used to encode the type as a variant under the Versioned type, without /// needing to clone, like this: `encoder.encode(x.as_encodable_variant())`. fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>; /// Can be used to decode the type from an encoded variant, like this: /// `X::from_decoded_variant(decoder.decode()?)`. fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self where Self: core::marker::Sized; fn into_versioned(self) -> Self::Versioned; } $($( impl #ImplGenerics #VersionTrait for $version_type { type Versioned = #VersionedType; const DISCRIMINATOR: u8 = #discriminators::[!ident! VERSION_ $version_num]; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } )*)? impl #ImplGenerics #VersionTrait for $latest_version_type { type Versioned = $versioned_name #TypeGenerics; const DISCRIMINATOR: u8 = #discriminators::LATEST_VERSION; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } }, (GenericMetadataValue<UncheckedUrl, UncheckedOrigin>,)>

type BorrowedSborVariant<'a> = SborFixedEnumVariant<$crate::eager_replace! { [!SET! #FullGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!SET! #ImplGenerics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!SET! #TypeGenerics = $(< $( $lt ),+ >)?] [!SET! #VersionedType = $versioned_name $(< $( $lt ),+ >)?] [!SET! #VersionedTypePath = $versioned_name $(::< $( $lt ),+ >)?] [!SET! #VersionsType = $versions_name $(< $( $lt ),+ >)?] [!SET! #VersionsTypePath = $versions_name $(::< $( $lt ),+ >)?] [!SET:ident! #PermitSborAttributesAlias = $versioned_name _PermitSborAttributes] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #PermitSborAttributesAlias; #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!stringify! #VersionsType])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #FullGenerics { inner: Option<#VersionsType>, } impl #ImplGenerics #VersionedType { pub fn new(inner: #VersionsType) -> Self { Self { inner: Some(inner), } } } impl #ImplGenerics AsRef<#VersionsType> for #VersionedType { fn as_ref(&self) -> &#VersionsType { self.inner.as_ref().unwrap() } } impl #ImplGenerics AsMut<#VersionsType> for #VersionedType { fn as_mut(&mut self) -> &mut #VersionsType { self.inner.as_mut().unwrap() } } impl #ImplGenerics From<#VersionsType> for #VersionedType { fn from(value: #VersionsType) -> Self { Self::new(value) } } impl #ImplGenerics From<#VersionedType> for #VersionsType { fn from(value: #VersionedType) -> Self { value.inner.unwrap() } } impl #ImplGenerics Versioned for #VersionedType { type Versions = #VersionsType; type LatestVersion = $latest_version_type; fn is_fully_updated(&self) -> bool { self.as_ref().is_fully_updated() } fn in_place_fully_update(&mut self) -> &mut Self { if !self.is_fully_updated() { let current = self.inner.take().unwrap(); self.inner = Some(current.fully_update()); } self } fn fully_update_and_into_latest_version(self) -> Self::LatestVersion { self.inner.unwrap().fully_update_and_into_latest_version() } /// Constructs the versioned enum from the latest content fn from_latest_version(latest: Self::LatestVersion) -> Self { Self::new(latest.into()) } fn as_latest_version(&self) -> Option<&Self::LatestVersion> { self.as_ref().as_latest_version() } fn as_latest_version_mut(&mut self) -> Option<&mut Self::LatestVersion> { self.as_mut().as_latest_version_mut() } fn as_versions(&self) -> &Self::Versions { self.as_ref() } fn as_versions_mut(&mut self) -> &mut Self::Versions { self.as_mut() } fn into_versions(self) -> Self::Versions { self.inner.unwrap() } fn from_versions(version: Self::Versions) -> Self { Self::new(version) } } [!SET:ident! #discriminators = $versioned_name _discriminators] #[allow(non_snake_case)] mod #discriminators { // The initial version of this tool used 0-indexed/off-by-one discriminators accidentally. // We're stuck with these now unfortunately... // But we make them explicit in case versions are skipped. $($( pub const [!ident! VERSION_ $version_num]: u8 = $version_num - 1; )*)? pub const LATEST_VERSION: u8 = $latest_version - 1; } #[derive(#PermitSborAttributesAlias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #FullGenerics { $($( #[sbor(discriminator(#discriminators::[!ident! VERSION_ $version_num]))] [!ident! V $version_num]($version_type), )*)? #[sbor(discriminator(#discriminators::LATEST_VERSION))] [!ident! V $latest_version]($latest_version_type), } #[allow(dead_code)] impl #ImplGenerics #VersionsType { /// Returns if update happened, and the updated versioned enum. fn attempt_single_update(self) -> (bool, Self) { match self { $($( Self::[!ident! V $version_num](value) => (true, Self::[!ident! V $update_to_version_num](value.into())), )*)? this @ Self::[!ident! V $latest_version](_) => (false, this), } } fn fully_update(mut self) -> Self { loop { let (did_update, updated) = self.attempt_single_update(); if did_update { // We should try updating self = updated; } else { // We're at latest - return return updated; } } } #[allow(unreachable_patterns)] pub fn is_fully_updated(&self) -> bool { match self { Self::[!ident! V $latest_version](_) => true, _ => false, } } #[allow(irrefutable_let_patterns)] fn fully_update_and_into_latest_version(self) -> $latest_version_type { let Self::[!ident! V $latest_version](latest) = self.fully_update() else { panic!("Invalid resolved latest version not equal to latest type") }; return latest; } fn from_latest_version(latest: $latest_version_type) -> Self { Self::[!ident! V $latest_version](latest) } #[allow(unreachable_patterns)] fn as_latest_version(&self) -> Option<&$latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } #[allow(unreachable_patterns)] fn as_latest_version_mut(&mut self) -> Option<&mut $latest_version_type> { match self { Self::[!ident! V $latest_version](latest) => Some(latest), _ => None, } } pub fn into_versioned(self) -> #VersionedType { #VersionedTypePath::new(self) } } $($( #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionsType { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #ImplGenerics From<$version_type> for #VersionedType { fn from(value: $version_type) -> Self { Self::new(#VersionsTypePath::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionsType { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #ImplGenerics From<$latest_version_type> for #VersionedType { fn from(value: $latest_version_type) -> Self { Self::new($versions_name::[!ident! V $latest_version](value)) } } // This trait is similar to `SborEnumVariantFor<X, Versioned>`, but it's nicer to use as // it's got a better name and can be implemented without needing a specific CustomValueKind. [!SET:ident! #VersionTrait = $versioned_name Version] #[allow(dead_code)] $vis trait #VersionTrait { // Note: We need to use an explicit associated type to capture the generics. type Versioned: sbor::Versioned; const DISCRIMINATOR: u8; type OwnedSborVariant; type BorrowedSborVariant<'a> where Self: 'a; /// Can be used to encode the type as a variant under the Versioned type, without /// needing to clone, like this: `encoder.encode(x.as_encodable_variant())`. fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>; /// Can be used to decode the type from an encoded variant, like this: /// `X::from_decoded_variant(decoder.decode()?)`. fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self where Self: core::marker::Sized; fn into_versioned(self) -> Self::Versioned; } $($( impl #ImplGenerics #VersionTrait for $version_type { type Versioned = #VersionedType; const DISCRIMINATOR: u8 = #discriminators::[!ident! VERSION_ $version_num]; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::[!ident! VERSION_ $version_num] }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } )*)? impl #ImplGenerics #VersionTrait for $latest_version_type { type Versioned = $versioned_name #TypeGenerics; const DISCRIMINATOR: u8 = #discriminators::LATEST_VERSION; type OwnedSborVariant = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (Self,)>; type BorrowedSborVariant<'a> = sbor::SborFixedEnumVariant::<{ #discriminators::LATEST_VERSION }, (&'a Self,)> where Self: 'a; fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_> { sbor::SborFixedEnumVariant::new((self,)) } fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self { variant.into_fields().0 } fn into_versioned(self) -> Self::Versioned { #VersionedTypePath::new(self.into()) } } }, (&'a GenericMetadataValue<UncheckedUrl, UncheckedOrigin>,)> where Self: 'a

fn as_encodable_variant(&self) -> Self::BorrowedSborVariant<'_>

Can be used to encode the type as a variant under the Versioned type, without needing to clone, like this: encoder.encode(x.as_encodable_variant()).

fn from_decoded_variant(variant: Self::OwnedSborVariant) -> Self

Can be used to decode the type from an encoded variant, like this: X::from_decoded_variant(decoder.decode()?).

fn into_versioned(self) -> Self::Versioned