wtx 0.28.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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
71
72
73
74
75
76
77
78
79

use crate::client_api_framework::{
  Api,
  misc::{
    manage_after_sending_bytes, manage_after_sending_pkg, manage_before_sending_bytes,
    manage_before_sending_pkg,
  },
  network::{
    TransportGroup,
    transport::{RecievingTransport, SendingTransport, Transport},
  },
  pkg::{Package, PkgsAux},
};
use core::ops::Range;

impl<TP> RecievingTransport<TP> for () {
  #[inline]
  async fn recv<A, DRSR>(&mut self, _: &mut PkgsAux<A, DRSR, TP>) -> Result<Range<usize>, A::Error>
  where
    A: Api,
  {
    Ok(0..0)
  }
}

impl<TP> SendingTransport<TP> for () {
  #[inline]
  async fn send_bytes<A, DRSR>(
    &mut self,
    bytes: &[u8],
    pkgs_aux: &mut PkgsAux<A, DRSR, TP>,
  ) -> Result<(), A::Error>
  where
    A: Api,
  {
    manage_before_sending_bytes(bytes, pkgs_aux, self).await?;
    manage_after_sending_bytes(pkgs_aux).await?;
    Ok(())
  }

  #[inline]
  async fn send_pkg<A, DRSR, P>(
    &mut self,
    pkg: &mut P,
    pkgs_aux: &mut PkgsAux<A, DRSR, TP>,
  ) -> Result<(), A::Error>
  where
    A: Api,
    P: Package<A, DRSR, Self::Inner, TP>,
  {
    manage_before_sending_pkg(pkg, pkgs_aux, self).await?;
    manage_after_sending_pkg(pkg, pkgs_aux, self).await?;
    Ok(())
  }
}

/// Does absolutely nothing. Good for demonstration purposes.
///
/// ```rust,no_run
/// # async fn fun() -> wtx::Result<()> {
/// use wtx::client_api_framework::{network::transport::SendingReceivingTransport, pkg::PkgsAux};
/// let _ =
///   ().send_pkg_recv_decode_contained(&mut (), &mut PkgsAux::from_minimum((), (), ())).await?;
/// # Ok(()) }
/// ```
impl<TP> Transport<TP> for () {
  const GROUP: TransportGroup = TransportGroup::Stub;
  type Inner = ();
}

#[cfg(all(feature = "_async-tests", test))]
mod tests {
  use crate::client_api_framework::{network::transport::SendingReceivingTransport, pkg::PkgsAux};

  #[tokio::test]
  async fn unit() {
    let mut pa = PkgsAux::from_minimum((), (), ());
    assert_eq!(().send_pkg_recv_decode_contained(&mut (), &mut pa).await.unwrap(), ());
  }
}