Struct PackageCodeOriginalCodeV1 

pub struct PackageCodeOriginalCodeV1 {
    pub code: Vec<u8>,
}

Fields

code: Vec<u8>

Trait Implementations

impl Categorize<ScryptoCustomValueKind> for PackageCodeOriginalCodeV1

fn value_kind() -> ValueKind<ScryptoCustomValueKind>

impl Debug for PackageCodeOriginalCodeV1

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

Formats the value using the given formatter.

impl<D: Decoder<ScryptoCustomValueKind>> Decode<ScryptoCustomValueKind, D> for PackageCodeOriginalCodeV1

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ScryptoCustomValueKind>, ) -> Result<Self, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl Describe<ScryptoCustomTypeKind> for PackageCodeOriginalCodeV1

const TYPE_ID: RustTypeId

The TYPE_ID should give a unique identifier for its SBOR schema type. An SBOR schema type capture details about the SBOR payload, how it should be interpreted, validated and displayed.

fn type_data() -> TypeData<ScryptoCustomTypeKind, RustTypeId>

Returns the local schema for the given type.

fn add_all_dependencies(aggregator: &mut TypeAggregator<ScryptoCustomTypeKind>)

For each type referenced in get_local_type_data, we need to ensure that the type and all of its own references get added to the aggregator.

impl<E: Encoder<ScryptoCustomValueKind>> Encode<ScryptoCustomValueKind, E> for PackageCodeOriginalCodeV1

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl From<PackageCodeOriginalCodeV1> for PackageCodeOriginalCodeVersions

fn from(value: PackageCodeOriginalCodeV1) -> Self

Converts to this type from the input type.

impl From<PackageCodeOriginalCodeV1> for VersionedPackageCodeOriginalCode

fn from(value: PackageCodeOriginalCodeV1) -> Self

Converts to this type from the input type.

impl PartialEq for PackageCodeOriginalCodeV1

fn eq(&self, other: &PackageCodeOriginalCodeV1) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SborEnum<ScryptoCustomValueKind> for PackageCodeOriginalCodeV1

where for<'b_> &'b_ Vec<u8>: SborEnum<ScryptoCustomValueKind>,

fn get_discriminator(&self) -> u8

fn get_length(&self) -> usize

impl SborTuple<ScryptoCustomValueKind> for PackageCodeOriginalCodeV1

where for<'b_> &'b_ Vec<u8>: SborTuple<ScryptoCustomValueKind>,

fn get_length(&self) -> usize

impl VersionedPackageCodeOriginalCodeVersion for PackageCodeOriginalCodeV1

const DISCRIMINATOR: u8 = VersionedPackageCodeOriginalCode_discriminators::LATEST_VERSION

type Versioned = VersionedPackageCodeOriginalCode

type OwnedSborVariant = SborFixedEnumVariant<$crate::prelude::preinterpret! { [!set! #full_generics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!set! #impl_generics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!set! #type_generics = $(< $( $lt ),+ >)?] [!set! #versioned_type = $versioned_name $(< $( $lt ),+ >)?] [!set! #versioned_type_path = $versioned_name $(::< $( $lt ),+ >)?] [!set! #versions_type = $versions_name $(< $( $lt ),+ >)?] [!set! #versions_type_path = $versions_name $(::< $( $lt ),+ >)?] [!set! #permit_sbor_attribute_alias = [!ident! $versioned_name _PermitSborAttributes]] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #permit_sbor_attribute_alias; #[derive(#permit_sbor_attribute_alias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!string! #versions_type])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #full_generics { inner: Option<#versions_type>, } impl #impl_generics #versioned_type { pub fn new(inner: #versions_type) -> Self { Self { inner: Some(inner), } } } impl #impl_generics AsRef<#versions_type> for #versioned_type { fn as_ref(&self) -> &#versions_type { self.inner.as_ref().unwrap() } } impl #impl_generics AsMut<#versions_type> for #versioned_type { fn as_mut(&mut self) -> &mut #versions_type { self.inner.as_mut().unwrap() } } impl #impl_generics From<#versions_type> for #versioned_type { fn from(value: #versions_type) -> Self { Self::new(value) } } impl #impl_generics From<#versioned_type> for #versions_type { fn from(value: #versioned_type) -> Self { value.inner.unwrap() } } impl #impl_generics Versioned for #versioned_type { type Versions = #versions_type; 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! #discriminators = [!ident! $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(#permit_sbor_attribute_alias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #full_generics { $($( #[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 #impl_generics #versions_type { /// 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) -> #versioned_type { #versioned_type_path::new(self) } } $($( #[allow(dead_code)] impl #impl_generics From<$version_type> for #versions_type { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #impl_generics From<$version_type> for #versioned_type { fn from(value: $version_type) -> Self { Self::new(#versions_type_path::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #impl_generics From<$latest_version_type> for #versions_type { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #impl_generics From<$latest_version_type> for #versioned_type { 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! #version_trait = [!ident! $versioned_name Version]] #[allow(dead_code)] $vis trait #version_trait { // 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 #impl_generics #version_trait for $version_type { type Versioned = #versioned_type; 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 { #versioned_type_path::new(self.into()) } } )*)? impl #impl_generics #version_trait for $latest_version_type { type Versioned = $versioned_name #type_generics; 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 { #versioned_type_path::new(self.into()) } } }, (PackageCodeOriginalCodeV1,)>

type BorrowedSborVariant<'a> = SborFixedEnumVariant<$crate::prelude::preinterpret! { [!set! #full_generics = $(< $( $lt $( : $clt $(+ $dlt )* )? $( = $deflt)? ),+ >)?] [!set! #impl_generics = $(< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)?] [!set! #type_generics = $(< $( $lt ),+ >)?] [!set! #versioned_type = $versioned_name $(< $( $lt ),+ >)?] [!set! #versioned_type_path = $versioned_name $(::< $( $lt ),+ >)?] [!set! #versions_type = $versions_name $(< $( $lt ),+ >)?] [!set! #versions_type_path = $versions_name $(::< $( $lt ),+ >)?] [!set! #permit_sbor_attribute_alias = [!ident! $versioned_name _PermitSborAttributes]] #[allow(dead_code)] $vis type $latest_version_alias = $latest_version_type; use $crate::PermitSborAttributes as #permit_sbor_attribute_alias; #[derive(#permit_sbor_attribute_alias)] $(#[$attributes])* $($(#[$outer_attributes])*)? // Needs to go below $attributes so that a #[derive(Sbor)] in the attributes can see it. #[sbor(as_type = [!string! #versions_type])] /// If you wish to get access to match on the versions, use `.as_ref()` or `.as_mut()`. $vis struct $versioned_name #full_generics { inner: Option<#versions_type>, } impl #impl_generics #versioned_type { pub fn new(inner: #versions_type) -> Self { Self { inner: Some(inner), } } } impl #impl_generics AsRef<#versions_type> for #versioned_type { fn as_ref(&self) -> &#versions_type { self.inner.as_ref().unwrap() } } impl #impl_generics AsMut<#versions_type> for #versioned_type { fn as_mut(&mut self) -> &mut #versions_type { self.inner.as_mut().unwrap() } } impl #impl_generics From<#versions_type> for #versioned_type { fn from(value: #versions_type) -> Self { Self::new(value) } } impl #impl_generics From<#versioned_type> for #versions_type { fn from(value: #versioned_type) -> Self { value.inner.unwrap() } } impl #impl_generics Versioned for #versioned_type { type Versions = #versions_type; 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! #discriminators = [!ident! $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(#permit_sbor_attribute_alias)] $(#[$attributes])* $($(#[$inner_attributes])*)? $vis enum $versions_name #full_generics { $($( #[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 #impl_generics #versions_type { /// 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) -> #versioned_type { #versioned_type_path::new(self) } } $($( #[allow(dead_code)] impl #impl_generics From<$version_type> for #versions_type { fn from(value: $version_type) -> Self { Self::[!ident! V $version_num](value) } } #[allow(dead_code)] impl #impl_generics From<$version_type> for #versioned_type { fn from(value: $version_type) -> Self { Self::new(#versions_type_path::[!ident! V $version_num](value)) } } )*)? #[allow(dead_code)] impl #impl_generics From<$latest_version_type> for #versions_type { fn from(value: $latest_version_type) -> Self { Self::[!ident! V $latest_version](value) } } #[allow(dead_code)] impl #impl_generics From<$latest_version_type> for #versioned_type { 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! #version_trait = [!ident! $versioned_name Version]] #[allow(dead_code)] $vis trait #version_trait { // 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 #impl_generics #version_trait for $version_type { type Versioned = #versioned_type; 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 { #versioned_type_path::new(self.into()) } } )*)? impl #impl_generics #version_trait for $latest_version_type { type Versioned = $versioned_name #type_generics; 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 { #versioned_type_path::new(self.into()) } } }, (&'a PackageCodeOriginalCodeV1,)> 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

impl Eq for PackageCodeOriginalCodeV1

impl StructuralPartialEq for PackageCodeOriginalCodeV1