rustdt-json_rpc 0.3.0

A JSON-RPC library for Rust
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

// Copyright 2016 Bruno Medeiros
//
// Licensed under the Apache License, Version 2.0 
// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>. 
// This file may not be copied, modified, or distributed
// except according to those terms.

use util::core::*;

use std::collections::HashMap;

use super::ResponseCompletable;
use super::RequestHandler;
use super::serde;

use method_types::*;
use jsonrpc_common::*;
use jsonrpc_request::*;


/* -----------------  MapRequestHandler  ----------------- */

pub type RpcMethodHandler = Fn(RequestParams, ResponseCompletable);

pub struct MapRequestHandler {
    pub method_handlers : HashMap<String, Box<RpcMethodHandler>>,
}

impl MapRequestHandler {
    
    pub fn new() -> MapRequestHandler {
         MapRequestHandler { method_handlers : HashMap::new() }
    }
    
    pub fn add_notification<
        PARAMS : serde::Deserialize + 'static,
    >(
        &mut self,
        method_name: &'static str, 
        method_fn: Box<Fn(PARAMS)>
    ) {
        let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
            completable.sync_handle_notification(params, &*method_fn);
        });
        self.add_rpc_handler(method_name, req_handler);
    }
    
    pub fn add_request<
        PARAMS : serde::Deserialize + 'static, 
        RET : serde::Serialize + 'static, 
        RET_ERROR : serde::Serialize + 'static
    >(
        &mut self,
        method_name: &'static str, 
        method_fn: Box<Fn(PARAMS) -> MethodResult<RET, RET_ERROR>>
    ) {
        let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
            completable.sync_handle_request(params, &*method_fn);
        });
        self.add_rpc_handler(method_name, req_handler);
    }
    
    pub fn add_rpc_handler(
        &mut self,
        method_name: &'static str,
        method_handler: Box<RpcMethodHandler>
    ) {
        self.method_handlers.insert(method_name.to_string(), method_handler);
    }
    
    fn do_invoke_method(
        &mut self, 
        method_name: &str, 
        completable: ResponseCompletable,
        request_params: RequestParams,
    ) {
        if let Some(method_fn) = self.method_handlers.get(method_name) 
        {
            let method_fn : &Box<RpcMethodHandler> = method_fn;
            method_fn(request_params, completable);
        } else {
            completable.complete_with_error(error_JSON_RPC_MethodNotFound());
        };
    }
    
}

impl RequestHandler for MapRequestHandler {
    
    fn handle_request(
        &mut self, request_method: &str, request_params: RequestParams, completable: ResponseCompletable
    ) {
        self.do_invoke_method(request_method, completable, request_params);
    }
    
}