stream-tungstenite

https://docs.rs/stream-tungstenite/0.5.1/
Admin
A Rust crate for asynchronous WebSocket stream handling, likely building on `tokio-tungstenite`.
Tokens:813,630
Snippets:3,629
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Build HTTP Requests with GET, PUT, and POST Methods

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/request/struct.Request

This snippet provides the API documentation and usage examples for the `get`, `put`, and `post` methods of the `Request` builder. These methods are used to initiate the construction of an HTTP request with the corresponding HTTP verb and a specified URI, returning a `Builder` instance for further configuration.

```APIDOC
Request Builder Methods:

pub fn get<T>(uri: T) -> Builder
  - Description: Creates a new `Builder` initialized with a GET method and the given URI. This method returns an instance of `Builder` which can be used to create a `Request`.
  - Parameters:
    - uri: T (Type T must implement TryInto<Uri>, allowing conversion to a URI)
  - Returns: Builder (An instance of the Request Builder)

pub fn put<T>(uri: T) -> Builder
  - Description: Creates a new `Builder` initialized with a PUT method and the given URI. This method returns an instance of `Builder` which can be used to create a `Request`.
  - Parameters:
    - uri: T (Type T must implement TryInto<Uri>, allowing conversion to a URI)
  - Returns: Builder (An instance of the Request Builder)

pub fn post<T>(uri: T) -> Builder
  - Description: Creates a new `Builder` initialized with a POST method and the given URI. This method returns an instance of `Builder` which can be used to create a `Request`.
  - Parameters:
    - uri: T (Type T must implement TryInto<Uri>, allowing conversion to a URI)
  - Returns: Builder (An instance of the Request Builder)
```

```Rust
// Example for GET method
let request_get = Request::get("https://www.rust-lang.org/")
    .body(())
    .unwrap();

// Example for PUT method
let request_put = Request::put("https://www.rust-lang.org/")
    .body(())
    .unwrap();

// Example for POST method
let request_post = Request::post("https://www.rust-lang.org/")
    .body(())
    .unwrap();
```

--------------------------------

### Rust String repeat Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Examples demonstrating the usage of the `repeat` method in Rust, showing how to repeat a string a specified number of times and an example of a runtime panic due to capacity overflow.

```Rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
```

```Rust
// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

--------------------------------

### Rust ClientRequestBuilder Usage Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/client/struct.ClientRequestBuilder

Demonstrates how to use `ClientRequestBuilder` to create a WebSocket client request. This example shows how to parse a URI, add an 'Authorization' header, specify a sub-protocol, and then connect using the configured builder.

```Rust
use http::Uri;
use tungstenite::{connect, ClientRequestBuilder};

let uri: Uri = "ws://localhost:3012/socket".parse().unwrap();
let token = "my_jwt_token";
let builder = ClientRequestBuilder::new(uri)
    .with_header("Authorization", format!("Bearer {token}"))
    .with_sub_protocol("my_sub_protocol");
let socket = connect(builder).unwrap();
```

--------------------------------

### Rust `Response::builder()` Method Usage Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Response

An example demonstrating the idiomatic way to construct an `http::Response` using its `builder()` method, setting status and headers in a chained manner.

```Rust
let response = Response::builder()
    .status(200)
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();
```

--------------------------------

### Rust `str::parse` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples demonstrating the usage of Rust's `str::parse` method, including basic parsing, using the turbofish syntax for explicit type inference, and handling scenarios where parsing fails.

```Rust
let four: u32 = "4".parse().unwrap();

assert_eq!(4, four);
```

```Rust
let four = "4".parse::<u32>();

assert_eq!(Ok(4), four);
```

```Rust
let nope = "j".parse::<u32>();

assert!(nope.is_err());
```

--------------------------------

### Rust Example for `PathAndQuery::from_static` Usage

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/uri/struct.PathAndQuery

Provides a Rust code example demonstrating how to use the `PathAndQuery::from_static` method. It shows how to create a `PathAndQuery` object from a literal string and then verify its extracted path and query components using assertions.

```Rust
let v = PathAndQuery::from_static("/hello?world");

assert_eq!(v.path(), "/hello");
assert_eq!(v.query(), Some("world"));
```

--------------------------------

### Rust Example: Chained Request Builder Usage

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Request

A concise example demonstrating the chained method calls of `Request::builder()` to set HTTP method, URI, headers, and the body, culminating in the creation of a `Request` object.

```Rust
let request = Request::builder()
    .method("GET")
    .uri("https://www.rust-lang.org/")
    .header("X-Custom-Foo", "Bar")
    .body(())
    .unwrap();
```

--------------------------------

### Rust Uri Struct Usage Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/uri/struct.Uri

Demonstrates how to parse string literals into `Uri` instances and access their components such as path, query, scheme, and host. Shows examples for both relative and absolute URIs, illustrating common usage patterns.

```Rust
use http::Uri;

let uri = "/foo/bar?baz".parse::<Uri>().unwrap();
assert_eq!(uri.path(), "/foo/bar");
assert_eq!(uri.query(), Some("baz"));
assert_eq!(uri.host(), None);

let uri = "https://www.rust-lang.org/install.html".parse::<Uri>().unwrap();
assert_eq!(uri.scheme_str(), Some("https"));
assert_eq!(uri.host(), Some("www.rust-lang.org"));
assert_eq!(uri.path(), "/install.html");
```

--------------------------------

### Rust String Repetition Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Rust code examples demonstrating the use of the `repeat` method to duplicate a string, including a scenario that illustrates a potential panic due to capacity overflow.

```Rust
assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));

// this will panic at runtime
let huge = "0123456789abcdef".repeat(usize::MAX);
```

--------------------------------

### Rust `http::Uri::from_parts()` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/uri/struct.Uri

Illustrates converting a `http::uri::Parts` struct into a `http::Uri`. Examples include constructing both relative and absolute URIs by setting different `Parts` components.

```Rust
// Relative URI
let mut parts = Parts::default();
parts.path_and_query = Some("/foo".parse().unwrap());

let uri = Uri::from_parts(parts).unwrap();

assert_eq!(uri.path(), "/foo");

assert!(uri.scheme().is_none());
assert!(uri.authority().is_none());

// Absolute URI
let mut parts = Parts::default();
parts.scheme = Some("http".parse().unwrap());
parts.authority = Some("foo.com".parse().unwrap());
parts.path_and_query = Some("/foo".parse().unwrap());

let uri = Uri::from_parts(parts).unwrap();

assert_eq!(uri.scheme().unwrap().as_str(), "http");
assert_eq!(uri.authority().unwrap(), "foo.com");
assert_eq!(uri.path(), "/foo");
```

--------------------------------

### Rust str::splitn Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples demonstrating the usage of the `splitn` method with various patterns and limits. This includes splitting by characters, string slices, and using a closure as a pattern, showing how the `n` parameter limits the number of returned substrings.

```Rust
let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);
```

```Rust
let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);
```

```Rust
let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);
```

```Rust
let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);
```

```Rust
let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);
```

--------------------------------

### Example Usage of Rust `str::splitn`

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Provides examples demonstrating the `splitn` method's behavior with different patterns and `n` limits, including simple string/char patterns and a closure-based pattern, showing how it limits the number of returned substrings.

```Rust
let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);

let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);

let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);

let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);
```

--------------------------------

### ServerHandshake API Documentation

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.ServerHandshake

Comprehensive API documentation for the `ServerHandshake` struct, which manages the server-side WebSocket handshake process. It includes the `start` method for initiating the handshake and various trait implementations like `Debug` and `HandshakeRole`.

```APIDOC
impl<S, C> ServerHandshake<S, C>
  - Description: Represents a server-side WebSocket handshake.
  - Where S: Read + Write, C: Callback

  Methods:
    pub fn start(
      stream: S,
      callback: C,
      config: Option<WebSocketConfig>,
    ) -> MidHandshake<ServerHandshake<S, C>>
      - Description: Initiates the server-side WebSocket handshake process. The `callback` allows for custom logic, such as adding additional headers based on incoming client headers.
      - Parameters:
        - stream: The underlying I/O stream that must implement `Read` and `Write` traits.
        - callback: A custom callback (`C`) that is invoked when a WebSocket client connects, enabling custom header manipulation.
        - config: An optional `WebSocketConfig` struct to specify custom WebSocket protocol settings.
      - Returns: A `MidHandshake` object representing the ongoing handshake, which can be further processed.

  Trait Implementations:
    impl Debug for ServerHandshake<S, C>
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
        - Description: Implements the `Debug` trait for `ServerHandshake`, allowing instances to be formatted for debugging purposes.
        - Parameters:
          - self: The `ServerHandshake` instance to be formatted.
          - f: The `Formatter` to use for output.
        - Returns: A `Result` indicating success (`()`) or an `Error` if formatting fails.

    impl HandshakeRole for ServerHandshake<S, C>
      - Description: Indicates that `ServerHandshake` fulfills the `HandshakeRole` trait, defining its specific role within the WebSocket handshake mechanism.

    Auto Trait Implementations:
      impl Freeze for ServerHandshake<S, C>
      impl RefUnwindSafe for ServerHandshake<S, C>
      impl Send for ServerHandshake<S, C>
      - Description: These are marker traits automatically implemented, indicating properties like immutability (`Freeze`), unwind safety (`RefUnwindSafe`), and thread-safety (`Send`) for the `ServerHandshake` struct.
```

--------------------------------

### Rust Example: Getting `OccupiedEntry` Value

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/header/struct.OccupiedEntry

Illustrates how to use the `get()` method of `OccupiedEntry` to obtain an immutable reference to the first value associated with the entry.

```Rust
let mut map = HeaderMap::new();
map.insert(HOST, "hello.world".parse().unwrap());

if let Entry::Occupied(mut e) = map.entry("host") {
    assert_eq!(e.get(), &"hello.world");

    e.append("hello.earth".parse().unwrap());

    assert_eq!(e.get(), &"hello.world");
}
```

--------------------------------

### Rust stream-tungstenite Prelude Module Structs

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/prelude/index

Documents the key structs available within the `stream_tungstenite::prelude` module, providing their names and a brief description of their purpose and optimization characteristics.

```APIDOC
EventListeners:
  - Description: A collection of event listeners for a task with optimized performance
  - Path: stream_tungstenite::prelude::EventListeners

MaybePSTSender:
  - Description: Optimized maybe sender with reduced lock contention
  - Path: stream_tungstenite::prelude::MaybePSTSender

OptPSTSender:
  - Description: Lock-free optional sender using atomic operations
  - Path: stream_tungstenite::prelude::OptPSTSender

ShareListener:
  - Description: Optimized shared listener with reduced lock contention
  - Path: stream_tungstenite::prelude::ShareListener
```

--------------------------------

### Rust Example: Getting Mutable `OccupiedEntry` Value

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/header/struct.OccupiedEntry

Shows how to use the `get_mut()` method of `OccupiedEntry` to get a mutable reference to the first value, allowing in-place modification.

```Rust
let mut map = HeaderMap::default();
map.insert(HOST, "hello.world".to_string());

if let Entry::Occupied(mut e) = map.entry("host") {
    e.get_mut().push_str("-2");
    assert_eq!(e.get(), &"hello.world-2");
}
```

--------------------------------

### Rust `HeaderValue::len` Usage Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/header/struct.HeaderValue

Shows how to get the byte length of a `HeaderValue` instance.

```Rust
let val = HeaderValue::from_static("hello");
assert_eq!(val.len(), 5);
```

--------------------------------

### Manage WebSocketContext Lifecycle and Configuration

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/struct.WebSocketContext

Provides methods for creating, configuring, and querying the state of a `WebSocketContext` instance. This context is essential for managing the underlying WebSocket stream, handling initial setup, configuration updates, and checking read/write capabilities.

```APIDOC
impl WebSocketContext:
  pub fn new(role: Role, config: Option<WebSocketConfig>) -> WebSocketContext
    - Description: Create a WebSocket context that manages a post-handshake stream.
    - Parameters:
      - role: The role of the WebSocket (e.g., client or server).
      - config: Optional configuration for the WebSocket context.
    - Returns: A new `WebSocketContext` instance.
    - Panics: If config is invalid e.g. `max_write_buffer_size <= write_buffer_size`.

  pub fn from_partially_read(part: Vec<u8>, role: Role, config: Option<WebSocketConfig>) -> WebSocketContext
    - Description: Create a WebSocket context that manages an post-handshake stream.
    - Parameters:
      - part: A partially read byte vector.
      - role: The role of the WebSocket.
      - config: Optional configuration for the WebSocket context.
    - Returns: A new `WebSocketContext` instance.
    - Panics: If config is invalid e.g. `max_write_buffer_size <= write_buffer_size`.

  pub fn set_config(&mut self, set_func: impl FnOnce(&mut WebSocketConfig))
    - Description: Change the configuration.
    - Parameters:
      - set_func: A closure that takes a mutable reference to `WebSocketConfig` to modify it.
    - Panics: If config is invalid e.g. `max_write_buffer_size <= write_buffer_size`.

  pub fn get_config(&self) -> &WebSocketConfig
    - Description: Read the configuration.
    - Returns: An immutable reference to the `WebSocketConfig`.

  pub fn can_read(&self) -> bool
    - Description: Check if it is possible to read messages. Reading is impossible after receiving `Message::Close`. It is still possible after sending close frame since the peer still may send some data before confirming close.
    - Returns: `true` if reading is possible, `false` otherwise.

  pub fn can_write(&self) -> bool
    - Description: Check if it is possible to write messages. Writing gets impossible immediately after sending or receiving `Message::Close`.
    - Returns: `true` if writing is possible, `false` otherwise.
```

--------------------------------

### Rust Example: Getting `OccupiedEntry` Key

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/header/struct.OccupiedEntry

Demonstrates how to use the `key()` method of `OccupiedEntry` to retrieve a reference to the header name.

```Rust
let mut map = HeaderMap::new();
map.insert(HOST, "world".parse().unwrap());

if let Entry::Occupied(e) = map.entry("host") {
    assert_eq!("host", e.key());
}
```

--------------------------------

### Tungstenite Client Module API Reference

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/client/index

Comprehensive API documentation for the `client` module within `stream_tungstenite::tokio_tungstenite::tungstenite`, outlining its purpose, key structs, and traits for building WebSocket client connections.

```APIDOC
Module: client
  Description: Methods to connect to a WebSocket as a client.

Structs:
  ClientRequestBuilder
    Description: Builder for a custom IntoClientRequest with options to add custom additional headers and sub protocols.

Traits:
  IntoClientRequest
    Description: Trait for converting various types into HTTP requests used for a client connection.
```

--------------------------------

### Rust Slice: Get last N elements as a chunk example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Bytes

Example usage of the `last_chunk` method, demonstrating how to retrieve the last `N` elements of a slice as a fixed-size array. It includes cases for successful retrieval, `None` return, and an empty slice.

```Rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

--------------------------------

### HTTP Response Parts Struct API Documentation

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/response/struct.Parts

Comprehensive API documentation for the `http::response::Parts` struct, detailing its public fields and the traits it implements, such as `Clone` and `Debug`. This section provides signatures and descriptions for key methods like `clone`, `clone_from`, and `fmt`, along with auto-implemented traits.

```APIDOC
Struct Parts:
  Component parts of an HTTP `Response`.
  The HTTP response head consists of a status, version, and a set of header fields.

  Fields:
    status: StatusCode
      The response’s status
    version: Version
      The response’s version
    headers: HeaderMap
      The response’s headers
    extensions: Extensions
      The response’s extensions

  Trait Implementations:
    impl Clone for Parts
      fn clone(&self) -> Parts
        Returns a duplicate of the value.
      const fn clone_from(&mut self, source: &Self)
        Performs copy-assignment from `source`.

    impl Debug for Parts
      fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
        Formats the value using the given formatter.

  Auto Trait Implementations:
    impl Freeze for Parts
    impl RefUnwindSafe for Parts
    impl Send for Parts
    impl Sync for Parts
    impl Unpin for Parts
    impl UnwindSafe for Parts
```

--------------------------------

### Rust Slice: Safely access element or subslice by index example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Bytes

Example usage of the `get` method, demonstrating safe access to slice elements and subslices using both single indices and ranges. It shows successful access and cases where `None` is returned for out-of-bounds attempts.

```Rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Initiating WebSocket Client Handshake with `ClientHandshake::start`

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.ClientHandshake

This snippet details the primary method for initiating a WebSocket client handshake using the `ClientHandshake` struct. It outlines the required parameters for the stream, HTTP request, and optional WebSocket configuration, along with the expected return type.

```APIDOC
impl<S> ClientHandshake<S> where S: Read + Write,

pub fn start(
    stream: S,
    request: Request<()>
    config: Option<WebSocketConfig>,
) -> Result<MidHandshake<ClientHandshake<S>>, Error>
  - Initiates a client handshake.
  - Parameters:
    - stream: The underlying stream, which must implement `std::io::Read` and `std::io::Write`.
    - request: The HTTP `Request` object used for the handshake.
    - config: An optional `WebSocketConfig` to customize the handshake behavior.
  - Returns: A `Result` which is `Ok(MidHandshake<ClientHandshake<S>>)` on success, or an `Error` if the handshake fails.
```

--------------------------------

### HTTP Response Struct Constructors and Builders

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/response/struct.Response

API documentation for the primary methods used to construct instances of the `http::Response` struct, including the builder pattern for flexible response creation and direct initialization.

```APIDOC
Response::builder() -> Builder
  - Creates a new builder-style object to manufacture a `Response`.
  - Example:
    let response = Response::builder()
        .status(200)
        .header("X-Custom-Foo", "Bar")
        .body(())
        .unwrap();

Response::new(body: T) -> Response<T>
  - Creates a new blank `Response` with the body.
  - The component parts of this response will be set to their default (e.g., OK status, no headers).
```

--------------------------------

### Rust `Extensions::get` Method Usage Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Extensions

Illustrates how to retrieve an immutable reference to a typed value stored within the `Extensions` struct using the `get` method.

```Rust
let mut ext = Extensions::new();
assert!(ext.get::<i32>().is_none());
ext.insert(5i32);

assert_eq!(ext.get::<i32>(), Some(&5i32));
```

--------------------------------

### Rust stream-tungstenite Prelude Module Re-exports

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/prelude/index

Lists the modules re-exported by the `stream_tungstenite::prelude` module for convenient access to commonly used items, simplifying imports for crate users.

```Rust
pub use super::config::*;
pub use super::errors::*;
pub use super::extension::*;
pub use super::handshake::*;
pub use super::metrics::*;
pub use super::strategies::*;
pub use super::tungstenite::*;
```

--------------------------------

### Example: Get Port as `u16`

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/uri/struct.Port

This Rust code snippet demonstrates how to parse an authority string and retrieve the port number as a `u16` using the `as_u16` method of the `Port` struct.

```Rust
let authority: Authority = "example.org:80".parse().unwrap();

let port = authority.port().unwrap();
assert_eq!(port.as_u16(), 80);
```

--------------------------------

### Example: Get Port as `str`

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/uri/struct.Port

This Rust code snippet illustrates how to parse an authority string and obtain the port number as a string slice (`&str`) using the `as_str` method of the `Port` struct.

```Rust
let authority: Authority = "example.org:80".parse().unwrap();

let port = authority.port().unwrap();
assert_eq!(port.as_str(), "80");
```

--------------------------------

### Rust Check String Starts With Pattern

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

This Rust example illustrates the usage of the `starts_with` method to determine if a string slice begins with a given pattern. It shows checks against both string literals and slices of characters.

```Rust
let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));
```

```Rust
let bananas = "bananas";

// Note that both of these assert successfully.
assert!(bananas.starts_with(&['b', 'a', 'n', 'a']));
assert!(bananas.starts_with(&['a', 'b', 'c', 'd']));
```

--------------------------------

### Trim characters from the start of a Rust string using `trim_start_matches`

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Illustrates how to remove leading characters from a string based on a pattern using the `trim_start_matches` method. Examples include trimming a specific character, numeric characters, and a slice of characters.

```Rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```

--------------------------------

### Example Usage of Rust HTTP Method

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/method/struct.Method

Demonstrates how to use the `http::Method` enum in Rust, including creating a `GET` method from bytes, checking for idempotency, and converting a `POST` method to a string. This showcases basic interactions with HTTP methods.

```Rust
use http::Method;

assert_eq!(Method::GET, Method::from_bytes(b"GET").unwrap());
assert!(Method::GET.is_idempotent());
assert_eq!(Method::POST.as_str(), "POST");
```

--------------------------------

### Rust HTTP Response Builder Header Usage Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/response/struct.Builder

Demonstrates various ways to interact with HTTP headers using the `Response::builder` in Rust, including adding headers, retrieving them immutably, and modifying them mutably.

```Rust
let response = Response::builder()
    .header("Content-Type", "text/html")
    .header("X-Custom-Foo", "bar")
    .header("content-length", 0)
    .body(())
    .unwrap();
```

```Rust
let res = Response::builder()
    .header("Accept", "text/html")
    .header("X-Custom-Foo", "bar");
let headers = res.headers_ref().unwrap();
assert_eq!( headers["Accept"], "text/html" );
assert_eq!( headers["X-Custom-Foo"], "bar" );
```

```Rust
let mut res = Response::builder();
{
  let headers = res.headers_mut().unwrap();
  headers.insert("Accept", HeaderValue::from_static("text/html"));
  headers.insert("X-Custom-Foo", HeaderValue::from_static("bar"));
}
let headers = res.headers_ref().unwrap();
assert_eq!( headers["Accept"], "text/html" );
assert_eq!( headers["X-Custom-Foo"], "bar" );
```

--------------------------------

### Rust Example: Splitting Bytes from the Start with split_off

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Bytes

Illustrates the `split_off` method of the `Bytes` struct, which divides a `Bytes` buffer into two parts at a specified index. The original `Bytes` retains the prefix `[0, at)`, and a new `Bytes` instance is returned containing the suffix `[at, len)`.

```Rust
use bytes::Bytes;

let mut a = Bytes::from(&b"hello world"[..]);
let b = a.split_off(5);

assert_eq!(&a[..], b"hello");
assert_eq!(&b[..], b" world");
```

--------------------------------

### Reverse Match Indices in Rust Strings

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Illustrates the `rmatch_indices` method in Rust, which finds all non-overlapping occurrences of a pattern in a string and returns them in reverse order, along with their starting indices. This method is useful when a reverse search is desired or yields different results than a forward search, as shown by the `ababa` example.

```Rust
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // only the last `aba`
```

--------------------------------

### Rust HeaderMap Entry Method for In-place Manipulation

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/header/struct.HeaderMap

Illustrates the use of the `entry` method on `HeaderMap` to get a mutable reference to an entry, allowing for in-place manipulation or insertion of default values. This example specifically shows how to count occurrences of different headers by incrementing a counter associated with each header name.

```Rust
let mut map: HeaderMap<u32> = HeaderMap::default();

let headers = &[
    "content-length",
    "x-hello",
    "Content-Length",
    "x-world",
];

for &header in headers {
    let counter = map.entry(header).or_insert(0);
    *counter += 1;
}

assert_eq!(map["content-length"], 2);
assert_eq!(map["x-hello"], 1);
```

--------------------------------

### ExtensionCapabilities Struct API Reference

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/extension/interface/struct.ExtensionCapabilities

Comprehensive API documentation for the `ExtensionCapabilities` struct, detailing its fields, methods, and all associated trait implementations within the `stream-tungstenite` Rust crate.

```APIDOC
ExtensionCapabilities Struct:
  Description: Represents the capabilities of a WebSocket extension, indicating what aspects of the connection it handles.

  Fields:
    handles_lifecycle: bool
      Indicates if the extension handles connection lifecycle events (e.g., handshake, close).
    handles_messages: bool
      Indicates if the extension handles message processing (e.g., encoding/decoding frames).

  Methods:
    new()
      Constructor for ExtensionCapabilities, typically creating a default instance with no capabilities enabled.
    with_all()
      Creates an ExtensionCapabilities instance with all known capabilities enabled.
    with_lifecycle()
      Creates an ExtensionCapabilities instance with only lifecycle handling enabled.
    with_messages()
      Creates an ExtensionCapabilities instance with only message handling enabled.

  Trait Implementations:
    Clone
      Enables cloning of ExtensionCapabilities instances.
    Debug
      Enables debug formatting for ExtensionCapabilities, useful for logging and inspection.
    Default
      Provides a default constructor for ExtensionCapabilities, typically equivalent to new().

  Auto Trait Implementations:
    Freeze
    RefUnwindSafe
    Send
    Sync
    Unpin
    UnwindSafe

  Blanket Implementations:
    Any
    Borrow<T>
    BorrowMut<T>
    CloneToUninit
    From<T>
    Instrument
    Into<U>
    Same
    ToOwned
    TryFrom<U>
    TryInto<U>
    VZip<V>
    WithSubscriber
```

--------------------------------

### Rust Example: Using http::Method for HTTP Verb Operations

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/method/index

This example demonstrates basic usage of the `http::Method` struct to create, compare, and inspect HTTP request methods. It shows how to convert byte slices to `Method` instances, check for idempotency, and retrieve the string representation of a method.

```Rust
use http::Method;

assert_eq!(Method::GET, Method::from_bytes(b"GET").unwrap());
assert!(Method::GET.is_idempotent());
assert_eq!(Method::POST.as_str(), "POST");
```

--------------------------------

### Rust Core Cloning Trait: CloneToUninit

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.ClientRequestBuilder

Documentation for the `core::clone::CloneToUninit` trait, an experimental API for performing copy-assignment to uninitialized memory.

```APIDOC
Trait: core::clone::CloneToUninit
unsafe fn clone_to_uninit(&self, dest: *mut u8)
  - Description: Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.
  - Parameters:
    - &self: The source value to clone from.
    - dest: *mut u8: The raw pointer destination to copy to.
  - Returns: None
```

--------------------------------

### Rust `rsplit_once` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples demonstrating the behavior of `rsplit_once`, which splits a string from the end at the last occurrence of the delimiter.

```Rust
assert_eq!("cfg".rsplit_once('='), None);
assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));
```

--------------------------------

### Tungstenite WebSocket Client Functions API

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/client/index

Comprehensive API documentation for the `stream_tungstenite::tokio_tungstenite::tungstenite::client` module, outlining functions for initiating WebSocket client handshakes, establishing connections in blocking mode, and determining URI modes. It includes functions for both basic and configurable operations.

```APIDOC
stream_tungstenite::tokio_tungstenite::tungstenite::client Functions:

fn client(...)
  - Description: Do the client handshake over the given stream.

fn client_with_config(...)
  - Description: Do the client handshake over the given stream given a web socket configuration. Passing `None` as configuration is equal to calling `client()` function.

fn connect(...)
  - Description: Connect to the given WebSocket in blocking mode.

fn connect_with_config(...)
  - Description: Connect to the given WebSocket in blocking mode.

fn uri_mode(...)
  - Description: Get the mode of the given URL.
```

--------------------------------

### `str::split_inclusive` Usage Examples in Rust

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Provides practical examples of `str::split_inclusive`, demonstrating its behavior when the string does or does not end with a separator.

```Rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
```

```Rust
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
```

--------------------------------

### Rust HeaderMap IntoIterator Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.HeaderMap

Demonstrates the usage of `HeaderMap::into_iter` to create a consuming iterator. The first example shows basic iteration over a map with unique keys. The second example illustrates how the iterator handles multiple values associated with the same header name, yielding `None` for subsequent header names.

```Rust
let mut map = HeaderMap::new();
map.insert(header::CONTENT_LENGTH, "123".parse().unwrap());
map.insert(header::CONTENT_TYPE, "json".parse().unwrap());

let mut iter = map.into_iter();
assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap())));
assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap())));
assert!(iter.next().is_none());
```

```Rust
let mut map = HeaderMap::new();

map.append(header::CONTENT_LENGTH, "123".parse().unwrap());
map.append(header::CONTENT_LENGTH, "456".parse().unwrap());

map.append(header::CONTENT_TYPE, "json".parse().unwrap());
map.append(header::CONTENT_TYPE, "html".parse().unwrap());
map.append(header::CONTENT_TYPE, "xml".parse().unwrap());

let mut iter = map.into_iter();

assert_eq!(iter.next(), Some((Some(header::CONTENT_LENGTH), "123".parse().unwrap())));
assert_eq!(iter.next(), Some((None, "456".parse().unwrap())));

assert_eq!(iter.next(), Some((Some(header::CONTENT_TYPE), "json".parse().unwrap())));
assert_eq!(iter.next(), Some((None, "html".parse().unwrap())));
assert_eq!(iter.next(), Some((None, "xml".parse().unwrap())));
assert!(iter.next().is_none());
```

--------------------------------

### Rust `str::eq_ignore_ascii_case` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples demonstrating the usage of Rust's `str::eq_ignore_ascii_case` method for performing case-insensitive ASCII string comparisons.

```Rust
assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));
```

--------------------------------

### Rust `split_once` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples illustrating the behavior of `split_once` when the delimiter is present or absent, and how it handles multiple occurrences of the delimiter by only splitting on the first one.

```Rust
assert_eq!("cfg".split_once('='), None);
assert_eq!("cfg=".split_once('='), Some(("cfg", "")));
assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));
```

--------------------------------

### WebSocket Protocol Core Methods (Rust Tungstenite)

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/struct.WebSocket

Comprehensive API documentation for the `WebSocket` struct's essential methods within the `stream-tungstenite` crate. This includes functions to retrieve configuration, check read/write readiness, read incoming messages, and send outgoing messages, along with details on connection closure handling.

```APIDOC
WebSocket Protocol Methods:

pub fn get_config(&self) -> &[WebSocketConfig]
  Description: Reads the configuration of the WebSocket instance.
  Parameters:
    - &self: Reference to the WebSocket instance.
  Returns:
    - &[WebSocketConfig]: A reference to the WebSocket configuration.

pub fn can_read(&self) -> bool
  Description: Checks if it is currently possible to read messages from the WebSocket.
  Notes:
    - Reading becomes impossible after receiving a `Message::Close` frame.
    - It remains possible after sending a close frame, as the peer might still send data before confirming closure.
  Parameters:
    - &self: Reference to the WebSocket instance.
  Returns:
    - bool: True if reading is possible, false otherwise.

pub fn can_write(&self) -> bool
  Description: Checks if it is currently possible to write messages to the WebSocket.
  Notes:
    - Writing becomes impossible immediately after either sending or receiving a `Message::Close` frame.
  Parameters:
    - &self: Reference to the WebSocket instance.
  Returns:
    - bool: True if writing is possible, false otherwise.

pub fn read(&mut self) -> Result<Message, Error>
  Description: Reads a single message from the underlying stream, if available.
  Notes:
    - This method also handles queuing responses to protocol messages like ping and close.
    - These queued responses will be written and flushed on the next call to `read`, `write`, or `flush`.
    - Closing the connection: When the remote endpoint initiates a close, this method will return the close message. To properly complete the close handshake, you should continue calling `read`, `write`, or `flush` until `Error::ConnectionClosed` is returned. At that point, it is safe to drop the underlying connection.
  Parameters:
    - &mut self: Mutable reference to the WebSocket instance.
  Returns:
    - Result<Message, Error>: A `Result` enum, containing the received `Message` on success, or an `Error` on failure.

pub fn send(&mut self, message: Message) -> Result<(), Error>
  Description: Writes a given message to the stream and immediately flushes it.
  Notes:
    - This method is a convenience wrapper, functionally equivalent to calling `write` followed by `flush`.
  Parameters:
    - &mut self: Mutable reference to the WebSocket instance.
    - message: Message - The message to be sent over the WebSocket connection.
  Returns:
    - Result<(), Error>: A `Result` enum, indicating success (`()`) or an `Error` if the operation fails.
```

--------------------------------

### Rust String to_ascii_lowercase Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

An example demonstrating the usage of the `to_ascii_lowercase` method in Rust, which converts only ASCII characters to lowercase while leaving non-ASCII characters unchanged.

```Rust
let s = "Grüße, Jürgen ❤";

assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
```

--------------------------------

### Creating an HTTP Request with Builder

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/request/struct.Request

Demonstrates how to construct an `http::Request` using the builder pattern, including setting URI, headers, and conditionally adding headers. It also shows a placeholder `send` function for sending the request.

```Rust
use http::{Request, Response};

let mut request = Request::builder()
    .uri("https://www.rust-lang.org/")
    .header("User-Agent", "my-awesome-agent/1.0");

if needs_awesome_header() {
    request = request.header("Awesome", "yes");
}

let response = send(request.body(()).unwrap());

fn send(req: Request<()>) -> Response<()> {
    // ...
}
```

--------------------------------

### Rust String to_ascii_uppercase Example

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

An example demonstrating the usage of the `to_ascii_uppercase` method in Rust, which converts only ASCII characters to uppercase while leaving non-ASCII characters unchanged.

```Rust
let s = "Grüße, Jürgen ❤";

assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
```

--------------------------------

### Example Usage of HTTP Method Struct

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Method

Demonstrates common operations with the `Method` struct, including creating a `Method` instance from a byte slice, comparing instances, checking if a method is idempotent, and converting a `Method` to a string slice for display or further processing.

```Rust
use http::Method;

assert_eq!(Method::GET, Method::from_bytes(b"GET").unwrap());
assert!(Method::GET.is_idempotent());
assert_eq!(Method::POST.as_str(), "POST");
```

--------------------------------

### Rust Example: Inspecting an Incoming HTTP Request

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Request

Illustrates how to process an incoming `http::Request`, check its URI, inspect headers, and access the body. Shows how to return a `404 Not Found` response based on URI.

```Rust
use http::{Request, Response, StatusCode};

fn respond_to(req: Request<()>) -> http::Result<Response<()>> {
    if req.uri() != "/awesome-url" {
        return Response::builder()
            .status(StatusCode::NOT_FOUND)
            .body(())
    }

    let has_awesome_header = req.headers().contains_key("Awesome");
    let body = req.body();

    // ...
}
```

--------------------------------

### Rust `str` Character Escaping Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Rust code examples demonstrating how to use `escape_debug`, `escape_default`, and `escape_unicode` methods to generate escaped string representations.

```Rust
for c in "❤\n!".escape_debug() {
    print!("{c}");
}
println!();
```

```Rust
println!("{}", "❤\n!".escape_debug());
```

```Rust
println!("❤\\n!");
```

```Rust
assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");
```

```Rust
for c in "❤\n!".escape_default() {
    print!("{c}");
}
println!();
```

```Rust
println!("{}", "❤\n!".escape_default());
```

```Rust
println!("\\u{{2764}}\\n!");
```

```Rust
assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");
```

```Rust
for c in "❤\n!".escape_unicode() {
    print!("{c}");
}
println!();
```

```Rust
println!("{}", "❤\n!".escape_unicode());
```

```Rust
println!("\\u{{2764}}\\u{{a}}\\u{{21}}");
```

```Rust
assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");
```

--------------------------------

### Rust `str::is_ascii` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/struct.Utf8Bytes

Examples demonstrating the usage of Rust's `str::is_ascii` method to verify if a given string contains only ASCII characters.

```Rust
let ascii = "hello!\n";
let non_ascii = "Grüße, Jürgen ❤";

assert!(ascii.is_ascii());
assert!(!non_ascii.is_ascii());
```

--------------------------------

### Initialize ReconnectOptions with Presets (Rust APIDOC)

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/config/struct.ReconnectOptions

Provides methods to create new instances of `ReconnectOptions`, including a default constructor and several preset configurations tailored for different reconnection scenarios (fast, stable, low-latency).

```APIDOC
pub fn new() -> Self
  - Creates a new ReconnectOptions instance with default values.

pub fn fast_reconnect() -> Self
  - Configures ReconnectOptions for fast reconnection scenarios.
  - Characteristics: Short initial delay (500ms), aggressive retry strategy, reduced timeout (10s).

pub fn stable_connection() -> Self
  - Configures ReconnectOptions for stable, long-term connections.
  - Characteristics: Longer initial delay (2s), conservative retry strategy, extended timeout (60s).

pub fn low_latency() -> Self
  - Configures ReconnectOptions for low-latency, high-frequency scenarios.
  - Characteristics: Very short delays, quick timeout detection, minimal backoff.
```

--------------------------------

### StatusViewer Struct Methods

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/extension/struct.StatusViewer

Documentation for the core methods of the `StatusViewer` struct, including its constructor and methods to access connection status.

```APIDOC
pub fn new() -> Self
  - Description: Creates a new instance of `StatusViewer`.

pub async fn current_status(&self) -> ConnectionStatus
  - Description: Asynchronously retrieves the current connection status.

pub fn status_handle(&self) -> Arc<Mutex<ConnectionStatus>>
  - Description: Get a shared reference to the current status.
```

--------------------------------

### Get URI Scheme as String in Rust

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/http/struct.Uri

Shows how to retrieve the URI scheme as a `&str` from a `Uri` object. This is a convenience method for getting the scheme directly as a string slice.

```Rust
let uri: Uri = "http://example.org/hello/world".parse().unwrap();

assert_eq!(uri.scheme_str(), Some("http"));
```

--------------------------------

### Rust `str` ASCII Whitespace Trimming Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Practical Rust code examples demonstrating the usage of `trim_ascii_start`, `trim_ascii_end`, and `trim_ascii` methods to remove ASCII whitespace from string slices.

```Rust
assert_eq!(" \t \u{3000}hello world\n".trim_ascii_start(), "\u{3000}hello world\n");
assert_eq!("  ".trim_ascii_start(), "");
assert_eq!("".trim_ascii_start(), "");
```

```Rust
assert_eq!("\r hello world\u{3000}\n ".trim_ascii_end(), "\r hello world\u{3000}");
assert_eq!("  ".trim_ascii_end(), "");
assert_eq!("".trim_ascii_end(), "");
```

```Rust
assert_eq!("\r hello world\n ".trim_ascii(), "hello world");
assert_eq!("  ".trim_ascii(), "");
assert_eq!("".trim_ascii(), "");
```

--------------------------------

### Rust `str::trim_start_matches` Examples

Source: https://docs.rs/stream-tungstenite/0.5.1/stream_tungstenite/tokio_tungstenite/tungstenite/protocol/frame/struct.Utf8Bytes

Illustrates the usage of `trim_start_matches` to remove leading characters from a string slice. Examples include trimming by a single character, a numeric predicate, and a slice of characters.

```Rust
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
```
Tokens:
Raw