Struct ThreadRunner 

pub struct ThreadRunner { /* private fields */ }

The persistent-thread runner. submit_*/reset push Commands down the channel; poll_* first DRAIN every ready Reply into the two demux buffers, then pop the matching one. The SceneRunner (and thus the kernel’s resident registry it warms) lives ENTIRELY on the thread — it is never shared — so the only cross-thread traffic is the Send command/reply payloads.

Implementations

impl ThreadRunner

pub fn new() -> Self

Trait Implementations

impl Default for ThreadRunner

Available on non-WebAssembly only.

fn default() -> Self

Returns the “default value” for a type.

impl Drop for ThreadRunner

Available on non-WebAssembly only.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl HistoryRunner for ThreadRunner

Available on non-WebAssembly only.

fn cancel(&mut self) -> bool

Abandon the thread: raise its stop flag, close its channels, and spawn a fresh thread with a fresh registry. The old thread cannot be interrupted inside a feature — it finishes the one it is on (burning CPU until then), sees the flag, and exits. Always true: there is always a thread to replace.

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

The assembly session the run of generation left, for the main thread’s constraint actions. Blocking, but bounded. The default cannot provide one, and the caller replays the history instead.

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 sync_parts_library( &mut self, revision: u64, fetch: &mut dyn FnMut() -> PartsLibraryMap, )

Bring the runner’s resident PARTS LIBRARY up to revision, calling fetch ONLY when it is not already there. Called immediately before every submit_run.

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 poll_run(&mut self) -> Option<RunReply>

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

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 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 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_sheet_lines(&mut self, request: SheetLinesRequest) -> bool

Submit a sheet placement’s exact pass (see SheetLinesRequest). false when this runner cannot run one — the engine then runs it on its own thread, as every projection did before the pass moved off it.

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

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

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 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 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 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_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 reset(&mut self)

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