Struct Request 

pub struct Request { /* private fields */ }

Blocking analogue of core::Request. Every method mirrors the async one without the .await. The hidden current-thread runtime runs the await internally.

Request is !Sync because the Runtime it owns is; clone one via new per thread that needs independent blocking access, or use the async API if you need Sync.

Implementations

impl Request

pub fn new() -> Result<Self>

Create a new handle. Spawns the async driver thread and allocates a single-threaded tokio runtime to drive its futures to completion.

pub fn connect_to(url: &str, opts: ConnectionOptions) -> Result<Self>

Construct + connect in one call.

use motorcortex_rust::{ConnectionOptions, blocking::Request};
let opts = ConnectionOptions::new("mcx.cert.crt".into(), 1000, 1000);
let req = Request::connect_to("wss://127.0.0.1:5568", opts)?;
req.request_parameter_tree()?;
let v: f64 = req.get_parameter("root/Control/dummyDouble")?;
println!("{v}");

Examples found in repository

examples/blocking_request.rs (line 27)

fn main() -> Result<()> {
    let mut args = env::args().skip(1);
    let url = args.next().unwrap_or_else(|| "wss://127.0.0.1:5568:5567".into());
    let cert = args.next().unwrap_or_else(|| "tests/mcx.cert.crt".into());
    let user = args.next().unwrap_or_else(|| "root".into());
    let pass = args.next().unwrap_or_default();
    let path = args
        .next()
        .unwrap_or_else(|| "root/Control/dummyDouble".into());

    let (req_url, _sub_url) = parse_url(&url)?;
    let opts = ConnectionOptions::new(cert, 5_000, 5_000);
    let req = Request::connect_to(&req_url, opts)?;
    req.login(&user, &pass)?;
    req.request_parameter_tree()?;

    let value: f64 = req.get_parameter(&path)?;
    println!("{path} = {value}");

    req.disconnect()?;
    Ok(())
}

pub fn connect(&self, url: &str, opts: ConnectionOptions) -> Result<()>

pub fn disconnect(&self) -> Result<()>

Examples found in repository

examples/blocking_request.rs (line 34)

fn main() -> Result<()> {
    let mut args = env::args().skip(1);
    let url = args.next().unwrap_or_else(|| "wss://127.0.0.1:5568:5567".into());
    let cert = args.next().unwrap_or_else(|| "tests/mcx.cert.crt".into());
    let user = args.next().unwrap_or_else(|| "root".into());
    let pass = args.next().unwrap_or_default();
    let path = args
        .next()
        .unwrap_or_else(|| "root/Control/dummyDouble".into());

    let (req_url, _sub_url) = parse_url(&url)?;
    let opts = ConnectionOptions::new(cert, 5_000, 5_000);
    let req = Request::connect_to(&req_url, opts)?;
    req.login(&user, &pass)?;
    req.request_parameter_tree()?;

    let value: f64 = req.get_parameter(&path)?;
    println!("{path} = {value}");

    req.disconnect()?;
    Ok(())
}

pub fn login(&self, user: &str, pass: &str) -> Result<StatusCode>

Examples found in repository

examples/blocking_request.rs (line 28)

fn main() -> Result<()> {
    let mut args = env::args().skip(1);
    let url = args.next().unwrap_or_else(|| "wss://127.0.0.1:5568:5567".into());
    let cert = args.next().unwrap_or_else(|| "tests/mcx.cert.crt".into());
    let user = args.next().unwrap_or_else(|| "root".into());
    let pass = args.next().unwrap_or_default();
    let path = args
        .next()
        .unwrap_or_else(|| "root/Control/dummyDouble".into());

    let (req_url, _sub_url) = parse_url(&url)?;
    let opts = ConnectionOptions::new(cert, 5_000, 5_000);
    let req = Request::connect_to(&req_url, opts)?;
    req.login(&user, &pass)?;
    req.request_parameter_tree()?;

    let value: f64 = req.get_parameter(&path)?;
    println!("{path} = {value}");

    req.disconnect()?;
    Ok(())
}

pub fn logout(&self) -> Result<StatusCode>

pub fn request_parameter_tree(&self) -> Result<StatusCode>

Examples found in repository

examples/blocking_request.rs (line 29)

fn main() -> Result<()> {
    let mut args = env::args().skip(1);
    let url = args.next().unwrap_or_else(|| "wss://127.0.0.1:5568:5567".into());
    let cert = args.next().unwrap_or_else(|| "tests/mcx.cert.crt".into());
    let user = args.next().unwrap_or_else(|| "root".into());
    let pass = args.next().unwrap_or_default();
    let path = args
        .next()
        .unwrap_or_else(|| "root/Control/dummyDouble".into());

    let (req_url, _sub_url) = parse_url(&url)?;
    let opts = ConnectionOptions::new(cert, 5_000, 5_000);
    let req = Request::connect_to(&req_url, opts)?;
    req.login(&user, &pass)?;
    req.request_parameter_tree()?;

    let value: f64 = req.get_parameter(&path)?;
    println!("{path} = {value}");

    req.disconnect()?;
    Ok(())
}

pub fn get_parameter_tree_hash(&self) -> Result<u32>

pub fn get_parameter<V>(&self, path: &str) -> Result<V>

where V: GetParameterValue + Default,

Examples found in repository

examples/blocking_request.rs (line 31)

fn main() -> Result<()> {
    let mut args = env::args().skip(1);
    let url = args.next().unwrap_or_else(|| "wss://127.0.0.1:5568:5567".into());
    let cert = args.next().unwrap_or_else(|| "tests/mcx.cert.crt".into());
    let user = args.next().unwrap_or_else(|| "root".into());
    let pass = args.next().unwrap_or_default();
    let path = args
        .next()
        .unwrap_or_else(|| "root/Control/dummyDouble".into());

    let (req_url, _sub_url) = parse_url(&url)?;
    let opts = ConnectionOptions::new(cert, 5_000, 5_000);
    let req = Request::connect_to(&req_url, opts)?;
    req.login(&user, &pass)?;
    req.request_parameter_tree()?;

    let value: f64 = req.get_parameter(&path)?;
    println!("{path} = {value}");

    req.disconnect()?;
    Ok(())
}

pub fn set_parameter<V>(&self, path: &str, value: V) -> Result<StatusCode>

where V: SetParameterValue,

pub fn get_parameters<T>(&self, paths: &[&str]) -> Result<T>

where T: GetParameterTuple,

pub fn set_parameters<T>(&self, paths: &[&str], values: T) -> Result<StatusCode>

where T: SetParameterTuple,

pub fn create_group<I>( &self, paths: I, alias: &str, fdiv: u32, ) -> Result<GroupStatusMsg>

where I: Parameters,

pub fn remove_group(&self, alias: &str) -> Result<StatusCode>

pub fn parameter_tree(&self) -> Arc<RwLock<ParameterTree>>

Shared parameter-tree cache. Populated by request_parameter_tree.

pub fn as_async(&self) -> &Request

Access the inner async handle — useful when one part of your program is blocking and another is async.