radiate-engines 1.3.1

Engines for the Radiate genetic algorithm library.
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

use crate::events::{EventStream, Subscription, SubscriptionId};
use radiate_core::{Executor, error::RadiateResult};
use std::sync::{Arc, Mutex};

pub trait Event: Send + Sync + 'static {}
impl<T: Send + Sync + 'static> Event for T {}

pub trait Handler<E: Event>: Send + 'static {
    fn handle(&mut self, event: &E, ctx: &EventContext<'_, Self>)
    where
        Self: Sized;
}

pub trait EventHandler: Send + 'static {
    fn start(&mut self, _ctx: &EventContext<'_, Self>) -> RadiateResult<()>
    where
        Self: Sized,
    {
        Ok(())
    }
}

impl<E, F> Handler<E> for F
where
    E: Event,
    F: FnMut(&E) + Send + 'static,
{
    fn handle(&mut self, event: &E, _ctx: &EventContext<'_, Self>) {
        self(event)
    }
}

pub struct EventContext<'a, H>(&'a Subscriber<H>);

impl<H> EventContext<'_, H> {
    pub fn publish<E: Event>(&self, event: E) {
        self.0.stream.publish(event);
    }

    pub fn subscribe<E>(&self) -> Subscription
    where
        E: Event,
        H: Handler<E>,
    {
        self.0.subscribe::<E>()
    }
}

pub struct Subscriber<H> {
    handler: Arc<Mutex<H>>,
    executor: Arc<Executor>,
    stream: EventStream,
}

impl<H: Send + 'static> Subscriber<H> {
    pub(super) fn new(handler: H, executor: Arc<Executor>, stream: EventStream) -> Self {
        Subscriber {
            handler: Arc::new(Mutex::new(handler)),
            executor,
            stream,
        }
    }

    pub fn subscribe<E>(&self) -> Subscription
    where
        E: Event,
        H: Handler<E>,
    {
        self.stream.subscribe_existing::<E, H>(self)
    }

    pub fn unsubscribe(&self, id: SubscriptionId) {
        self.stream.unsubscribe(id);
    }

    pub(super) fn start(&self) -> RadiateResult<()>
    where
        H: EventHandler,
    {
        let ctx = EventContext(self);
        self.handler.lock().unwrap().start(&ctx)
    }

    pub(super) fn send_shared<E>(&self, event: Arc<E>)
    where
        E: Event,
        H: Handler<E>,
    {
        match self.executor.as_ref() {
            Executor::Serial => {
                let ctx = EventContext(self);
                self.handler.lock().unwrap().handle(event.as_ref(), &ctx);
            }
            _ => {
                let owned = self.clone();
                self.executor.submit(move || {
                    let ctx = EventContext(&owned);
                    owned.handler.lock().unwrap().handle(event.as_ref(), &ctx);
                });
            }
        }
    }
}

impl<H> Clone for Subscriber<H> {
    fn clone(&self) -> Self {
        Subscriber {
            handler: Arc::clone(&self.handler),
            executor: Arc::clone(&self.executor),
            stream: self.stream.clone(),
        }
    }
}