Trait MaybeFuture 

pub trait MaybeFuture: IntoFuture + Sized {
    // Provided method
    fn wait(self) -> Self::Output { ... }
}

Extension trait adding a blocking .wait() to every action.

Blanket-implemented for everything awaitable, so any Hidra / HidDevice method can be driven with .wait() on native targets. Not available on wasm32, where blocking the (single) thread is impossible; use .await instead.

Provided Methods

fn wait(self) -> Self::Output

Run the action to completion, blocking the current thread.

Examples found in repository

examples/backends.rs (line 39)

    fn product_string_of(&self, vid: u16, pid: u16) -> HidResult<Option<String>> {
        match self {
            Api::Native(api) => api.open(vid, pid).wait()?.get_product_string().wait(),
            Api::Nusb(api) => api.open(vid, pid).wait()?.get_product_string().wait(),
        }
    }

examples/read_input.rs (line 20)

fn main() -> hidra::HidResult<()> {
    let mut args = env::args().skip(1);
    let vid = u16::from_str_radix(&args.next().expect("usage: read_input <vid> <pid>"), 16)
        .expect("vid must be hex");
    let pid = u16::from_str_radix(&args.next().expect("usage: read_input <vid> <pid>"), 16)
        .expect("pid must be hex");

    let api = hidra::Hidra::new()?;
    let device = api.open(vid, pid).wait()?;

    println!("product: {:?}", device.get_product_string().wait()?);
    let descriptor = device.parsed_report_descriptor().wait()?;
    println!(
        "report descriptor: {} top-level collection(s), max input report {} bytes, numbered ids: {}",
        descriptor.collections.len(),
        descriptor.max_report_size(hidra::descriptor::ReportKind::Input),
        descriptor.uses_report_ids(),
    );

    println!("reading input reports (ctrl-c to quit)...");
    let mut buf = [0u8; 256];
    loop {
        // Blocks until a report arrives; never returns 0.
        let len = device.read(&mut buf).wait()?;
        println!("{:02x?}", &buf[..len]);
    }
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T: IntoFuture> MaybeFuture for T

Available on non-WebAssembly only.