Enum cadence_json::ValueRef

pub enum ValueRef<'a> {
    Void,
    Int(BigInt),
    Int8(i8),
    Int16(i16),
    Int32(i32),
    Int64(i64),
    Int128(i128),
    Int256(BigInt),
    UInt(BigUint),
    UInt8(u8),
    UInt16(u16),
    UInt32(u32),
    UInt64(u64),
    UInt128(u128),
    UInt256(BigUint),
    Fix64(Fix64),
    UFix64(UFix64),
    Word8(Wrapping<u8>),
    Word16(Wrapping<u16>),
    Word32(Wrapping<u32>),
    Word64(Wrapping<u64>),
    Bool(bool),
    Optional(Option<Box<ValueRef<'a>>>),
    String(&'a str),
    Address(AddressRef<'a>),
    Array(&'a [ValueRef<'a>]),
    Dictionary(&'a [EntryRef<'a>]),
    Struct(CompositeRef<'a>),
    Resource(CompositeRef<'a>),
    Event(CompositeRef<'a>),
    Contract(CompositeRef<'a>),
    Enum(CompositeRef<'a>),
    Path(PathRef<'a>),
    Type(&'a str),
    Capability(CapabilityRef<'a>),
}

Variants

Void

Int(BigInt)

Tuple Fields of Int

0: BigInt

Int8(i8)

Tuple Fields of Int8

0: i8

Int16(i16)

Tuple Fields of Int16

0: i16

Int32(i32)

Tuple Fields of Int32

0: i32

Int64(i64)

Tuple Fields of Int64

0: i64

Int128(i128)

Tuple Fields of Int128

0: i128

Int256(BigInt)

Tuple Fields of Int256

0: BigInt

UInt(BigUint)

Tuple Fields of UInt

0: BigUint

UInt8(u8)

Tuple Fields of UInt8

0: u8

UInt16(u16)

Tuple Fields of UInt16

0: u16

UInt32(u32)

Tuple Fields of UInt32

0: u32

UInt64(u64)

Tuple Fields of UInt64

0: u64

UInt128(u128)

Tuple Fields of UInt128

0: u128

UInt256(BigUint)

Tuple Fields of UInt256

0: BigUint

Fix64(Fix64)

Tuple Fields of Fix64

0: Fix64

UFix64(UFix64)

Tuple Fields of UFix64

0: UFix64

Word8(Wrapping<u8>)

Tuple Fields of Word8

0: Wrapping<u8>

Word16(Wrapping<u16>)

Tuple Fields of Word16

0: Wrapping<u16>

Word32(Wrapping<u32>)

Tuple Fields of Word32

0: Wrapping<u32>

Word64(Wrapping<u64>)

Tuple Fields of Word64

0: Wrapping<u64>

Bool(bool)

Tuple Fields of Bool

0: bool

Optional(Option<Box<ValueRef<'a>>>)

Tuple Fields of Optional

0: Option<Box<ValueRef<'a>>>

String(&'a str)

Tuple Fields of String

0: &'a str

Address(AddressRef<'a>)

Tuple Fields of Address

0: AddressRef<'a>

Array(&'a [ValueRef<'a>])

Tuple Fields of Array

0: &'a [ValueRef<'a>]

Dictionary(&'a [EntryRef<'a>])

Tuple Fields of Dictionary

0: &'a [EntryRef<'a>]

Struct(CompositeRef<'a>)

Tuple Fields of Struct

0: CompositeRef<'a>

Resource(CompositeRef<'a>)

Tuple Fields of Resource

0: CompositeRef<'a>

Event(CompositeRef<'a>)

Tuple Fields of Event

0: CompositeRef<'a>

Contract(CompositeRef<'a>)

Tuple Fields of Contract

0: CompositeRef<'a>

Enum(CompositeRef<'a>)

Tuple Fields of Enum

0: CompositeRef<'a>

Path(PathRef<'a>)

Tuple Fields of Path

0: PathRef<'a>

Type(&'a str)

Tuple Fields of Type

0: &'a str

Capability(CapabilityRef<'a>)

Tuple Fields of Capability

0: CapabilityRef<'a>

Implementations

impl ValueRef<'_>

pub fn ty(&self) -> Type

Trait Implementations

impl<'a> AsRef<ValueRef<'a>> for ValueRef<'a>

fn as_ref(&self) -> &ValueRef<'a>

Performs the conversion.

impl<'a> Clone for ValueRef<'a>

fn clone(&self) -> ValueRef<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ValueRef<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq<ValueRef<'a>> for ValueRef<'a>

fn eq(&self, other: &ValueRef<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ValueRef<'a>) -> bool

This method tests for !=.

impl<'a> Serialize for ValueRef<'a>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a> Eq for ValueRef<'a>

impl<'a> StructuralEq for ValueRef<'a>

impl<'a> StructuralPartialEq for ValueRef<'a>