mitrid_core 0.9.4

Core library of the Mitrid framework
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

//! # App
//!
//! `app` is the module providing the trait implemented by Mitrid applications.

use base::Result;
use base::data::Datable;
use app::{Request, Response};
use app::{RequestChannel, ResponseSender};
use app::Logger;

/// Trait implemented by Mitrid application types.
pub trait App<A, P, R>
    where   A: Ord + Datable,
            P: Datable,
            R: Datable,
            Self: 'static + Sized + Send + Sync + Logger
{
    /// Returns the `App` address.
    fn address(&self) -> A;

    /// Returns the `App` `RequestChannel`.
    fn request_channel(&self) -> RequestChannel<A, P>;

    /// Returns the `App` `ResponseSender`.
    fn response_sender(&self) -> ResponseSender<A, R>;

    /// Executes a command in the `App`.
    fn exec(&mut self, req: &Request<A, P>)
        -> Result<Response<A, R>>;

    /// Logs a result.
    fn log_result<T: Sized>(&self, res: &Result<T>);

    /// Runs the `App`.
    fn run(&mut self) {
        let sender = self.response_sender();

        loop {
            for req in self.request_channel().receiver {

                let res = self.exec(&req)
                            .or_else(|e| {
                                let err = Err(format!("{:?}", e));
                                self.log_result(&err);
                                err
                            })
                            .and_then(|res| {
                                sender
                                    .send(res)
                                    .map_err(|e| format!("{:?}", e))
                            });

                self.log_result(&res);
                res.unwrap();
            }
        }   
    }
}