djin_protocol/wire/stream/
connection.rs

1use crate::{Parcel, Error, Settings};
2use crate::wire::stream::{Transport, transport};
3use crate::wire::middleware;
4
5use std::io::prelude::*;
6use std::io::Cursor;
7
8/// A stream-based connection.
9// TODO: Allow custom transports.
10#[derive(Debug)]
11pub struct Connection<P: Parcel, S: Read + Write, M: middleware::Pipeline = middleware::pipeline::Default>
12{
13    pub stream: S,
14    pub transport: transport::Simple,
15    pub middleware: M,
16    pub settings: Settings,
17
18    pub _a: ::std::marker::PhantomData<P>,
19}
20
21impl<P,S,M> Connection<P,S,M>
22    where P: Parcel, S: Read + Write, M: middleware::Pipeline
23{
24    /// Creates a new connection.
25    pub fn new(stream: S,
26               middleware: M,
27               settings: Settings) -> Self {
28        Connection {
29            stream: stream,
30            transport: transport::Simple::new(),
31            middleware: middleware,
32            settings,
33            _a: ::std::marker::PhantomData,
34        }
35    }
36
37    /// Processes any incoming data in the stream.
38    pub fn process_incoming_data(&mut self) -> Result<(), Error> {
39        self.transport.process_data(&mut self.stream, &self.settings)
40    }
41
42    /// Attempts to receive a packet.
43    pub fn receive_packet(&mut self) -> Result<Option<P>, Error> {
44        self.process_incoming_data()?;
45
46        if let Some(raw_packet) = self.transport.receive_raw_packet()? {
47            let mut packet_data = Cursor::new(self.middleware.decode_data(raw_packet)?);
48
49            let packet = P::read(&mut packet_data, &self.settings)?;
50
51            Ok(Some(packet))
52        } else {
53            Ok(None)
54        }
55    }
56
57    /// Sends a packet.
58    pub fn send_packet(&mut self, packet: &P) -> Result<(), Error> {
59        let raw_packet = self.middleware.encode_data(packet.raw_bytes(&self.settings)?)?;
60        self.transport.send_raw_packet(&mut self.stream, &raw_packet, &self.settings)
61    }
62
63    pub fn into_inner(self) -> S { self.stream }
64}
65