1 use hedgewars_engine_messages::{messages::*, parser::extract_message}; |
1 mod channel; |
2 use netbuf::*; |
2 mod queue; |
3 use std::io::*; |
|
4 |
3 |
5 pub struct IPC { |
4 pub use self::channel::*; |
6 in_buffer: Buf, |
5 pub use self::queue::*; |
7 out_buffer: Buf, |
|
8 } |
|
9 |
|
10 impl IPC { |
|
11 pub fn new() -> Self { |
|
12 Self { |
|
13 in_buffer: Buf::new(), |
|
14 out_buffer: Buf::new(), |
|
15 } |
|
16 } |
|
17 |
|
18 pub fn send_message(&mut self, message: &EngineMessage) { |
|
19 self.out_buffer.write(&message.to_bytes()).unwrap(); |
|
20 } |
|
21 |
|
22 pub fn iter(&mut self) -> IPCMessagesIterator { |
|
23 IPCMessagesIterator::new(self) |
|
24 } |
|
25 } |
|
26 |
|
27 impl Write for IPC { |
|
28 fn write(&mut self, buf: &[u8]) -> Result<usize> { |
|
29 self.in_buffer.write(buf) |
|
30 } |
|
31 |
|
32 fn flush(&mut self) -> Result<()> { |
|
33 self.in_buffer.flush() |
|
34 } |
|
35 } |
|
36 |
|
37 impl Read for IPC { |
|
38 fn read(&mut self, buf: &mut [u8]) -> Result<usize> { |
|
39 let read_bytes = self.out_buffer.as_ref().read(buf)?; |
|
40 |
|
41 self.out_buffer.consume(read_bytes); |
|
42 |
|
43 Ok(read_bytes) |
|
44 } |
|
45 } |
|
46 |
|
47 pub struct IPCMessagesIterator<'a> { |
|
48 ipc: &'a mut IPC, |
|
49 } |
|
50 |
|
51 impl<'a> IPCMessagesIterator<'a> { |
|
52 pub fn new(ipc: &'a mut IPC) -> Self { |
|
53 Self { ipc } |
|
54 } |
|
55 } |
|
56 |
|
57 impl<'a> Iterator for IPCMessagesIterator<'a> { |
|
58 type Item = EngineMessage; |
|
59 |
|
60 fn next(&mut self) -> Option<Self::Item> { |
|
61 let (consumed, message) = extract_message(&self.ipc.in_buffer[..])?; |
|
62 |
|
63 self.ipc.in_buffer.consume(consumed); |
|
64 |
|
65 Some(message) |
|
66 } |
|
67 } |
|