Enum candid::parser::value::IDLValue

pub enum IDLValue {
    Bool(bool),
    Null,
    Text(String),
    Number(String),
    Float64(f64),
    Opt(Box<IDLValue>),
    Vec(Vec<IDLValue>),
    Record(Vec<IDLField>),
    Variant(VariantValue),
    Principal(Principal),
    Service(Principal),
    Func(Principal, String),
    None,
    Int(Int),
    Nat(Nat),
    Nat8(u8),
    Nat16(u16),
    Nat32(u32),
    Nat64(u64),
    Int8(i8),
    Int16(i16),
    Int32(i32),
    Int64(i64),
    Float32(f32),
    Reserved,
}

Variants

Bool(bool)

Tuple Fields

0: bool

Null

Text(String)

Tuple Fields

0: String

Number(String)

Tuple Fields

0: String

Float64(f64)

Tuple Fields

0: f64

Opt(Box<IDLValue>)

Tuple Fields

0: Box<IDLValue>

Vec(Vec<IDLValue>)

Tuple Fields

0: Vec<IDLValue>

Record(Vec<IDLField>)

Tuple Fields

0: Vec<IDLField>

Variant(VariantValue)

Tuple Fields

0: VariantValue

Principal(Principal)

Tuple Fields

0: Principal

Service(Principal)

Tuple Fields

0: Principal

Func(Principal, String)

Tuple Fields

0: Principal

1: String

None

Int(Int)

Tuple Fields

0: Int

Nat(Nat)

Tuple Fields

0: Nat

Nat8(u8)

Tuple Fields

0: u8

Nat16(u16)

Tuple Fields

0: u16

Nat32(u32)

Tuple Fields

0: u32

Nat64(u64)

Tuple Fields

0: u64

Int8(i8)

Tuple Fields

0: i8

Int16(i16)

Tuple Fields

0: i16

Int32(i32)

Tuple Fields

0: i32

Int64(i64)

Tuple Fields

0: i64

Float32(f32)

Tuple Fields

0: f32

Reserved

Implementations

impl IDLValue

pub fn annotate_type(
    &self,
    from_parser: bool,
    env: &TypeEnv,
    t: &Type
) -> Result<Self>

Anotate IDLValue with the given type, allowing subtyping. If IDLValue is parsed from string, we need to set from_parser to true to enable converting numbers to the expected types, and disable the opt rules.

pub fn value_ty(&self) -> Type

Trait Implementations

impl CandidType for IDLValue

fn ty() -> Type

fn id() -> TypeId

fn _ty() -> Type

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

impl Clone for IDLValue

fn clone(&self) -> IDLValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IDLValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IDLValue

fn deserialize<D>(deserializer: D) -> Result<IDLValue, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for IDLValue

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

Formats the value using the given formatter.

impl FromStr for IDLValue

type Err = Error

The associated error which can be returned from parsing.

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<IDLValue> for IDLValue

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

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

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

This method tests for !=.

impl StructuralPartialEq for IDLValue