Enum brane_exe::value::Value

pub enum Value {
    Boolean {
        value: bool,
    },
    Integer {
        value: i64,
    },
    Real {
        value: f64,
    },
    String {
        value: String,
    },
    Array {
        values: Vec<Self>,
    },
    Function {
        def: usize,
    },
    Instance {
        values: HashMap<String, Self>,
        def: usize,
    },
    Method {
        values: HashMap<String, Self>,
        cdef: usize,
        fdef: usize,
    },
    Data {
        name: String,
    },
    IntermediateResult {
        name: String,
    },
    Void,
}

Defines a single Value while executing a Workflow. That’s basically an instantiated DataType.

Variants

Boolean

It’s a boolean value (true/false)

Fields

value: bool

Integer

It’s an integer value (non-fractional numbers)

Fields

value: i64

Real

It’s a real value (fractional numbers)

Fields

value: f64

String

It’s a string value (UTF-8 characters)

Fields

value: String

Array

It’s an Array of values

Fields

values: Vec<Self>

Function

It’s a function object, that references a Function in the workflow table.

Fields

def: usize

Instance

It’s an instance object, that maps field names to values.

Fields

values: HashMap<String, Self>

def: usize

Method

It’s a method object, which merges a function and an instance together into one.

Fields

values: HashMap<String, Self>

cdef: usize

fdef: usize

Data

It’s a data object that contains the identifier of the dataset referenced.

Fields

name: String

IntermediateResult

It’s an intermediate result object that contains the identifier of the dataset or result referenced.

Fields

name: String

Void

No value

Implementations

impl Value

pub fn try_as_bool(self) -> Option<bool>

Returns the top value on the stack as if it was a boolean.

Returns

The boolean value if it actually was a boolean, or else None.

pub fn try_as_int(self) -> Option<i64>

Returns the top value on the stack as if it was an integer.

Returns

The integer value if it actually was a integer, or else None.

pub fn try_as_string(self) -> Option<String>

Returns the top value on the stack as if it was a string.

Returns

The string value if it actually was a string, or else None.

pub fn try_as_array(self) -> Option<Vec<Self>>

Returns the top value on the stack as if it was an array (of any type).

Returns

An array of values if it actually was an array, or else None.

pub fn try_as_func(self) -> Option<usize>

Returns the top value on the stack as if it was a callable (function) of some sort (of any signature).

Returns

The function’s index if it actually was a callable, or else None.

pub fn try_as_instance(self) -> Option<(HashMap<String, Self>, usize)>

Returns the top value on the stack as if it was an instance (of any type).

Returns

A tuple with the definition and the map of field names -> values if it actually was an instance, or else None.

pub fn try_as_method(self) -> Option<(HashMap<String, Self>, usize, usize)>

Returns the top value on the stack as if it was a method (of any type).

Returns

A tuple with the definition and the map of field names -> values if it actually was an instance, or else None.

pub fn try_as_intermediate_result(self) -> Option<String>

Returns the top value on the stack as if it was an IntermediateResult.

Returns

The name of the intermediate result, if any.

pub fn cast(self, target: &DataType, table: &SymTable) -> Result<Self, Error>

Attempts to cast this Value to another one, according to the casting rules.

Arguments

• target: The target type to cast to.
• table: The VirtualSymTable that we use to resolve specific data types.

Returns

A new Value that contains the casted representation of this value.

Errors

This function errors if this value is not casteable to the given type.

pub fn data_type(&self, table: &SymTable) -> DataType

Returns the DataType of this Value. Note that the following properties may be assumed:

• The datatype is never Void (since it is a value)
• Because it is runtime, it always has a non-Any type (i.e., it’s always resolved).

Arguments

• table: The VirtualSymTable that we use to resolve specific data types.

pub fn display<'a, 'b>(&'a self, table: &'b SymTable) -> ValueDisplay<'a, 'b>

Allows the Value to be displayed with resolved definitions.

Arguments

• table: The VirtualSymTable to resolve the definitions with.

Returns

A ValueDisplay that implements the resolving Display for a Value.

pub fn to_full(&self, table: &SymTable) -> FullValue

Converts this Value into a FullValue by resolving the necessary definitions.

Arguments

• table: The VirtualSymTable that contains the definitions which we will resolve.

Returns

A new FullValue instance that is a copy of this Value.

pub fn into_full(self, table: &SymTable) -> FullValue

Converts this Value into a FullValue by resolving the necessary definitions.

This overload consumes self, allowing for a more efficient conversion in cases where object are concerned.

Arguments

• table: The VirtualSymTable that contains the definitions which we will resolve.

Returns

A new FullValue instance that is a copy of this Value.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl From<&Value> for StackSlot

fn from(value: &Value) -> Self

Converts to this type from the input type.

impl From<Value> for StackSlot

fn from(value: Value) -> Self

Converts to this type from the input type.

impl PartialEq for Value

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