Enum Tag

#[repr(u8)]
pub enum Tag {
    False = 0,
    True = 1,
    Void = 2,
    Error = 3,
    U32Val = 4,
    I32Val = 5,
    U64Small = 6,
    I64Small = 7,
    TimepointSmall = 8,
    DurationSmall = 9,
    U128Small = 10,
    I128Small = 11,
    U256Small = 12,
    I256Small = 13,
    SymbolSmall = 14,
    SmallCodeUpperBound = 15,
    ObjectCodeLowerBound = 63,
    U64Object = 64,
    I64Object = 65,
    TimepointObject = 66,
    DurationObject = 67,
    U128Object = 68,
    I128Object = 69,
    U256Object = 70,
    I256Object = 71,
    BytesObject = 72,
    StringObject = 73,
    SymbolObject = 74,
    VecObject = 75,
    MapObject = 76,
    AddressObject = 77,
    ObjectCodeUpperBound = 78,
    Bad = 127,
}

Code values for the 8 tag bits in the bit-packed representation of Val. These don’t coincide with tag numbers in the SCVal XDR but cover all those cases as well as some optimized refinements for special cases (boolean true and false, small-value forms).

Variants

False = 0

Tag for a Val that encodes bool false. The bool type is refined to two single-value subtypes in order for each tag number to coincide with the WASM encoding of a boolean.

True = 1

Tag for a Val that encodes bool true.

Void = 2

Tag for a Val that is empty/absent (eg. void, null, nil, undefined, None)

Error = 3

Tag for a Val that is contains an error code.

U32Val = 4

Tag for a Val that contains a u32 number.

I32Val = 5

Tag for a Val that contains an i32 number.

U64Small = 6

Tag for a Val that contains a u64 small enough to fit in 56 bits.

I64Small = 7

Tag for a Val that contains an i64 small enough to fit in 56 bits.

TimepointSmall = 8

Tag for a Val that contains a u64 timepoint small enough to fit in 56 bits.

DurationSmall = 9

Tag for a Val that contains a u64 duration small enough to fit in 56 bits.

U128Small = 10

Tag for a Val that contains a u128 small enough to fit in 56 bits.

I128Small = 11

Tag for a Val that contains an i128 small enough to fit in 56 bits.

U256Small = 12

Tag for a Val that contains a u256 small enough to fit in 56 bits.

I256Small = 13

Tag for a Val that contains an i256 small enough to fit in 56 bits.

SymbolSmall = 14

Tag for a Val that contains up to 9 character symbols.

SmallCodeUpperBound = 15

Code delimiting the upper boundary of “small” types.

ObjectCodeLowerBound = 63

Tag reserved to indicate boundary between tags for “small” types with their payload packed into the remaining 56 bits of the Val and “object” types that are stored as host objects and referenced by Object handle.

U64Object = 64

Tag for a Val that refers to a host-side u64 number.

I64Object = 65

Tag for a Val that refers to a host-side i64 number.

TimepointObject = 66

Tag for a Val that refers to a host-side u64 number encoding a time-point (a count of seconds since the Unix epoch, Jan 1 1970 UTC).

DurationObject = 67

Tag for a Val that refers to a host-side i64 number encoding a duration (a count of seconds).

U128Object = 68

Tag for a Val that refers to a host-side u128 number.

I128Object = 69

Tag for a Val that refers to a host-side i128 number.

U256Object = 70

Tag for a Val that refers to a host-side u256 number.

I256Object = 71

Tag for a Val that refers to a host-side i256 number.

BytesObject = 72

Tag for a Val that refers to a host-side byte array.

StringObject = 73

Tag for a Val that refers to a host-side string.

SymbolObject = 74

Tag for a Val that refers to a host-side symbol (see Symbol).

VecObject = 75

Tag for a Val that refers to a host-side vector of Vals.

MapObject = 76

Tag for a Val that refers to a host-side map from Vals to Vals.

AddressObject = 77

Tag for a Val that refers to a host-side contract address.

ObjectCodeUpperBound = 78

Code delimiting the upper boundary of “object” types.

Bad = 127

Code reserved to indicate mis-tagged Vals.

Implementations

impl Tag

pub const fn val_mask() -> i64

pub fn val_const(&self) -> i64

pub const fn is_object(self) -> bool

pub const fn from_u8(tag: u8) -> Tag

pub const fn get_scval_type(&self) -> Option<ScValType>

Get the ScValType of the XDR type that corresponds to this tag.

For use in the Host::obj_cmp comparison function so that comparison based on tags can be done identically to the ScVal type.

Returns None for Tag::Bad, and for the three marker tags SmallCodeUpperBound, ObjectCodeLowerBound, ObjectCodeUpperBound.

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl Hash for Tag

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Tag

fn cmp(&self, other: &Tag) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Tag

fn eq(&self, other: &Tag) -> 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 PartialOrd for Tag

fn partial_cmp(&self, other: &Tag) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Tag

impl Eq for Tag

impl StructuralPartialEq for Tag