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>

Given an old ast, old program memory and new ast, find the parts of the code that need to be re-executed. This function should never error, because in the case of any internal error, we should just pop the cache.

Returns None when there are no changes to the program, i.e. it is fully cached.

pub fn generate_changed_program( &self, old_ast: Node<AstProgram>, new_ast: Node<AstProgram>, ) -> CacheResult

Force-generate a new CacheResult, even if one shouldn’t be made. The way in which this gets invoked should always be through Self::get_changed_program. This is purely to contain the logic on how we construct a new [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 for partial execution.

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

Perform the execution of a program.

You can optionally pass in some initialization memory for partial execution.

The error includes additional outputs used for the feature tree and artifact graph.

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. Additionally return engine session data.

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.

pub async fn close(&self)

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.