wtx 0.44.1

A collection of different transport implementations and related tools focused primarily on web technologies.
Documentation 
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Implementations of the [Transport] trait.

mod mock;
mod recieving_transport;
mod sending_receiving_transport;
mod sending_transport;
mod transport_params;
mod unit;
#[cfg(feature = "http2")]
mod wtx_http;
#[cfg(feature = "web-socket")]
mod wtx_ws;

use crate::client_api_framework::network::TransportGroup;
pub use mock::{Mock, MockBytes, MockStr};
pub use recieving_transport::ReceivingTransport;
pub use sending_receiving_transport::SendingReceivingTransport;
pub use sending_transport::SendingTransport;
pub use transport_params::TransportParams;

/// Any means of transferring data between two parties.
///
/// Please, see the [`crate::client_api_framework::pkg::Package`] implementation of the desired package to know
/// more about the expected types as well as any other additional documentation.
pub trait Transport<TP> {
  /// See [TransportGroup].
  const GROUP: TransportGroup;
  /// The inner implementation.
  type Inner: Transport<TP>;
  /// If applicable, can be used by clients to poll specific sent requests.
  type ReqId;

  /// Instance counterpart of [`Self::GROUP`].
  #[inline]
  fn ty(&self) -> TransportGroup {
    Self::GROUP
  }
}

impl<T, TP> Transport<TP> for &mut T
where
  T: Transport<TP>,
{
  const GROUP: TransportGroup = T::GROUP;
  type Inner = T::Inner;
  type ReqId = T::ReqId;
}

#[cfg(feature = "web-socket")]
pub(crate) fn log_generic_res(_bytes: &[u8], _log_data: bool, _tg: TransportGroup) {
  let _body = if _log_data { crate::misc::from_utf8_basic(_bytes).ok() } else { None };
  _debug!(body = debug(_body), trans_ty = display(_tg), "Response");
}
#[cfg(feature = "http2")]
pub(crate) fn log_http_res(
  _bytes: &[u8],
  _log_data: bool,
  _status_code: crate::http::StatusCode,
  _tg: TransportGroup,
  _uri: &crate::misc::UriString,
) {
  let _body = if _log_data { crate::misc::from_utf8_basic(_bytes).ok() } else { None };
  _debug!(
    body = debug(_body),
    status_code = display(_status_code),
    trans_ty = display(_tg),
    uri = display(_uri.origin()),
    "Response"
  );
}

#[cfg(feature = "tokio")]
mod tokio {
  use crate::client_api_framework::network::{TransportGroup, transport::Transport};
  use tokio::sync::MappedMutexGuard;

  impl<T, TP> Transport<TP> for MappedMutexGuard<'_, T>
  where
    T: Transport<TP>,
  {
    const GROUP: TransportGroup = T::GROUP;
    type Inner = T::Inner;
    type ReqId = T::ReqId;
  }
}

#[cfg(test)]
mod tests {
  use crate::{
    client_api_framework::pkg::Package,
    codec::{Decode, DecodeSeq, DecodeWrapper, Encode, EncodeWrapper, GenericCodec},
    collection::Vector,
  };

  #[derive(Debug, Eq, PartialEq)]
  pub(crate) struct _PingPong(pub(crate) _Ping, pub(crate) ());

  impl<DRSR, T, TP> Package<(), DRSR, T, TP> for _PingPong {
    type ExternalRequestContent = _Ping;
    type ExternalResponseContent<'de> = _Pong;
    type PackageParams = ();

    #[inline]
    fn ext_req_content(&self) -> &Self::ExternalRequestContent {
      &self.0
    }

    #[inline]
    fn ext_req_content_mut(&mut self) -> &mut Self::ExternalRequestContent {
      &mut self.0
    }

    #[inline]
    fn pkg_params(&self) -> &Self::PackageParams {
      &self.1
    }

    #[inline]
    fn pkg_params_mut(&mut self) -> &mut Self::PackageParams {
      &mut self.1
    }
  }

  #[derive(Debug, Eq, PartialEq)]
  pub(crate) struct _Ping;

  impl<DRSR> Encode<GenericCodec<DRSR, DRSR>> for _Ping {
    #[inline]
    fn encode(&self, ew: &mut EncodeWrapper<'_, DRSR>) -> crate::Result<()> {
      ew.buffer.extend_from_copyable_slice(b"ping")?;
      Ok(())
    }
  }

  #[derive(Debug, Eq, PartialEq)]
  pub(crate) struct _Pong(pub(crate) &'static str);

  impl<'de, DRSR> Decode<'de, GenericCodec<DRSR, DRSR>> for _Pong {
    #[inline]
    fn decode(_: &mut DecodeWrapper<'de, DRSR>) -> crate::Result<Self> {
      Ok(Self("pong"))
    }
  }

  impl<'de, DRSR> DecodeSeq<'de, GenericCodec<DRSR, DRSR>> for _Pong {
    #[inline]
    fn decode_seq(_: &mut Vector<Self>, _: &mut DecodeWrapper<'de, DRSR>) -> crate::Result<()> {
      Ok(())
    }
  }
}

fn local_send_bytes<'bytes, 'bytes_buffer, 'rslt>(
  bytes: Option<&'bytes [u8]>,
  bytes_buffer: &'bytes_buffer [u8],
) -> &'rslt [u8]
where
  'bytes: 'rslt,
  'bytes_buffer: 'rslt,
{
  if let Some(el) = bytes { el } else { bytes_buffer }
}