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
extern crate serde;
extern crate serde_json;
use std::io::stdin;
use std::error::Error;
use serde::{Serialize, Deserialize};
use serde_json::{from_str, to_string};
use types::{Input, Output};
pub use types::Context;
mod types;
pub trait Handler<I: Deserialize, O: Serialize, E: Error> {
fn handle(&self, I, Context) -> Result<O, E>;
}
impl<I: Deserialize, O: Serialize, E: Error, F> Handler<I, O, E> for F
where F: Fn(I, Context) -> Result<O, E>
{
fn handle(&self, ipt: I, ctx: Context) -> Result<O, E> {
self(ipt, ctx)
}
}
pub fn run<I: Deserialize, O: Serialize, E: Error, H: Handler<I, O, E>>(h: H) {
let mut buf = String::new();
loop {
if let Err(e) = stdin().read_line(&mut buf) {
return_error::<O, _>(e);
break;
}
let i: Result<Input<I>, _> = from_str(&buf);
match i {
Ok(ipt) => {
match h.handle(ipt.event, ipt.context) {
Ok(r) => return_success(r),
Err(e) => return_error::<O, _>(e),
}
}
Err(e) => return_error::<O, _>(e),
}
buf.clear();
}
}
fn return_error<O: Serialize, E: Error>(e: E) {
let s = to_string(&Output::Error::<O>(format!("{}", e))).unwrap();
println!("{}", s);
}
fn return_success<O: Serialize>(r: O) {
let s = to_string(&Output::Value(r)).unwrap();
println!("{}", s);
}