some_executor 0.6.3

A trait for libraries that abstract over any executor
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
130
131
132
133
134
135

// SPDX-License-Identifier: MIT OR Apache-2.0

use crate::observer::{FinishedObservation, Observation, Observer};
use crate::task::TaskID;
use std::any::Any;
use std::future::Future;
use std::marker::PhantomData;
use std::pin::Pin;
use std::task::{Context, Poll};

/**
This takes another observer of type `Observer<Value = Box<(dyn Any + Send + 'static)>>`
and downcasts the value to `Value` before calling the inner observer.
*/
pub struct DowncastObserver<O, V>(O, PhantomData<V>);

impl<O, V> Observer for DowncastObserver<O, V>
where
    O: Observer<Value = Box<dyn Any + Send + 'static>> + 'static + Send,
    V: 'static,
{
    type Value = V;

    fn observe(&self) -> Observation<Self::Value> {
        let inner = self.0.observe();
        match inner {
            Observation::Pending => Observation::Pending,

            Observation::Ready(e) => {
                let downcasted = e.downcast::<V>().expect("Downcast failed");
                Observation::Ready(*downcasted)
            }
            Observation::Done => Observation::Done,
            Observation::Cancelled => Observation::Cancelled,
        }
    }

    fn task_id(&self) -> &TaskID {
        self.0.task_id()
    }
}

impl<O, V> DowncastObserver<O, V> {
    pub fn new(observer: O) -> Self {
        Self(observer, PhantomData)
    }
}

impl<O, V> Future for DowncastObserver<O, V>
where
    O: Future<Output = FinishedObservation<Box<dyn Any + Send + 'static>>> + 'static,
    V: 'static,
{
    type Output = FinishedObservation<V>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let f = unsafe { self.map_unchecked_mut(|s| &mut s.0) }.poll(cx);
        match f {
            Poll::Pending => Poll::Pending,
            Poll::Ready(e) => match e {
                FinishedObservation::Cancelled => Poll::Ready(FinishedObservation::Cancelled),
                FinishedObservation::Ready(e) => {
                    let downcasted = e.downcast::<V>().expect("Downcast failed");
                    Poll::Ready(FinishedObservation::Ready(*downcasted))
                }
            },
        }
    }
}

/**
This implements Observer for `Box<dyn type>`

todo: could probably be made more generic
*/
impl<V> Observer for Box<dyn Observer<Value = V, Output = FinishedObservation<V>>>
where
    V: 'static,
{
    type Value = V;

    fn observe(&self) -> Observation<Self::Value> {
        self.as_ref().observe()
    }

    fn task_id(&self) -> &TaskID {
        self.as_ref().task_id()
    }
}

impl<V> Future for Box<dyn Observer<Value = V, Output = FinishedObservation<V>>>
where
    V: 'static,
{
    type Output = FinishedObservation<V>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        //Box guarantees the inner value is pinned as long as the Box itself is pinned,
        let map = unsafe { self.as_mut().map_unchecked_mut(|s| &mut **s) };
        map.poll(cx)
    }
}

/**
This implements Observer for `Box<dyn type>` + Send

todo: could probably be made more generic
*/
impl<V> Observer for Box<dyn Observer<Value = V, Output = FinishedObservation<V>> + Send>
where
    V: 'static,
{
    type Value = V;

    fn observe(&self) -> Observation<Self::Value> {
        self.as_ref().observe()
    }

    fn task_id(&self) -> &TaskID {
        self.as_ref().task_id()
    }
}

impl<V> Future for Box<dyn Observer<Value = V, Output = FinishedObservation<V>> + Send>
where
    V: 'static,
{
    type Output = FinishedObservation<V>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        //Box guarantees the inner value is pinned as long as the Box itself is pinned,
        let map = unsafe { self.as_mut().map_unchecked_mut(|s| &mut **s) };
        map.poll(cx)
    }
}