wtx 0.43.0

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

use crate::http::{Protocol, ReqResBuffer, Request};
use core::net::IpAddr;

#[cfg(feature = "http2")]
/// Manual server stream backed by tokio structures.
pub type ManualServerStream<CA, HB, SA, SW> =
  ManualStream<CA, crate::http2::ServerStream<HB, SW>, SA>;

/// Tells how an HTTP stream should be handled.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum OperationMode {
  /// Automatic
  Auto,
  /// Manual
  Manual,
}

/// HTTP stream that is automatically managed by the system. In other words, all frames
/// are gathered until an end-of-stream flag is received and only then a response is sent.
#[derive(Debug)]
pub struct AutoStream<CA, SA> {
  /// Connection auxiliary
  pub conn_aux: CA,
  /// Remote peer address
  pub peer: IpAddr,
  /// See [Protocol].
  pub protocol: Option<Protocol>,
  /// Request
  pub req: Request<ReqResBuffer>,
  /// Stream auxiliary
  pub stream_aux: SA,
}

/// HTTP stream that is manually managed by the user. For example, WebSockets over streams.
#[derive(Debug)]
pub struct ManualStream<CA, S, SA> {
  /// Connection auxiliary
  pub conn_aux: CA,
  /// Remote peer address
  pub peer: IpAddr,
  /// See [Protocol].
  pub protocol: Option<Protocol>,
  /// Request
  pub req: Request<ReqResBuffer>,
  /// Stream
  pub stream: S,
  /// Stream auxiliary
  pub stream_aux: SA,
}

/// Operation Mode Stream
pub trait OperationModeStream {
  /// Operation mode
  const OM: OperationMode;
  /// Connection Auxiliary
  type ConnAux;
  /// Stream Auxiliary
  type StreamAux;

  /// Connection auxiliary
  fn conn_aux(&mut self) -> &mut Self::ConnAux;

  /// Remote peer address
  fn parts(&mut self) -> (&mut Self::ConnAux, &mut Request<ReqResBuffer>, &mut Self::StreamAux);

  /// Remote peer address
  fn peer(&self) -> &IpAddr;

  /// Request
  fn req(&mut self) -> &mut Request<ReqResBuffer>;

  /// Stream auxiliary
  fn stream_aux(&mut self) -> &mut Self::StreamAux;
}

impl<CA, SA> OperationModeStream for AutoStream<CA, SA> {
  const OM: OperationMode = OperationMode::Auto;
  type ConnAux = CA;
  type StreamAux = SA;

  #[inline]
  fn conn_aux(&mut self) -> &mut Self::ConnAux {
    &mut self.conn_aux
  }

  #[inline]
  fn parts(&mut self) -> (&mut Self::ConnAux, &mut Request<ReqResBuffer>, &mut Self::StreamAux) {
    (&mut self.conn_aux, &mut self.req, &mut self.stream_aux)
  }

  #[inline]
  fn peer(&self) -> &IpAddr {
    &self.peer
  }

  #[inline]
  fn req(&mut self) -> &mut Request<ReqResBuffer> {
    &mut self.req
  }

  #[inline]
  fn stream_aux(&mut self) -> &mut Self::StreamAux {
    &mut self.stream_aux
  }
}

impl<CA, S, SA> OperationModeStream for ManualStream<CA, S, SA> {
  const OM: OperationMode = OperationMode::Manual;
  type ConnAux = CA;
  type StreamAux = SA;

  #[inline]
  fn conn_aux(&mut self) -> &mut CA {
    &mut self.conn_aux
  }

  #[inline]
  fn parts(&mut self) -> (&mut Self::ConnAux, &mut Request<ReqResBuffer>, &mut Self::StreamAux) {
    (&mut self.conn_aux, &mut self.req, &mut self.stream_aux)
  }

  #[inline]
  fn peer(&self) -> &IpAddr {
    &self.peer
  }

  #[inline]
  fn req(&mut self) -> &mut Request<ReqResBuffer> {
    &mut self.req
  }

  #[inline]
  fn stream_aux(&mut self) -> &mut SA {
    &mut self.stream_aux
  }
}