dot15d4 0.1.2

IEEE 802.15.4 implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use core::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};

use super::Either;

/// Combine 2 futures and return if both are ready.
pub fn join<F1: Future, F2: Future>(
    f1: F1,
    f2: F2,
) -> impl Future<Output = (F1::Output, F2::Output)> {
    JoinFuture {
        f1: Either::First(f1),
        f2: Either::First(f2),
    }
}

pub struct JoinFuture<F1: Future, F2: Future> {
    f1: Either<F1, Option<F1::Output>>,
    f2: Either<F2, Option<F2::Output>>,
}

impl<F1, F2> Future for JoinFuture<F1, F2>
where
    F1: Future,
    F2: Future,
{
    type Output = (F1::Output, F2::Output);

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        // Safety: self is not used after this point, so it is not moved
        let this = unsafe { self.get_unchecked_mut() };

        // Make progress if the task is not yet finished
        // Safety: this is pinned, so f1 will not be moved either
        if let Some(res) = unsafe { poll_future(&mut this.f1, cx) } {
            this.f1 = Either::Second(Some(res));
        }
        if let Some(res) = unsafe { poll_future(&mut this.f2, cx) } {
            this.f2 = Either::Second(Some(res));
        }

        match (&mut this.f1, &mut this.f2) {
            (Either::Second(f1 @ Some(_)), Either::Second(f2 @ Some(_))) => {
                Poll::Ready((f1.take().unwrap(), f2.take().unwrap()))
            }
            _ => Poll::Pending,
        }
    }
}

/// # Safety
/// The future behind the f may not be moved while this function is being
/// executed
unsafe fn poll_future<F: Future>(
    f: &mut Either<F, Option<F::Output>>,
    cx: &mut Context,
) -> Option<F::Output> {
    match f {
        Either::First(f) => match Pin::new_unchecked(f).poll(cx) {
            Poll::Ready(res) => Some(res),
            Poll::Pending => None,
        },
        Either::Second(_res) => None,
    }
}

#[cfg(test)]
mod tests {
    use core::future::poll_fn;
    use core::task::Poll;

    use pollster::FutureExt as _;

    use super::join;

    #[test]
    pub fn test_select_immediate_ready_first() {
        async {
            let f1 = poll_fn(|_| Poll::Ready(1));
            let f2 = poll_fn(|_| Poll::Ready(2));

            assert_eq!(join(f1, f2).await, (1, 2));
        }
        .block_on();
    }

    #[test]
    pub fn test_select_wait_until_one_finished() {
        async {
            let mut counter = 10;
            let f1 = poll_fn(move |cx| {
                if counter == 0 {
                    Poll::Ready(())
                } else {
                    counter -= 1;
                    cx.waker().wake_by_ref();
                    Poll::Pending
                }
            });
            let f2 = poll_fn(|_| Poll::Ready(()));

            assert_eq!(join(f1, f2).await, ((), ()));
        }
        .block_on();
    }

    #[test]
    pub fn test_select_wait_until_second_finished() {
        async {
            let mut counter = 10;
            let f1 = poll_fn(|_| Poll::Ready(()));
            let f2 = poll_fn(move |cx| {
                if counter == 0 {
                    Poll::Ready(())
                } else {
                    counter -= 1;
                    cx.waker().wake_by_ref();
                    Poll::Pending
                }
            });

            assert_eq!(join(f1, f2).await, ((), ()));
        }
        .block_on();
    }
}