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
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

//! # Channel
//!
//! `channel` is the module providing the types used to communicate with applications.

use std::sync::mpsc::{Sender, Receiver, channel};

use base::Datable;
use app::Request;
use app::Response;

pub type RequestSender<A, P> = Sender<Request<A, P>>;
pub type RequestReceiver<A, P> = Receiver<Request<A, P>>;

/// Type used to represent an application `Request` channels.
#[derive(Debug)]
pub struct RequestChannel<A, P>
    where   A: Ord + Datable,
            P: Datable,
{
    /// Request channel sender.
    pub sender: RequestSender<A, P>,
    /// Request channel receiver.
    pub receiver: RequestReceiver<A, P>,
}

impl<A, P> RequestChannel<A, P>
    where   A: Ord + Datable,
            P: Datable,
{
    /// Creates a new `RequestChannel`.
    pub fn new() -> Self {
        let (sender, receiver) = channel();

        RequestChannel {
            sender: sender,
            receiver: receiver,
        }
    }
}

pub type ResponseSender<A, R> = Sender<Response<A, R>>;
pub type ResponseReceiver<A, R> = Receiver<Response<A, R>>;

/// Type used to represent an application `Response` channel.
#[derive(Debug)]
pub struct ResponseChannel<A, R>
    where   A: Ord + Datable,
            R: Datable,
{
    /// Response channel sender.
    pub sender: ResponseSender<A, R>,
    /// Response channel receiver.
    pub receiver: ResponseReceiver<A, R>,
}

impl<A, R> ResponseChannel<A, R>
    where   A: Ord + Datable,
            R: Datable,
{
    /// Creates a new `ResponseChannel`.
    pub fn new() -> Self {
        let (sender, receiver) = channel();

        ResponseChannel {
            sender: sender,
            receiver: receiver,
        }
    }
}

/// Type used to represent an application `Request` and `Response` channels.
#[derive(Debug)]
pub struct Channels<A, P, R>
    where   A: Ord + Datable,
            P: Datable,
            R: Datable,
{
    /// Request channel.
    pub request: RequestChannel<A, P>,
    /// Response channel.
    pub response: ResponseChannel<A, R>,
}

impl<A, P, R> Channels<A, P, R>
    where   A: Ord + Datable,
            P: Datable,
            R: Datable,
{
    /// Creates a new `Channels`.
    pub fn new() -> Self {
        let request_channel = RequestChannel::new();
        let response_channel = ResponseChannel::new();

        Channels {
            request: request_channel,
            response: response_channel,
        }
    }
}