Struct jsonrpc_core::io::IoHandler

pub struct IoHandler {
    // some fields omitted
}

Should be used to handle jsonrpc io.

extern crate jsonrpc_core;
use jsonrpc_core::*;

fn main() {
    let io = IoHandler::new();
    struct SayHello;

    // Implement `SyncMethodCommand` or `AsyncMethodCommand`
    impl SyncMethodCommand for SayHello {
        fn execute(&self, _params: Params) -> Result<Value, Error>  {
            Ok(Value::String("hello".to_string()))
        }
    }

    io.add_method("say_hello", SayHello);
    // Or just use closures
    io.add_async_method("say_hello_async", |_params: Params, ready: Ready| {
        ready.ready(Ok(Value::String("hello".to_string())))
    });

    let request1 = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
    let request2 = r#"{"jsonrpc": "2.0", "method": "say_hello_async", "params": [42, 23], "id": 1}"#;
    let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;

    assert_eq!(io.handle_request_sync(request1), Some(response.to_string()));
    assert_eq!(io.handle_request_sync(request2), Some(response.to_string()));
}

Methods

impl IoHandler

fn new() -> Self

Creates new IoHandler

fn add_method<C>(&self, name: &str, command: C) where C: MethodCommand + 'static

Add supported method

fn add_async_method<C>(&self, name: &str, command: C) where C: AsyncMethodCommand + 'static

Add supported asynchronous method

fn add_notification<C>(&self, name: &str, command: C) where C: NotificationCommand + 'static

Add supported notification

fn add_delegate<D>(&self, delegate: IoDelegate<D>) where D: Send + Sync

Add delegate with supported methods.

fn handle_request_sync<'a>(&self, request_str: &'a str) -> Option<String>

Handle given request synchronously - will block until response is available. If you have any asynchronous methods in your RPC it is much wiser to use handle_request instead and deal with asynchronous requests in a non-blocking fashion.

fn handle_request<'a>(&self, request_str: &'a str) -> Option<AsyncStringResponse>

Handle given request asynchronously.