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

//! # Transport
//!
//! `transport` is the module providing the trait implemented by network transports.

use base::Result;
use base::VariableSize;
use base::Checkable;
use base::Datable;
use base::{Eval, EvalMut};

/// Trait implemented by transports used by network clients.
pub trait ClientTransport<A>
    where   A: Datable + VariableSize,
            Self: 'static + Sized + Send + Sync + Clone + Checkable
{
    /// Opens a connection to a network addresses.
    fn connect(address: &A) -> Result<Self>;

    /// Closes the connection.
    fn disconnect(&mut self) -> Result<()>;

    /// Sends data through the network connection.
    fn send(&mut self, data: &[u8]) -> Result<()>;

    /// Receives data from the network connection, returning an handle to
    /// the transport that can be used to reply to the caller.
    fn recv(&mut self) -> Result<Vec<u8>>;

    /// Eval operation in the client transport.
    fn eval<Ev: Eval<Self, P, R>, P: Datable, R: Datable>(&self, params: &P, evaluator: &Ev) -> Result<R> {
        self.check()?;

        params.check()?;

        evaluator.eval(self, params)
    }

    /// Mutable eval operation in the client transport.
    fn eval_mut<EvM: EvalMut<Self, P, R>, P: Datable, R: Datable>(&mut self, params: &P, evaluator: &mut EvM) -> Result<R> {
        self.check()?;

        params.check()?;

        let result = evaluator.eval_mut(self, params)?;
        self.check()?;

        Ok(result)
    }
}

/// Trait implemented by transports for network servers.
pub trait ServerTransport<A, CT>
    where   A: Datable + VariableSize,
            CT: ClientTransport<A>,
            Self: 'static + Sized + Send + Sync + Checkable
{
    /// Listens to a connection incoming from a network addresses.
    fn listen(address: &A) -> Result<Self>;

    /// Accepts a connection incoming from a network addresses.
    fn accept(&mut self) -> Result<(CT, A)>;

    /// Closes the connections.
    fn close(&mut self) -> Result<()>;

    /// Eval operation in the server transport.
    fn eval<Ev: Eval<Self, P, R>, P: Datable, R: Datable>(&self, params: &P, evaluator: &Ev) -> Result<R> {
        self.check()?;

        params.check()?;

        evaluator.eval(self, params)
    }

    /// Mutable eval operation in the server transport.
    fn eval_mut<EvM: EvalMut<Self, P, R>, P: Datable, R: Datable>(&mut self, params: &P, evaluator: &mut EvM) -> Result<R> {
        self.check()?;

        params.check()?;

        let result = evaluator.eval_mut(self, params)?;
        self.check()?;

        Ok(result)
    }
}