jsonrpc/
map_request_handler.rs

1// Copyright 2016 Bruno Medeiros
2//
3// Licensed under the Apache License, Version 2.0 
4// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>. 
5// This file may not be copied, modified, or distributed
6// except according to those terms.
7
8use util::core::*;
9
10use std::collections::HashMap;
11
12use super::ResponseCompletable;
13use super::RequestHandler;
14use super::serde;
15
16use method_types::*;
17use jsonrpc_common::*;
18use jsonrpc_request::*;
19
20
21/* -----------------  MapRequestHandler  ----------------- */
22
23pub type RpcMethodHandler = Fn(RequestParams, ResponseCompletable);
24
25pub struct MapRequestHandler {
26    pub method_handlers : HashMap<String, Box<RpcMethodHandler>>,
27}
28
29impl MapRequestHandler {
30    
31    pub fn new() -> MapRequestHandler {
32         MapRequestHandler { method_handlers : HashMap::new() }
33    }
34    
35    pub fn add_notification<
36        PARAMS : serde::Deserialize + 'static,
37    >(
38        &mut self,
39        method_name: &'static str, 
40        method_fn: Box<Fn(PARAMS)>
41    ) {
42        let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
43            completable.sync_handle_notification(params, &*method_fn);
44        });
45        self.add_rpc_handler(method_name, req_handler);
46    }
47    
48    pub fn add_request<
49        PARAMS : serde::Deserialize + 'static, 
50        RET : serde::Serialize + 'static, 
51        RET_ERROR : serde::Serialize + 'static
52    >(
53        &mut self,
54        method_name: &'static str, 
55        method_fn: Box<Fn(PARAMS) -> MethodResult<RET, RET_ERROR>>
56    ) {
57        let req_handler : Box<RpcMethodHandler> = new(move |params, completable| {
58            completable.sync_handle_request(params, &*method_fn);
59        });
60        self.add_rpc_handler(method_name, req_handler);
61    }
62    
63    pub fn add_rpc_handler(
64        &mut self,
65        method_name: &'static str,
66        method_handler: Box<RpcMethodHandler>
67    ) {
68        self.method_handlers.insert(method_name.to_string(), method_handler);
69    }
70    
71    fn do_invoke_method(
72        &mut self, 
73        method_name: &str, 
74        completable: ResponseCompletable,
75        request_params: RequestParams,
76    ) {
77        if let Some(method_fn) = self.method_handlers.get(method_name) 
78        {
79            let method_fn : &Box<RpcMethodHandler> = method_fn;
80            method_fn(request_params, completable);
81        } else {
82            completable.complete_with_error(error_JSON_RPC_MethodNotFound());
83        };
84    }
85    
86}
87
88impl RequestHandler for MapRequestHandler {
89    
90    fn handle_request(
91        &mut self, request_method: &str, request_params: RequestParams, completable: ResponseCompletable
92    ) {
93        self.do_invoke_method(request_method, completable, request_params);
94    }
95    
96}