Struct usi::UsiEngineHandler

pub struct UsiEngineHandler { /* fields omitted */ }

UsiEngineHandler provides a type-safe interface to the USI engine process.

Examples

use usi::{BestMoveParams, Error, EngineCommand, GuiCommand, UsiEngineHandler};

let mut handler = UsiEngineHandler::spawn("/path/to/usi_engine", "/path/to/working_dir").unwrap();

// Get the USI engine information.
let info = handler.prepare().unwrap();
assert_eq!("engine name", info.name());

// Set options.
handler.send_command(&GuiCommand::SetOption("USI_Ponder".to_string(), Some("true".to_string()))).unwrap();

// Start listening to the engine output.
// You can pass the closure which will be called
//   everytime new command is received from the engine.
handler.listen(move |output| -> Result<(), Error> {
    match output.response() {
        Some(EngineCommand::BestMove(BestMoveParams::MakeMove(
                     ref best_move_sfen,
                     ref ponder_move,
                ))) => {
                    assert_eq!("5g5f", best_move_sfen);
                }
        _ => {}
    }
    Ok(())
}).unwrap();
handler.send_command(&GuiCommand::Usi).unwrap();

Implementations

impl UsiEngineHandler

pub fn spawn<P: AsRef<OsStr>, Q: AsRef<Path>>(
    engine_path: P,
    working_dir: Q
) -> Result<UsiEngineHandler, Error>

Spanws a new process of the specific USI engine.

pub fn prepare(&mut self) -> Result<EngineInfo, Error>

Bootstrap the engine and returns a metadata such as an engine name and available options. Returns Error::IllegalOperation when called after listen method.

pub fn send_command(&mut self, command: &GuiCommand) -> Result<(), Error>

Sends a command to the engine.

pub fn kill(&mut self) -> Result<(), Error>

Terminates the engine.

pub fn listen<F, E>(&mut self, hook: F) -> Result<(), Error> where
    F: FnMut(&EngineOutput) -> Result<(), E> + Send + 'static,
    E: Error + Send + Sync + 'static, 

Spanws a new thread to monitor outputs from the engine. hook will be called for each USI command received. prepare method can only be called before listen method.

Trait Implementations

impl Debug for UsiEngineHandler

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

Formats the value using the given formatter.

impl Drop for UsiEngineHandler

fn drop(&mut self)

Executes the destructor for this type.