Struct GXRt 

pub struct GXRt<X: GXExt> {
    pub ext: X,
    /* private fields */
}

Fields

ext: X

Implementations

impl<X: GXExt> GXRt<X>

pub fn new(publisher: Publisher, subscriber: Subscriber) -> Self

Trait Implementations

impl<X: Debug + GXExt> Debug for GXRt<X>

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

Formats the value using the given formatter.

impl<X: GXExt> Rt for GXRt<X>

type AbortHandle = AbortHandle

fn clear(&mut self)

fn call_rpc(&mut self, name: Path, args: Vec<(ArcStr, Value)>, id: BindId)

This must return results from the same path in the call order.

fn publish_rpc( &mut self, name: Path, doc: Value, spec: Vec<ArgSpec>, id: BindId, ) -> Result<()>

Publish an rpc at the specified path with the specified procedure level doc and arg spec.

fn unpublish_rpc(&mut self, name: Path)

unpublish the rpc identified by the bind id.

fn subscribe(&mut self, flags: UpdatesFlags, path: Path, ref_by: ExprId) -> Dval

Subscribe to the specified netidx path

fn unsubscribe(&mut self, _path: Path, dv: Dval, ref_by: ExprId)

Called when a subscription is no longer needed

fn list(&mut self, id: BindId, path: Path)

List the netidx path, return Value::Null if the path did not change. When the path did update you should send the output back as a properly formatted struct with two fields, rows and columns both containing string arrays.

fn list_table(&mut self, id: BindId, path: Path)

List the table at path, return Value::Null if the path did not change

fn stop_list(&mut self, id: BindId)

list or table will no longer be called on this BindId, and related resources can be cleaned up.

fn publish(&mut self, path: Path, value: Value, ref_by: ExprId) -> Result<Val>

Publish the specified value, returning it’s Id, which must be used to update the value and unpublish it. If the path is already published, return an error.

fn update(&mut self, val: &Val, value: Value)

Update the specified value

fn unpublish(&mut self, val: Val, ref_by: ExprId)

Stop publishing the specified id

fn set_timer(&mut self, id: BindId, timeout: Duration)

arrange to have a Timer event delivered after timeout. When the timer expires you are expected to deliver a Variable event for the id, containing the current time.

fn ref_var(&mut self, id: BindId, ref_by: ExprId)

This will be called by the compiler whenever a bound variable is referenced. The ref_by is the toplevel expression that contains the variable reference. When a variable event happens, you should update all the toplevel expressions that ref that variable.

fn unref_var(&mut self, id: BindId, ref_by: ExprId)

fn set_var(&mut self, id: BindId, value: Value)

Called by the ExecCtx when set_var is called on it.

fn notify_set(&mut self, id: BindId)

Notify the RT that a top level variable has been set internally

fn spawn<F: Future<Output = (BindId, Box<dyn CustomBuiltinType>)> + Send + 'static>( &mut self, f: F, ) -> Self::AbortHandle

Spawn a task

fn spawn_var<F: Future<Output = (BindId, Value)> + Send + 'static>( &mut self, f: F, ) -> Self::AbortHandle

Spawn a task

fn watch( &mut self, s: Receiver<GPooled<Vec<(BindId, Box<dyn CustomBuiltinType>)>>>, )

Ask the runtime to watch a channel

fn watch_var(&mut self, s: Receiver<GPooled<Vec<(BindId, Value)>>>)

Ask the runtime to watch a channel