Struct selectme::StaticSelect

pub struct StaticSelect<Bits, S, B, O> { /* private fields */ }

The implementation used by the select! macro internally and returned by the inline! macro when the static; option is enabled.

See the select! and inline! macros for documentation on syntax and use.

Examples

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;

use pin_project::pin_project;
use selectme::{Random, StaticSelect};
use tokio::time::{self, Sleep};

#[pin_project]
struct MyFuture {
    #[pin]
    select: StaticSelect<u8, (Sleep, Sleep), Random, Option<u32>>,
}

impl Future for MyFuture {
    type Output = Option<u32>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let this = self.project();
        this.select.poll_next(cx)
    }
}

let s1 = time::sleep(Duration::from_millis(100));
let s2 = time::sleep(Duration::from_millis(200));

let my_future = MyFuture {
    select: selectme::inline! {
        static;

        () = s1 => Some(1),
        _ = s2 => Some(2),
        else => None,
    }
};

assert_eq!(my_future.await, Some(1));

Implementations

impl<Bits, S, B, O> StaticSelect<Bits, S, B, O>where Bits: Number, B: Bias<Bits>,

pub async fn next(self: Pin<&mut Self>) -> O

Get the next element from this select when pinned.

Examples

use std::time::Duration;

use tokio::time;

#[selectme::main]
pub(crate) async fn main() {
    let s1 = time::sleep(Duration::from_millis(100));
    let s2 = time::sleep(Duration::from_millis(200));

    let output = selectme::inline! {
        static;

        () = s1 => Some(1),
        _ = s2 => Some(2),
        else => None,
    };

    tokio::pin!(output);

    let mut values = Vec::new();

    while let Some(output) = output.as_mut().next().await {
        values.push(output);
    }

    assert_eq!(values, &[1, 2]);
}

pub fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<O>

Poll for the next branch to resolve in this StaticSelect.

Trait Implementations

impl<Bits, S, B, O> Debug for StaticSelect<Bits, S, B, O>where Bits: Number, B: Debug, S: Debug,

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

Formats the value using the given formatter.

impl<Bits, S, B, O> Future for StaticSelect<Bits, S, B, O>where Bits: Number, B: Bias<Bits>,

type Output = O

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.