Struct RuntimeInternal 

pub struct RuntimeInternal {
    pub memory: RefCell<Memory>,
    pub com_hub: ComHub,
    pub endpoint: Endpoint,
    pub config: RuntimeConfig,
    pub execution_contexts: RefCell<HashMap<IncomingEndpointContextSectionId, ExecutionContext>>,
    /* private fields */
}

Fields

memory: RefCell<Memory>

com_hub: ComHub

endpoint: Endpoint

config: RuntimeConfig

execution_contexts: RefCell<HashMap<IncomingEndpointContextSectionId, ExecutionContext>>

active execution contexts, stored by context_id

Implementations

impl RuntimeInternal

pub fn start_update_loop(self_rc: Rc<RuntimeInternal>)

Starts the

pub async fn stop_update_loop(self_rc: Rc<RuntimeInternal>)

Stops the update loop for the Runtime, if it is running.

impl RuntimeInternal

pub async fn execute( self_rc: Rc<RuntimeInternal>, script: &str, inserted_values: &[ValueContainer], execution_context: Option<&mut ExecutionContext>, ) -> Result<Option<ValueContainer>, ScriptExecutionError>

pub fn execute_sync( self_rc: Rc<RuntimeInternal>, script: &str, inserted_values: &[ValueContainer], execution_context: Option<&mut ExecutionContext>, ) -> Result<Option<ValueContainer>, ScriptExecutionError>

pub fn execute_dxb<'a>( self_rc: Rc<RuntimeInternal>, dxb: Vec<u8>, execution_context: Option<&'a mut ExecutionContext>, end_execution: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<ValueContainer>, ExecutionError>> + 'a>>

pub fn execute_dxb_sync( self_rc: Rc<RuntimeInternal>, dxb: &[u8], execution_context: Option<&mut ExecutionContext>, end_execution: bool, ) -> Result<Option<ValueContainer>, ExecutionError>

pub async fn execute_remote( self_rc: Rc<RuntimeInternal>, remote_execution_context: &mut RemoteExecutionContext, dxb: Vec<u8>, ) -> Result<Option<ValueContainer>, ExecutionError>

Trait Implementations

impl DIFInterface for RuntimeInternal

fn update( &self, source_id: TransceiverId, address: PointerAddress, update: DIFUpdateData, ) -> Result<(), DIFUpdateError>

Applies a DIF update to the value at the given pointer address.

async fn resolve_pointer_address_external( &self, address: PointerAddress, ) -> Result<DIFReference, DIFResolveReferenceError>

Resolves a pointer address of a pointer that may not be in memory. If the pointer is not in memory, it will be loaded from external storage.

fn resolve_pointer_address_in_memory( &self, address: PointerAddress, ) -> Result<DIFReference, DIFResolveReferenceError>

Resolves a pointer address of a pointer that is currently in memory. Returns an error if the pointer is not found in memory.

fn apply( &self, callee: DIFValueContainer, value: DIFValueContainer, ) -> Result<DIFValueContainer, DIFApplyError>

Executes an apply operation, applying the value to the callee.

fn create_pointer( &self, value: DIFValueContainer, allowed_type: Option<DIFTypeContainer>, mutability: ReferenceMutability, ) -> Result<PointerAddress, DIFCreatePointerError>

Creates a new pointer and stores it in memory. Returns the address of the newly created pointer.

fn observe_pointer<F: Fn(&DIFUpdate) + 'static>( &self, transceiver_id: TransceiverId, address: PointerAddress, options: ObserveOptions, callback: F, ) -> Result<u32, DIFObserveError>

Starts observing changes to the pointer at the given address. As long as the pointer is observed, it will not be garbage collected.

fn update_observer_options( &self, address: PointerAddress, observer_id: u32, options: ObserveOptions, ) -> Result<(), DIFObserveError>

Updates the options for an existing observer on the pointer at the given address. If the observer does not exist, an error is returned.

fn unobserve_pointer( &self, address: PointerAddress, observer_id: u32, ) -> Result<(), DIFObserveError>

Stops observing changes to the pointer at the given address. If no other references to the pointer exist, it may be garbage collected after this call.

impl Debug for RuntimeInternal

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

Formats the value using the given formatter.

impl Default for RuntimeInternal

fn default() -> Self

Returns the “default value” for a type.