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

//! Abstractions over different types of data streams.

macro_rules! _local_write_all {
  ($bytes:expr, $write:expr) => {{
    while !$bytes.is_empty() {
      match $write {
        Err(err) => return Err(err.into()),
        Ok(0) => return { Err(crate::Error::UnexpectedStreamWriteEOF) },
        Ok(n) => $bytes = $bytes.get(n..).unwrap_or_default(),
      }
    }
  }};
}

macro_rules! _local_write_all_vectored {
  ($bytes:expr, $this:ident, |$io_slices:ident| $write_many:expr) => {{
    match $bytes {
      [] => return Ok(()),
      [single] => {
        <Self as crate::stream::StreamWriter>::write_all($this, single).await?;
      }
      _ => {
        let mut buffer = [std::io::IoSlice::new(&[]); _];
        let mut $io_slices = crate::stream::convert_to_io_slices(&mut buffer, $bytes)?;
        while !$io_slices.is_empty() {
          match $write_many {
            Err(err) => return Err(err.into()),
            Ok(0) => return Err(crate::Error::UnexpectedStreamWriteEOF),
            Ok(n) => std::io::IoSlice::advance_slices(&mut $io_slices, n),
          }
        }
      }
    }
  }};
}

mod buf_stream_reader;
mod bytes_stream;
#[cfg(feature = "embassy-net")]
mod embassy_net;
#[cfg(feature = "std")]
mod std;
mod stream_common;
mod stream_reader;
mod stream_writer;
mod tcp_listener;
mod tcp_stream;
#[cfg(feature = "tokio")]
mod tokio;
mod udp_stream;

pub use buf_stream_reader::{BufStreamReader, BufStreamReaderError};
pub use bytes_stream::BytesStream;
pub use stream_common::StreamCommon;
pub use stream_reader::StreamReader;
pub use stream_writer::StreamWriter;
pub use tcp_listener::TcpListener;
pub use tcp_stream::TcpStream;
pub use udp_stream::UdpStream;

/// A stream of values produced asynchronously.
pub trait Stream: StreamReader + StreamWriter {
  /// Connects the reader and the writer.
  type BridgeOwned;
  /// See [`StreamReader`].
  type ReadHalfOwned: StreamReader;
  /// See [`StreamWriter`].
  type WriteHalfOwned: StreamWriter;

  /// Splits this instance into owned parts that can be used in concurrent scenarios.
  fn into_split(
    self,
  ) -> crate::Result<(Self::BridgeOwned, Self::ReadHalfOwned, Self::WriteHalfOwned)>;
}

impl Stream for () {
  type BridgeOwned = ();
  type ReadHalfOwned = ();
  type WriteHalfOwned = ();

  #[inline]
  fn into_split(
    self,
  ) -> crate::Result<(Self::BridgeOwned, Self::ReadHalfOwned, Self::WriteHalfOwned)> {
    Ok(((), (), ()))
  }
}

#[cfg(feature = "std")]
fn convert_to_io_slices<'buffer, 'bytes>(
  buffer: &'buffer mut [::std::io::IoSlice<'bytes>; 8],
  elems: &[&'bytes [u8]],
) -> crate::Result<&'buffer mut [::std::io::IoSlice<'bytes>]> {
  if elems.len() > 8 {
    return crate::misc::unlikely_elem(Err(crate::Error::VectoredWriteOverflow));
  }
  for (elem, io_slice) in elems.iter().zip(&mut *buffer) {
    *io_slice = ::std::io::IoSlice::new(elem);
  }
  Ok(buffer.get_mut(..elems.len()).unwrap_or_default())
}