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

//! # Handler
//!
//! `handler` is the module providing the trait implemented by the server handler.

use base::Result;
use base::size::ConstantSize;
use base::Serializable;
use base::Checkable;
use base::Datable;
use base::{Eval, EvalMut};
use io::store::Store;
use io::network::message::Request;
use io::network::message::Response;

/// Trait implemented by the server handler.
pub trait Handler<St, StS, S, D, P>
    where   St: Store<StS>,
            StS: Datable + Serializable,
            S: Datable,
            D: Ord + Datable + ConstantSize,
            P: Datable,
            Self: 'static + Sized + Clone + Send + Sync,
{
    /// Returns the middleware callbacks applied sequentially by the router. Each callback takes as parameters
    /// the results of the preceding one.
    fn middlewares(&mut self, _store: &mut St)
        -> Result<Vec<Box<FnMut(&mut Self, &mut St, &Request<S, D, P>)
                        -> Result<(Request<S, D, P>)>>>> 
    {
            Ok(vec![])
    }

    /// Handles a ping `Request`.
    fn handle_ping(&mut self,
                   store: &mut St,
                   request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a session `Request`.
    fn handle_session(&mut self,
                      store: &mut St,
                      request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a count `Request`.
    fn handle_count(&mut self,
                    store: &mut St,
                    request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a list `Request`.
    fn handle_list(&mut self,
                   store: &mut St,
                   request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a lookup `Request`.
    fn handle_lookup(&mut self,
                     store: &mut St,
                     request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a get `Request`.
    fn handle_get(&mut self,
                  store: &mut St,
                  request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a create `Request`.
    fn handle_create(&mut self,
                     store: &mut St,
                     request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles an update `Request`.
    fn handle_update(&mut self,
                     store: &mut St,
                     request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles an upsert `Request`.
    fn handle_upsert(&mut self,
                     store: &mut St,
                     request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles a delete `Request`.
    fn handle_delete(&mut self,
                     store: &mut St,
                     request: &Request<S, D, P>)
        -> Result<Response<S, D, P>>;

    /// Handles an eval `Request`.
    fn handle_eval<Ev>(&mut self,
                       store: &mut St,
                       request: &Request<S, D, P>,
                       evaluator: &Ev)
        -> Result<Response<S, D, P>>
        where   Ev: Eval<St, Request<S, D, P>, Response<S, D, P>>
    {
        request.check()?;
        
        let response = evaluator.eval(store, request)?;
        response.check()?;

        Ok(response)
    }

    /// Handles an evalmut `Request`.
    fn handle_eval_mut<EvM>(&mut self,
                            store: &mut St,
                            request: &Request<S, D, P>,
                            evaluator: &mut EvM)
        -> Result<Response<S, D, P>>
        where   EvM: EvalMut<St, Request<S, D, P>, Response<S, D, P>>
    {
        request.check()?;
        
        let response = evaluator.eval_mut(store, request)?;
        response.check()?;

        Ok(response)
    }
}