wtx 0.44.3

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

use crate::{
  collection::Vector,
  misc::{ConnectionState, LeaseMut, net::PartitionedFilledBuffer},
  rng::Rng,
  stream::{Stream, StreamReader, StreamWriter},
  web_socket::{
    Frame, FrameMut, WebSocketPayloadOrigin, compression::NegotiatedCompression,
    is_in_continuation_frame::IsInContinuationFrame, web_socket_reader::read_frame,
    web_socket_replier::WebSocketReplier, web_socket_writer,
  },
};

#[derive(Debug)]
pub(crate) struct WebSocketReaderGeneric<PFB, V, const IS_CLIENT: bool> {
  pub(crate) max_payload_len: usize,
  pub(crate) network_buffer: PFB,
  pub(crate) no_masking: bool,
  pub(crate) reader_buffer: V,
}

impl<PFB, V, const IS_CLIENT: bool> WebSocketReaderGeneric<PFB, V, IS_CLIENT>
where
  PFB: LeaseMut<PartitionedFilledBuffer>,
  V: LeaseMut<Vector<u8>>,
{
  pub(crate) async fn read_frame_mut<'frame, 'this, 'ub, NC, R, S>(
    &'this mut self,
    connection_state: &mut ConnectionState,
    is_in_continuation_frame: &mut Option<IsInContinuationFrame>,
    nc: &mut NC,
    nc_rsv1: u8,
    payload_origin: WebSocketPayloadOrigin,
    rng: &mut R,
    stream: &mut S,
    user_buffer: &'ub mut Vector<u8>,
  ) -> crate::Result<FrameMut<'frame, IS_CLIENT>>
  where
    'this: 'frame,
    'ub: 'frame,
    NC: NegotiatedCompression,
    R: Rng,
    S: Stream,
  {
    let Self { max_payload_len, network_buffer, no_masking, reader_buffer } = self;
    read_frame::<_, _, _, _, _, true, IS_CLIENT>(
      connection_state,
      is_in_continuation_frame,
      *max_payload_len,
      nc,
      nc_rsv1,
      network_buffer.lease_mut(),
      *no_masking,
      payload_origin,
      reader_buffer.lease_mut(),
      &WebSocketReplier::new(),
      rng,
      stream,
      user_buffer,
      |local_stream| local_stream,
      |local_stream| local_stream,
    )
    .await
  }

  pub(crate) async fn read_frame_owned<'frame, 'this, 'ub, NC, R, SR>(
    &'this mut self,
    connection_state: &mut ConnectionState,
    is_in_continuation_frame: &mut Option<IsInContinuationFrame>,
    nc: &mut NC,
    nc_rsv1: u8,
    payload_origin: WebSocketPayloadOrigin,
    replier: &WebSocketReplier<IS_CLIENT>,
    rng: &mut R,
    stream_reader: &mut SR,
    user_buffer: &'ub mut Vector<u8>,
  ) -> crate::Result<FrameMut<'frame, IS_CLIENT>>
  where
    'this: 'frame,
    'ub: 'frame,
    NC: NegotiatedCompression,
    R: Rng,
    SR: StreamReader,
  {
    let Self { max_payload_len, network_buffer, no_masking, reader_buffer } = self;
    read_frame::<_, _, _, _, _, false, IS_CLIENT>(
      connection_state,
      is_in_continuation_frame,
      *max_payload_len,
      nc,
      nc_rsv1,
      network_buffer.lease_mut(),
      *no_masking,
      payload_origin,
      reader_buffer.lease_mut(),
      replier,
      rng,
      &mut (stream_reader, &mut ()),
      user_buffer,
      |local_stream| local_stream.0,
      |local_stream| local_stream.1,
    )
    .await
  }
}

/// Auxiliary structure that can be used when it is necessary to write a received frame that belongs
/// to the same instance.
#[derive(Debug)]
pub(crate) struct WebSocketWriterGeneric<V, const IS_CLIENT: bool> {
  pub(crate) no_masking: bool,
  pub(crate) writer_buffer: V,
}

impl<V, const IS_CLIENT: bool> WebSocketWriterGeneric<V, IS_CLIENT>
where
  V: LeaseMut<Vector<u8>>,
{
  pub(crate) async fn write_frame<NC, P, R, SW>(
    &mut self,
    connection_state: &mut ConnectionState,
    frame: &mut Frame<P, IS_CLIENT>,
    nc: &mut NC,
    nc_rsv1: u8,
    rng: &mut R,
    stream_writer: &mut SW,
  ) -> crate::Result<()>
  where
    NC: NegotiatedCompression,
    P: LeaseMut<[u8]>,
    R: Rng,
    SW: StreamWriter,
  {
    let Self { no_masking, writer_buffer } = self;
    web_socket_writer::write_frame(
      connection_state,
      frame,
      *no_masking,
      nc,
      nc_rsv1,
      rng,
      stream_writer,
      writer_buffer.lease_mut(),
    )
    .await?;
    Ok(())
  }
}