Enum Command 

#[non_exhaustive]
pub enum Command {
    VersionString,
    Login {
        user_name: String,
        password: String,
    },
    Logout,
    LoadFile {
        path: String,
    },
    Start {
        sequence: String,
    },
    Run {
        sequence_file: String,
        sequence: String,
    },
    Terminate {
        execution_id: i32,
    },
    Control {
        execution_id: Option<i32>,
        control: ExecutionControl,
    },
    ReadValue {
        execution_id: i32,
        lookup: String,
    },
    Shutdown,
}

A request from a front end, addressed to the host that owns the engine.

Every variant is something the engine can do on its own thread, because that is where the host will run it. Nothing here returns a COM reference: a command’s answer is a Response, which is data.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

VersionString

Ask the engine what it is.

Answers with Engine.VersionString and Engine.Is64Bit, which are the members it reads. Named for them rather than for a greeting: a command called hello describes the conversation, not the engine operation, and somebody reading the vendor documentation would not find it.

Cheap, and worth sending first: it distinguishes “the socket connected” from “the engine is up”, which are not the same and fail differently.

Login

Log a user in, by name.

The host looks the account up, checks the password, and makes it current. An account with no password takes an empty string, which is ordinary on a station where the operator is identified but not authenticated.

Fields

user_name: String

The account’s login name.

password: String

The password to check. Empty when the account has none.

Logout

Log the current user out, leaving nobody logged in.

LoadFile

Open a sequence file and hold it, without running anything.

Separate from Start because loading is where a bad path or a missing dependency shows up, and a panel wants that answer before it offers a run button.

Fields

path: String

Path to the sequence file, as the host’s filesystem sees it.

Start

Start a sequence in the file already loaded.

Fields

sequence: String

Which sequence to run.

Run

Load a sequence file and start one of its sequences in one step.

Fields

sequence_file: String

Path to the sequence file, as the host’s filesystem sees it.

sequence: String

Which sequence to run. MainSequence unless the file says otherwise.

Terminate

Ask a running execution to stop.

Termination, not abort: cleanup still runs, so hardware is left safe.

Fields

execution_id: i32

Which execution, as reported by MessageEvent::execution_id.

Control

Change what a running execution is doing.

One command carrying a verb rather than six commands, so the wire shape stays stable as more controls land, and so a panel acting on whatever is running can leave execution_id out instead of tracking it.

The engine binding has had these members for a while. Without this variant none were reachable from a client, which left a panel able to start a run and stop it and do nothing in between.

Fields

execution_id: Option<i32>

Which execution. Absent means whatever the host has running.

control: ExecutionControl

What to do to it.

ReadValue

Read a value out of a running execution’s context.

lookup is an ordinary property path, Locals.Result or FileGlobals.SerialNumber. This is how a panel gets data it was not pushed: the host resolves the path and answers with the subtree as data, because the reference itself could never leave the process.

Fields

execution_id: i32

Which execution to read from.

lookup: String

The property path to resolve.

Shutdown

Stop the host after the current run finishes.

Implementations

impl Command

pub const fn name(&self) -> &'static str

A short name for logging, without rendering the whole command.

pub const fn is_control(&self) -> bool

Whether this command changes what the station is doing.

A host that serves more than one panel wants to treat these differently from reads: two observers are fine, two controllers are a decision somebody has to make.

Trait Implementations

impl Clone for Command

fn clone(&self) -> Command

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Command

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Command

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Command

fn eq(&self, other: &Command) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Command

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Command