Runtime arguments
The runtime representation of the static arguments from the code. It has the same set of types and easily transforms one to another
#![allow(unused)] fn main() { #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)] pub enum RtValue { String(String), Bool(bool), Array(Vec<RtValue>), Object(HashMap<String, RtValue>), Number(RtValueNumber), Pointer(BBKey) ... } }
Primitive types
The types String
, Bool
, Number
are primitive types. They act as their counterparts in the other languages
Complex types
The types Object
acts as a json map and Array
just as an array.
Pointer
Represents a name of the cell in bb. For example, in the expression equal(tick, 10)
the tick is a pointer and represents
a name of the cell where the value is stored. Thus, the action will go to the cell tick
and extract the value and compare
it with number.
import "std::actions"
impl incr(k:string, i:num);
root main r_sequence{
store_tick("tick")
sequence {
r_fallback {
equal(tick, 10)
running()
}
}
}
Remark.
The action store_tick("tick")
accepts a cell name as a string,
otherwise if it is a pointer the action will be looking a name inside the cell with the name tick
.
The example depicts it:
store("x","tick")
store_tick(x)
equal(tick, 10)
How to work with arguments
There are two ways to extract the values from the arguments:
Directly using as_ method
Every argument can be immediately converted to the specific primitive or complex type.
#![allow(unused)] fn main() { fn to(v:RtValue) { let val:Option<String> = v.as_string(); } }
This is the cheapest way to do it. But also, this way does not consider pointers, therefore, it can be used only if you are sure the type is primitive or complex.
Using cast(ctx) method
The method accepts context for being able to unfold the pointer if it is presents.
#![allow(unused)] fn main() { impl Impl for CheckEq { fn tick(&self, args: RtArgs, ctx: TreeContextRef) -> Tick { let key = args .find_or_ith("key".to_string(), 0) .ok_or(RuntimeError::fail(format!("the key is expected ")))?; // cast accepts a context to be able to resolve pointers if they are presented let param = key.cast(ctx.clone()).str()?; } } }
This is method preferable if you are not sure what can come in the arguments.