xrl 0.0.1

Xi Rpc Lib - Tokio based implementation of the RPC used in the Xi editor
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

use errors::ServerError;
use protocol::Service;
use futures::{future, Future};
use serde_json::{from_value, Value};
use structs::{ScrollTo, Style, Update};
use client::Client;

pub type ServerResult<T> = Box<Future<Item = T, Error = ServerError>>;

pub trait Frontend {
    fn update(&mut self, update: Update) -> ServerResult<()>;
    fn scroll_to(&mut self, scroll_to: ScrollTo) -> ServerResult<()>;
    fn set_style(&mut self, style: Style) -> ServerResult<()>;
}

pub trait FrontendBuilder<F>
where
    F: Frontend,
{
    fn build(self, client: Client) -> F;
}

impl<F: Frontend> Service for F {
    type T = Value;
    type E = Value;
    type Error = ServerError;

    fn handle_request(
        &mut self,
        _method: &str,
        _params: Value,
    ) -> Box<Future<Item = Result<Self::T, Self::E>, Error = Self::Error>> {
        // AFAIK the core does not send any request to frontends yet
        // We should return an ServerError here
        unimplemented!();
    }

    fn handle_notification(
        &mut self,
        method: &str,
        params: Value,
    ) -> Box<Future<Item = (), Error = Self::Error>> {
        info!(
            "Handling notification: METHOD={}, PARAMS={}",
            method,
            &params
        );

        match method {
            "update" => match from_value::<Update>(params) {
                Ok(update) => self.update(update),
                Err(e) => {
                    error!("Can't handle notification: invalid parameters {}", &e);
                    Box::new(future::err(ServerError::DeserializeFailed(e)))
                }
            },

            "scroll_to" => match from_value::<ScrollTo>(params) {
                Ok(scroll_to) => self.scroll_to(scroll_to),
                Err(e) => {
                    error!("Can't handle notification: invalid parameters {}", &e);
                    Box::new(future::err(ServerError::DeserializeFailed(e)))
                }
            },

            "set_style" => match from_value::<Style>(params) {
                Ok(style) => self.set_style(style),
                Err(e) => {
                    error!("Can't handle notification: invalid parameters {}", &e);
                    Box::new(future::err(ServerError::DeserializeFailed(e)))
                }
            },

            _ => {
                error!("Can't handle notification: unknown method");
                Box::new(future::err(ServerError::UnknownMethod(method.into())))
            }
        }
    }
}