src/conn.rs

   1 use super::PktInfo;
   2 use delegate::delegate;
   3 use mt_ser::{DefCfg, MtDeserialize, MtSerialize};
   4 use std::{borrow::Cow, io};
   5 use thiserror::Error;
   6
   7 pub trait Remote {
   8     type UdpSender: mt_rudp::UdpSender;
   9     type PktFrom: MtDeserialize;
  10     type PktTo: MtSerialize + PktInfo;
  11 }
  12
  13 #[cfg(feature = "client")]
  14 pub struct RemoteSrv;
  15
  16 #[cfg(feature = "client")]
  17 impl Remote for RemoteSrv {
  18     type UdpSender = mt_rudp::ToSrv;
  19     type PktTo = crate::ToSrvPkt;
  20     type PktFrom = crate::ToCltPkt;
  21 }
  22
  23 #[cfg(feature = "client")]
  24 pub async fn connect(addr: &str) -> io::Result<(MtSender<RemoteSrv>, MtReceiver<RemoteSrv>)> {
  25     let (tx, rx) = mt_rudp::connect(addr).await?;
  26     Ok((MtSender(tx), MtReceiver(rx)))
  27 }
  28
  29 /*
  30
  31 pub struct RemoteClt;
  32 impl Remote for RemoteClt {
  33     type Sender = mt_rudp::ToClt;
  34     type To = crate::ToCltPkt;
  35     type From = crate::ToSrvPkt;
  36 }
  37
  38 */
  39
  40 pub struct MtSender<R: Remote>(pub mt_rudp::RudpSender<R::UdpSender>);
  41 pub struct MtReceiver<R: Remote>(pub mt_rudp::RudpReceiver<R::UdpSender>);
  42
  43 #[derive(Error, Debug)]
  44 pub enum RecvError {
  45     #[error("connection error: {0}")]
  46     ConnError(#[from] mt_rudp::Error),
  47     #[error("deserialize error: {0}")]
  48     DeserializeError(#[from] mt_ser::DeserializeError),
  49 }
  50
  51 #[derive(Error, Debug)]
  52 pub enum SendError {
  53     #[error("connection error: {0}")]
  54     ConnError(#[from] io::Error),
  55     #[error("serialize error: {0}")]
  56     SerializeError(#[from] mt_ser::SerializeError),
  57 }
  58
  59 macro_rules! impl_delegate {
  60     ($T:ident) => {
  61         impl<R: Remote> $T<R> {
  62             delegate! {
  63                 to self.0 {
  64                     pub async fn peer_id(&self) -> u16;
  65                     pub async fn is_server(&self) -> bool;
  66                     pub async fn close(self);
  67                 }
  68             }
  69         }
  70     };
  71 }
  72
  73 impl_delegate!(MtSender);
  74 impl_delegate!(MtReceiver);
  75
  76 impl<R: Remote> MtReceiver<R> {
  77     pub async fn recv(&mut self) -> Option<Result<R::PktFrom, RecvError>> {
  78         self.0.recv().await.map(|res| {
  79             res.map_err(RecvError::from).and_then(|pkt| {
  80                 // TODO: warn on trailing data
  81                 R::PktFrom::mt_deserialize::<DefCfg>(&mut io::Cursor::new(pkt.data))
  82                     .map_err(RecvError::from)
  83             })
  84         })
  85     }
  86 }
  87
  88 impl<R: Remote> MtSender<R> {
  89     pub async fn send(&self, pkt: &R::PktTo) -> Result<(), SendError> {
  90         let mut writer = Vec::new();
  91         pkt.mt_serialize::<DefCfg>(&mut writer)?;
  92
  93         let (chan, unrel) = pkt.pkt_info();
  94         self.0
  95             .send(mt_rudp::Pkt {
  96                 chan,
  97                 unrel,
  98                 data: Cow::Borrowed(&writer),
  99             })
 100             .await?;
 101
 102         Ok(())
 103     }
 104 }