photonic 0.1.1

Dynamic light controller and animator
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
136
137
138

use std::pin::pin;
use std::task::Context;

use anyhow::Result;
use futures::Future;
use tokio::sync::{broadcast, mpsc, oneshot};

pub use self::sink::{AnyInputValue, InputSink, Sink};
pub use self::trigger::Trigger;
pub use self::values::Coerced;

mod attr;
mod sink;
mod trigger;
mod values;

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
pub enum InputValueType {
    Trigger,
    Boolean,
    Integer,
    Decimal,
    Color,
    IntegerRange,
    DecimalRange,
    ColorRange,
}

impl std::fmt::Display for InputValueType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        return match self {
            Self::Trigger => f.write_str("trigger"),
            Self::Boolean => f.write_str("boolean"),
            Self::Integer => f.write_str("integer"),
            Self::Decimal => f.write_str("decimal"),
            Self::Color => f.write_str("color"),
            Self::IntegerRange => f.write_str("range<integer>"),
            Self::DecimalRange => f.write_str("range<decimal>"),
            Self::ColorRange => f.write_str("range<color>"),
        };
    }
}

mod private {
    pub trait Sealed {}
}

pub trait InputValue: private::Sealed + Send + Copy + 'static {
    const TYPE: InputValueType;
    fn sink(sink: Sink<Self>) -> InputSink;
}

#[derive(Debug)]
pub enum Poll<T> {
    /// Represents that a value is immediately available.
    Update(T),

    /// Represents that a value has not changed.
    Pending,
}

struct UpdateRequest<V>
where V: InputValue
{
    value: V,
    responder: oneshot::Sender<Result<()>>,
}

#[derive(Debug)]
pub struct Input<V>
where V: InputValue
{
    update_tx: mpsc::Sender<UpdateRequest<V>>,
    update_rx: mpsc::Receiver<UpdateRequest<V>>,

    value_tx: broadcast::Sender<V>,
    value_rx: broadcast::Receiver<V>,
}

impl<V> Default for Input<V>
where V: InputValue
{
    fn default() -> Self {
        Self::new()
    }
}

impl<V> Input<V>
where V: InputValue
{
    pub fn new() -> Self {
        let (update_tx, update_rx) = mpsc::channel(1);

        let (value_tx, value_rx) = broadcast::channel(1);

        return Self {
            update_tx,
            update_rx,
            value_tx,
            value_rx,
        };
    }

    pub fn poll<F, R, E>(&mut self, validate: F) -> Poll<R>
    where
        F: Fn(V) -> Result<R, E>,
        E: Into<anyhow::Error>,
    {
        let ctx = &mut Context::from_waker(futures::task::noop_waker_ref());

        let std::task::Poll::Ready(Some(UpdateRequest {
            responder,
            value,
        })) = pin!(self.update_rx.recv()).as_mut().poll(ctx)
        else {
            return Poll::Pending;
        };

        match validate(value) {
            Ok(update) => {
                let _ = responder.send(Ok(()));
                let _ = self.value_tx.send(value);
                return Poll::Update(update);
            }
            Err(err) => {
                let _ = responder.send(Err(err.into()));
                return Poll::Pending;
            }
        }
    }

    pub fn sink(&self) -> Sink<V> {
        return Sink {
            update_tx: self.update_tx.clone(),
            value_rx: self.value_rx.resubscribe(),
        };
    }
}