Struct ExecutorContext

pub struct ExecutorContext {
    pub engine: Arc<Box<dyn EngineManager>>,
    pub fs: Arc<FileManager>,
    pub stdlib: Arc<StdLib>,
    pub settings: ExecutorSettings,
    pub context_type: ContextType,
}

The executor context. Cloning will return another handle to the same engine connection/session, as this uses Arc under the hood.

Fields

engine: Arc<Box<dyn EngineManager>>

fs: Arc<FileManager>

stdlib: Arc<StdLib>

settings: ExecutorSettings

context_type: ContextType

Implementations

impl ExecutorContext

pub async fn new(client: &Client, settings: ExecutorSettings) -> Result<Self>

Create a new default executor context.

pub async fn new_mock() -> Self

pub fn new_forwarded_mock(engine: Arc<Box<dyn EngineManager>>) -> Self

pub async fn new_with_client( settings: ExecutorSettings, token: Option<String>, engine_addr: Option<String>, ) -> Result<Self>

Create a new default executor context. With a kittycad client. This allows for passing in ZOO_API_TOKEN and ZOO_HOST as environment variables. But also allows for passing in a token and engine address directly.

pub async fn new_with_default_client(units: UnitLength) -> Result<Self>

Create a new default executor context. With the default kittycad client. This allows for passing in ZOO_API_TOKEN and ZOO_HOST as environment variables.

pub fn is_mock(&self) -> bool

pub async fn new_for_unit_test( units: UnitLength, engine_addr: Option<String>, ) -> Result<Self>

For executing unit tests.

pub async fn reset_scene( &self, exec_state: &mut ExecState, source_range: SourceRange, ) -> Result<(), KclError>

pub async fn get_changed_program( &self, info: CacheInformation, ) -> Option<CacheResult>

pub async fn run( &self, cache_info: CacheInformation, exec_state: &mut ExecState, ) -> Result<(), KclError>

Perform the execution of a program. You can optionally pass in some initialization memory. Kurt uses this for partial execution.

pub async fn run_with_session_data( &self, cache_info: CacheInformation, exec_state: &mut ExecState, ) -> Result<Option<ModelingSessionData>, KclError>

Perform the execution of a program. You can optionally pass in some initialization memory. Kurt uses this for partial execution.

pub fn execute_expr<'a: 'async_recursion, 'life0, 'life1, 'life2, 'life_self, 'async_recursion>( &'life_self self, init: &'life0 Expr, exec_state: &'life1 mut ExecState, metadata: &'life2 Metadata, statement_kind: StatementKind<'a>, ) -> Pin<Box<dyn Future<Output = Result<KclValue, KclError>> + Send + 'async_recursion>>

where 'life0: 'async_recursion, 'life1: 'async_recursion, 'life2: 'async_recursion, 'life_self: 'async_recursion,

pub fn update_units(&mut self, units: UnitLength)

Update the units for the executor.

pub async fn prepare_snapshot(&self) -> Result<TakeSnapshot, ExecError>

Get a snapshot of the current scene.

pub async fn execute_and_prepare_snapshot( &self, program: &Program, exec_state: &mut ExecState, ) -> Result<TakeSnapshot, ExecError>

Execute the program, then get a PNG screenshot.

Trait Implementations

impl Clone for ExecutorContext

fn clone(&self) -> ExecutorContext

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutorContext

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

Formats the value using the given formatter.