Struct EngineHost 

pub struct EngineHost { /* private fields */ }

A shared, thread-safe front end to one engine.

The engine is a single-threaded-apartment COM object: its wrappers are deliberately neither Send nor Sync, and driving one from several threads does not work. A server, though, is inherently multi-threaded.

This resolves that by giving the engine a thread of its own. Callers submit work; the engine thread runs it and sends the answer back. Because the work is a closure rather than a fixed command list, the whole API is reachable without enumerating it:

use rs_teststand_bridge::EngineHost;

let host = EngineHost::start()?;
let version = host.with_engine(|engine| engine.version_string()).await??;
println!("TestStand {version}");

The same thread polls the message queue and broadcasts what it finds, so a host can serve requests and forward progress at once, which is what an IPC layer needs and what a single-threaded caller cannot do.

Implementations

impl EngineHost

pub fn start() -> Result<Self, Error>

Starts an engine on a dedicated thread.

Message polling is enabled, so anything a sequence posts reaches subscribe without further setup.

Errors

Error if the engine cannot be created.

pub async fn with_engine<F, T>(&self, work: F) -> Result<T, Error>

where F: FnOnce(&Engine) -> T + Send + 'static, T: Send + 'static,

Runs a closure against the engine and waits for its result.

The closure runs on the engine’s thread, so it may use any part of the API. Its result must be Send to come back.

The outer error means the engine thread is gone; the inner one is whatever the closure produced.

Errors

Error if the engine thread has stopped.

pub fn subscribe(&self) -> Receiver<MessageEvent>

Receives every message posted from now on.

Each subscriber gets its own copy. One that falls further behind than the backlog is told how many it missed rather than quietly losing them.

pub fn subscriber_count(&self) -> usize

How many subscribers are currently listening.

Trait Implementations

impl Debug for EngineHost

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

Formats the value using the given formatter.

impl Drop for EngineHost

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.