Struct InlineRunner 

pub struct InlineRunner { /* private fields */ }

The default, SYNCHRONOUS runner: runs on submit, stashes the reply for an immediate poll. Behavior-identical to the pre-seam in-process run.

Implementations

impl InlineRunner

pub fn new() -> Self

Trait Implementations

impl Default for InlineRunner

fn default() -> Self

Returns the “default value” for a type.

impl HistoryRunner for InlineRunner

fn session_for_main(&mut self, generation: u64) -> SessionOnMain

The run executed on this (the caller’s) thread: its session is already here unless something has replaced it since.

fn sync_parts_library( &mut self, _revision: u64, _fetch: &mut dyn FnMut() -> PartsLibraryMap, )

Nothing to send: Inline runs on the CALLER’s thread against the CALLER’s kernel store, so the library the caller would hand over is already the one this run resolves against. (Which is also why Inline never needs the preflight — there is only one store, and the caller seeds it directly.)

fn submit_sheet_lines(&mut self, request: SheetLinesRequest) -> bool

Runs the pass at once, on the caller’s thread: an inline runner’s registry IS the caller’s, so the answer is ready for the next poll.

fn submit_plugin_install(&mut self, request: PluginInstallRequest) -> bool

fn poll_plugin_install(&mut self) -> Option<PluginInstallReply>

fn sync_plugins(&mut self, revision: u64, fetch: &mut dyn FnMut() -> Value)

Trusted installed content, separate from saved document dependency pins.

fn submit_plugin_action(&mut self, request: PluginActionRequest) -> bool

False explicitly reports a runner without action support.

fn poll_plugin_action(&mut self) -> Option<PluginActionReply>

fn submit_run(&mut self, request: HistoryRequest, generation: u64)

Submit a history run tagged with a monotonic generation. The runner executes it (immediately for Inline; on a background thread later) and makes the reply available via poll_run.

fn poll_run(&mut self) -> Option<RunReply>

Non-blocking: the next completed run reply, if any (drained each frame).

fn submit_query(&mut self, query: MeasureQuery)

Submit a per-object measurement query (answered against the runner’s warm registry). Inline computes it immediately; a thread impl computes it on the runner thread and surfaces it via poll_query.

fn poll_query(&mut self) -> Option<MeasureReply>

Non-blocking: the next completed measurement reply, if any.

fn submit_mesh_import(&mut self, request: MeshImportRequest)

Submit RANSAC mesh reconstruction to the runner’s thread/worker.

fn poll_mesh_import(&mut self) -> Option<MeshImportReply>

Non-blocking: the next completed mesh reconstruction, if any.

fn submit_step_probe(&mut self, request: StepProbeRequest)

Submit a STEP product-structure probe (see StepProbeRequest).

fn poll_step_probe(&mut self) -> Option<StepProbeReply>

Non-blocking: the next completed STEP probe, if any.

fn submit_topology(&mut self, request: TopologyRequest)

Submit a topology request (see TopologyRequest). The default drops it: a runner that never answers leaves a sheet on its mesh approximation, which the drawing reports.

fn poll_topology(&mut self) -> Option<TopologyReply>

Non-blocking: the next completed topology reply, if any.

fn poll_sheet_lines(&mut self) -> Option<SheetLinesReply>

Non-blocking: the next completed sheet-lines reply, if any.

fn reset(&mut self)

Drop the delta baseline (document switch → full rebuild).

fn wait_topology(&mut self, _timeout: Duration) -> bool

BLOCK up to timeout until a topology reply is ready to poll: true when one is. An export that needs the exact solids waits this way on a runner with a thread of its own; the default cannot wait (a worker answers through the page’s event loop, which a blocked page never turns), so the export draws the mesh approximation and the file says so.

fn submit_cam(&mut self, _job: CamJob) -> bool

Submit ONE CAM operation’s generation (see CamJob); false when this runner cannot run it.

fn poll_cam(&mut self) -> Option<CamReply>

fn poll_cam_progress(&mut self) -> Option<CamProgress>

fn cancel_cam(&mut self)

Cancel the CAM job in flight at its next work chunk, where the driver can reach it (the native thread); a driver that cannot lets the job finish and the main side drops its reply.

fn hold_cam_replies(&mut self, _hold: bool)

TEST HOLD (automation only): while hold, finished CAM replies are kept back from poll_cam, so a job stays in flight on the main side however fast it ran — the one way a script can meet it with a cancel every time. Releasing delivers what was kept, in order. A driver without the hold ignores it.

fn submit_cam_sim(&mut self, _job: CamSimJob) -> bool

Submit ONE CAM simulation command (see CamSimJob); false when this runner cannot simulate (the caller then simulates inline).

fn poll_cam_sim(&mut self) -> Option<CamSimReply>

fn poll_cam_sim_progress(&mut self) -> Option<CamSimProgress>

fn cancel_cam_sim(&mut self)

Stop the simulation chunk in flight between two motions where the driver can reach it (the native thread); elsewhere the chunk finishes and the caller drops its reply.

fn poll_library_request(&mut self) -> bool

True when the runner REFUSED a run because its resident parts library could not serve it (see Reply::NeedPartsLibrary). It has already forgotten its copy, so the next sync_parts_library reinstalls; the caller must re-submit the run. Never true for a runner that shares the caller’s store.

fn run_reply_waiting(&mut self) -> bool

Whether a run reply (or a refusal asking for the parts library) is waiting for poll_run: a caller may skip what only a landing needs while this is false. true when the runner cannot tell.

fn poll_progress(&mut self) -> Option<RunProgress>

Non-blocking: the MOST RECENT progress report of the in-flight run, with any older ones discarded (only the latest feature matters). None for a synchronous runner — Inline has finished before anyone could ask.

fn cancel(&mut self) -> bool

ABANDON the in-flight work and start over with an EMPTY resident registry. Returns false when there is nothing this runner can abandon (Inline: the run already completed on the caller’s thread). A true means every handle the caller holds is now invalid, no reply is coming for anything submitted so far, and the parts library must be re-sent — the caller reconciles its generations and pending sets accordingly (EngineState::cancel_run). Nothing inside a feature is interruptible: the thread runner lets its old thread finish the feature it is on and stop at the next boundary; the browser worker is terminated outright.