async-selector 0.2.0

Fast and flexible asynchronous task selector
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

//! Wrapper types for [`Selector`] that allow for customizing polling behavior.

use std::{
    pin::Pin,
    sync::Arc,
    task::{Context, Poll},
};

use futures::Stream;

use crate::{
    pollable::{PollStrategy, PollWith},
    selector::{Id, Selector},
};

/// Borrowed [`Stream`] that will poll the inner [`Selector`]
/// and pass the extensions to the inner tasks.
///
/// Created with [`Selector::with_ext`].
///
/// **Important:** before polling the tasks with different extension types, see the wakeups [section](Selector#wakeups).
pub struct WithExt<'s, 'e, 'emut, S: PollStrategy, E: ?Sized, EMut: ?Sized> {
    pub(super) selector: &'s mut Selector<S>,
    pub(super) ext: &'e E,
    pub(super) ext_mut: &'emut mut EMut,
}

impl<'e, S, E, EMut> Stream for WithExt<'_, 'e, '_, S, E, EMut>
where
    S: PollStrategy,
    S: PollWith<'e, E, EMut>,
    E: ?Sized,
    EMut: ?Sized,
{
    type Item = S::Progress;

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let this = self.get_mut();
        this.selector
            .poll_next_inner(this.ext, this.ext_mut, |_| (), cx)
            .map(|opt| opt.map(|(result, ())| result))
    }
}

/// Borrowed [`Stream`] that will poll the inner [`Selector`] and attach the origin task [`Id`] to every item.
///
/// Created with [`Selector::with_id`].
pub struct WithId<'s, S: PollStrategy> {
    pub(super) selector: &'s mut Selector<S>,
}

impl<S> Stream for WithId<'_, S>
where
    S: PollStrategy,
    S: PollWith<'static, (), ()>,
{
    type Item = (S::Progress, Id<S::Pollable>);

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        self.get_mut()
            .selector
            .poll_next_inner(&(), &mut (), |task| Id(Arc::downgrade(task)), cx)
    }
}

/// Borrowed [`Stream`] that will poll the inner [`Selector`], pass the extensions the inner tasks,
/// and attach the origin task [`Id`] to every item.
///
/// Created with [`Selector::with_ext_and_id`].
///
/// **Important:** before polling the tasks with different extension types, see the wakeups [section](Selector#wakeups).
pub struct WithExtAndId<'s, 'e, 'emut, S: PollStrategy, E: ?Sized, EMut: ?Sized> {
    pub(super) selector: &'s mut Selector<S>,
    pub(super) ext: &'e E,
    pub(super) ext_mut: &'emut mut EMut,
}

impl<'e, S, E, EMut> Stream for WithExtAndId<'_, 'e, '_, S, E, EMut>
where
    S: PollStrategy,
    S: PollWith<'e, E, EMut>,
    E: ?Sized,
    EMut: ?Sized,
{
    type Item = (S::Progress, Id<S::Pollable>);

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let this = self.get_mut();
        this.selector
            .poll_next_inner(this.ext, this.ext_mut, |task| Id(Arc::downgrade(task)), cx)
    }
}