wtx 0.50.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
137

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

/// 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<D> {
  /// Auxiliary data
  pub data: D,
  /// data peer address
  pub peer: IpAddr,
  /// See [Protocol].
  pub protocol: Option<Protocol>,
  /// Request
  pub req: Request<MsgBufferString>,
}

impl<D> AutoStream<D> {
  /// Shortcut
  #[inline]
  pub const fn new(
    data: D,
    peer: IpAddr,
    protocol: Option<Protocol>,
    req: Request<MsgBufferString>,
  ) -> Self {
    Self { data, peer, protocol, req }
  }
}

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

impl<D, S> ManualStream<D, S> {
  /// Shortcut
  #[inline]
  pub const fn new(
    data: D,
    peer: IpAddr,
    protocol: Option<Protocol>,
    req: Request<MsgBufferString>,
    stream: S,
  ) -> Self {
    Self { data, peer, protocol, req, stream }
  }
}

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

  /// Auxiliary data
  fn data(&mut self) -> &mut Self::Data;

  /// Remote peer address
  fn parts(&mut self) -> (&mut Self::Data, &mut Request<MsgBufferString>);

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

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

impl<D> OperationModeStream for AutoStream<D> {
  const OM: OperationMode = OperationMode::Auto;
  type Data = D;

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

  #[inline]
  fn parts(&mut self) -> (&mut Self::Data, &mut Request<MsgBufferString>) {
    (&mut self.data, &mut self.req)
  }

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

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

impl<D, S> OperationModeStream for ManualStream<D, S> {
  const OM: OperationMode = OperationMode::Manual;
  type Data = D;

  #[inline]
  fn data(&mut self) -> &mut D {
    &mut self.data
  }

  #[inline]
  fn parts(&mut self) -> (&mut Self::Data, &mut Request<MsgBufferString>) {
    (&mut self.data, &mut self.req)
  }

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

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