Oneshot Uniffi

https://docs.rs/oneshot_uniffi
Admin
Oneshot Uniffi is a single producer, single consumer (SPSC) channel designed for highly efficient,...
Tokens:835
Snippets:9
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Asynchronous Oneshot Channel Receive

Source: https://docs.rs/oneshot_uniffi

Shows how to asynchronously await a response from a background thread on a oneshot channel. Requires the 'async' feature and an async runtime.

```rust
#[cfg(feature = "async")] {
    tokio::runtime::Runtime::new()
        .unwrap()
        .block_on(async move {
            let (response_sender, response_receiver) = oneshot::channel();
            let request = Request::from("data from sync thread");

            processor.send((request, response_sender)).expect("Processor down");
            match response_receiver.await { // <- Receive on the oneshot channel asynchronously
                Ok(result) => println!("Processor returned {}", result),
                Err(_e) => panic!("Processor exited"),
            }
        });
}
```

--------------------------------

### Spawn Processing Thread with Oneshot Channel

Source: https://docs.rs/oneshot_uniffi

Sets up a background thread to process requests and send responses back via a oneshot channel. The sender is consumed upon sending.

```rust
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

type Request = String;

// Starts a background thread performing some computation on requests sent to it.
// Delivers the response back over a oneshot channel.
fn spawn_processing_thread() -> mpsc::Sender<(Request, oneshot::Sender<usize>)> {
    let (request_sender, request_receiver) = mpsc::channel::<(Request, oneshot::Sender<usize>)>();
    thread::spawn(move || {
        for (request_data, response_sender) in request_receiver.iter() {
            let compute_operation = || request_data.len();
            let _ = response_sender.send(compute_operation()); // <- Send on the oneshot channel
        }
    });
    request_sender
}
```

--------------------------------

### Synchronous Oneshot Channel Receive with Timeout

Source: https://docs.rs/oneshot_uniffi

Demonstrates receiving a response from a background thread on a oneshot channel with a specified timeout. Requires the 'std' feature.

```rust
#[cfg(feature = "std")] {
    let (response_sender, response_receiver) = oneshot::channel();
    let request = Request::from("data from sync thread");

    processor.send((request, response_sender)).expect("Processor down");
    match response_receiver.recv_timeout(Duration::from_secs(1)) { // <- Receive on the oneshot channel
        Ok(result) => println!("Processor returned {}", result),
        Err(oneshot::RecvTimeoutError::Timeout) => eprintln!("Processor was too slow"),
        Err(oneshot::RecvTimeoutError::Disconnected) => panic!("Processor exited"),
    }
}
```
Tokens:
Raw