src/conn.rs

   1 use super::PktInfo;
   2 use async_trait::async_trait;
   3 use mt_rudp::Pkt;
   4 pub use mt_rudp::{Ack, Error as RudpError};
   5 use mt_ser::{DefCfg, MtDeserialize, MtSerialize};
   6 use std::{borrow::Cow, io};
   7 use thiserror::Error;
   8
   9 #[derive(Error, Debug)]
  10 pub enum RecvError {
  11     #[error("connection error: {0}")]
  12     ConnError(#[from] RudpError),
  13     #[error("deserialize error: {0}")]
  14     DeserializeError(#[from] mt_ser::DeserializeError),
  15 }
  16
  17 #[derive(Error, Debug)]
  18 pub enum SendError {
  19     #[error("connection error: {0}")]
  20     ConnError(#[from] io::Error),
  21     #[error("serialize error: {0}")]
  22     SerializeError(#[from] mt_ser::SerializeError),
  23 }
  24
  25 #[async_trait]
  26 pub trait SenderExt {
  27     type Pkt: MtSerialize + PktInfo + Send + Sync;
  28
  29     async fn send_raw(&self, pkt: Pkt<'_>) -> io::Result<Ack>;
  30     async fn send(&self, pkt: &Self::Pkt) -> Result<Ack, SendError> {
  31         let mut writer = Vec::new();
  32         pkt.mt_serialize::<DefCfg>(&mut writer)?;
  33
  34         let (chan, unrel) = pkt.pkt_info();
  35         Ok(self
  36             .send_raw(Pkt {
  37                 chan,
  38                 unrel,
  39                 data: Cow::Borrowed(&writer),
  40             })
  41             .await?)
  42     }
  43 }
  44
  45 #[async_trait]
  46 pub trait ReceiverExt {
  47     type Pkt: MtDeserialize;
  48
  49     async fn recv_raw(&mut self) -> Option<Result<Pkt<'static>, RudpError>>;
  50     async fn recv(&mut self) -> Option<Result<Self::Pkt, RecvError>> {
  51         self.recv_raw().await.map(|res| {
  52             res.map_err(RecvError::from).and_then(|pkt| {
  53                 // TODO: warn on trailing data
  54                 Self::Pkt::mt_deserialize::<DefCfg>(&mut io::Cursor::new(pkt.data))
  55                     .map_err(RecvError::from)
  56             })
  57         })
  58     }
  59 }
  60
  61 #[cfg(feature = "client")]
  62 pub use mt_rudp::{connect, CltReceiver, CltSender, CltWorker};
  63
  64 #[cfg(feature = "client")]
  65 #[async_trait]
  66 impl ReceiverExt for CltReceiver {
  67     type Pkt = crate::ToCltPkt;
  68
  69     async fn recv_raw(&mut self) -> Option<Result<Pkt<'static>, RudpError>> {
  70         self.recv_rudp().await
  71     }
  72 }
  73
  74 #[cfg(feature = "client")]
  75 #[async_trait]
  76 impl SenderExt for CltSender {
  77     type Pkt = crate::ToSrvPkt;
  78
  79     async fn send_raw(&self, pkt: Pkt<'_>) -> io::Result<Ack> {
  80         self.send_rudp(pkt).await
  81     }
  82 }