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
use crate::{Error, Result};
use serde::{Deserialize, Serialize};
use std::fmt;
use std::io::{BufRead, BufReader, BufWriter, Read, Write};
use std::marker::PhantomData;
pub struct MessageSender<T, W: Write> {
writer: BufWriter<W>,
_message: PhantomData<T>,
}
impl<T, W> MessageSender<T, W>
where
T: Serialize,
W: Write,
{
pub fn new(writer: W) -> Self {
Self {
writer: BufWriter::new(writer),
_message: PhantomData,
}
}
pub fn send(&mut self, message: &T) -> Result<()> {
track!(serde_json::to_writer(&mut self.writer, message).map_err(Error::from))?;
track!(writeln!(self.writer).map_err(Error::from))?;
track!(self.writer.flush().map_err(Error::from))?;
Ok(())
}
}
impl<T, W: Write> fmt::Debug for MessageSender<T, W> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MessageSender {{ .. }}")
}
}
pub struct MessageReceiver<T, R: Read> {
reader: BufReader<R>,
_message: PhantomData<T>,
}
impl<T, R> MessageReceiver<T, R>
where
T: for<'a> Deserialize<'a>,
R: Read,
{
pub fn new(reader: R) -> Self {
Self {
reader: BufReader::new(reader),
_message: PhantomData,
}
}
pub fn recv(&mut self) -> Result<T> {
let mut line = String::new();
track!(self.reader.read_line(&mut line).map_err(Error::from))?;
let message = track!(serde_json::from_str(&line).map_err(Error::from); line)?;
Ok(message)
}
}
impl<T, R: Read> fmt::Debug for MessageReceiver<T, R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "MessageReceiver {{ .. }}")
}
}