Struct EmbeddedProgram 

pub struct EmbeddedProgram { /* private fields */ }

Implementations

impl EmbeddedProgram

pub fn builder() -> EmbeddedBuilder

pub fn vm_mut(&mut self) -> &mut VM

pub fn set_gas_budget(&mut self, limit: u64)

pub fn clear_gas_budget(&mut self)

pub fn reset_gas_counter(&mut self)

pub fn gas_used(&self) -> u64

pub fn gas_remaining(&self) -> Option<u64>

pub fn set_memory_budget_bytes(&mut self, limit_bytes: usize)

pub fn set_memory_budget_kb(&mut self, limit_kb: u64)

pub fn clear_memory_budget(&mut self)

pub fn reset_memory_counter(&mut self)

pub fn memory_used_bytes(&self) -> usize

pub fn memory_remaining_bytes(&self) -> Option<usize>

pub fn dump_externs_to_dir( &self, output_root: impl AsRef<Path>, ) -> Result<Vec<PathBuf>>

pub fn global_names(&self) -> Vec<String>

pub fn globals(&self) -> Vec<(String, Value)>

pub fn signature(&self, function_name: &str) -> Option<&FunctionSignature>

pub fn typed_functions( &self, ) -> impl Iterator<Item = (&String, &FunctionSignature)>

pub fn struct_definition(&self, type_name: &str) -> Option<&StructDef>

pub fn enum_definition(&self, type_name: &str) -> Option<&EnumDef>

pub fn get_global_value(&self, name: &str) -> Option<Value>

pub fn get_typed_global<T: FromLustValue>( &self, name: &str, ) -> Result<Option<T>>

pub fn set_global_value<V: IntoTypedValue>( &mut self, name: impl Into<String>, value: V, )

pub fn struct_instance<I>( &self, type_name: impl Into<String>, fields: I, ) -> Result<StructInstance>

where I: IntoIterator, I::Item: Into<StructField>,

pub fn enum_variant( &self, type_name: impl Into<String>, variant: impl Into<String>, ) -> Result<EnumInstance>

pub fn enum_variant_with<I, V>( &self, type_name: impl Into<String>, variant: impl Into<String>, payload: I, ) -> Result<EnumInstance>

where I: IntoIterator<Item = V>, V: IntoTypedValue,

pub fn register_native_fn<F>(&mut self, name: impl Into<String>, func: F)

where F: Fn(&[Value]) -> Result<NativeCallResult, String> + 'static,

pub fn register_async_native<F, Fut>( &mut self, name: impl Into<String>, func: F, ) -> Result<()>

where F: Fn(Vec<Value>) -> Fut + 'static, Fut: Future<Output = Result<Value, String>> + 'static,

pub fn register_typed_native<Args, R, F>( &mut self, name: &str, func: F, ) -> Result<()>

where Args: FromLustArgs, R: IntoLustValue + FromLustValue, F: Fn(Args) -> Result<R, String> + 'static,

pub fn register_async_typed_native<Args, R, F, Fut>( &mut self, name: &str, func: F, ) -> Result<()>

where Args: FromLustArgs, R: IntoLustValue + FromLustValue, F: Fn(Args) -> Fut + 'static, Fut: Future<Output = Result<R, String>> + 'static,

pub fn register_async_task_native<Args, R, F, Fut>( &mut self, name: &str, func: F, ) -> Result<()>

where Args: FromLustArgs, R: IntoLustValue + FromLustValue, F: Fn(Args) -> Fut + 'static, Fut: Future<Output = Result<R, String>> + 'static,

pub fn register_async_task_queue<Args, R>( &mut self, name: &str, queue: AsyncTaskQueue<Args, R>, ) -> Result<()>

where Args: FromLustArgs + 'static, R: IntoLustValue + FromLustValue + 'static,

pub fn call_typed<Args, R>( &mut self, function_name: &str, args: Args, ) -> Result<R>

where Args: FunctionArgs, R: FromLustValue,

pub fn call_raw( &mut self, function_name: &str, args: Vec<Value>, ) -> Result<Value>

pub fn function_handle(&self, function_name: &str) -> Result<FunctionHandle>

pub fn run_entry_script(&mut self) -> Result<()>

pub fn poll_async_tasks(&mut self) -> Result<()>

pub fn has_pending_async_tasks(&self) -> bool