### Example: Using #[launch] for Rocket Application (Rust)

Source: https://docs.rs/rocket/latest/rocket/fn.execute_search=u32+-%3E+bool

Provides an example of how to use the `#[rocket::launch]` attribute to start a Rocket application. This attribute simplifies the process of setting up the asynchronous runtime and launching the server, even when Rocket is part of a larger application.

```rust

#[rocket::launch]
async fn rocket() -> Rocket<impl Launcher> {
    rocket::build()
}

```

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

### Get length of Vec<T> in Rust (Example)

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/trait.Parser_search=std%3A%3Avec

A conceptual example demonstrating how to get the number of elements in a vector.

```rust
let my_vec = vec![1, 2, 3, 4, 5];
let length = my_vec.len(); // length will be 5

```

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

### Rocket FileServer: Basic Options Initialization

Source: https://docs.rs/rocket/latest/rocket/fs/struct.Options_search=std%3A%3Avec

Demonstrates the initialization of a FileServer with specific options. This example shows how to enable both index file serving and dot file access by combining `Options::Index` and `Options::DotFiles`.

```rust
use rocket::fs::FileServer;

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/files", FileServer::new("static").with_options(rocket::fs::Options::Index | rocket::fs::Options::DotFiles))
}
```

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

### Construct FileServer with Path and Options

Source: https://docs.rs/rocket/latest/rocket/fs/struct.FileServer

This example demonstrates constructing a FileServer using `FileServer::new()` with specific options (Index and DotFiles) and a custom rank.

```Rust
use rocket::fs::{FileServer, Options};

#[launch]
fn rocket() -> _ {
    let options = Options::Index | Options::DotFiles;
    rocket::build()
        .mount("/static", FileServer::from("/www/public"))
        .mount("/pub", FileServer::new("/www/public", options).rank(-1))
}
```

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

### Rocket Basic Get Route Example

Source: https://docs.rs/rocket/latest/rocket/attr.delete_search=

A fundamental example of a Rocket `GET` route. It demonstrates a simple free function decorated with `#[get("/")]` that returns a static string, illustrating the basic structure for defining a web endpoint.

```Rust
#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

```

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

### Get mutable remaining slice of Vec<u8> in Rust (Example)

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/trait.Parser_search=std%3A%3Avec

A conceptual example demonstrating how to get a mutable slice representing the remaining uninitialized portion of a byte vector.

```rust
let mut buffer: Vec<u8> = vec![0; 1024];
let initialized_len = 512;
let remaining = &mut buffer[initialized_len..];
let mutable_slice = rocket::mtls::oid::asn1_rs::nom::lib::std::vec::Vec::remaining_mut(&mut buffer);

```

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

### Rocket Configuration Example

Source: https://docs.rs/rocket/latest/rocket/struct.Rocket_search=std%3A%3Avec

Demonstrates how to create and configure a Rocket instance using a custom configuration, including setting the port, address, and temporary directory. It also shows how to modify the configuration using Figment.

```APIDOC
## Rocket Configuration Example

### Description
This example illustrates setting up a custom Rocket configuration with specific port, address, and temporary directory settings. It also demonstrates updating these configurations dynamically using Rocket's Figment API.

### Method
N/A (Configuration Setup)

### Endpoint
N/A (Configuration Setup)

### Parameters
N/A

### Request Example
```rust
use rocket::Config;
use std::net::Ipv4Addr;
use std::path::Path;

let config = Config {
    port: 7777,
    address: Ipv4Addr::new(18, 127, 0, 1).into(),
    temp_dir: "/tmp/config-example".into(),
    ..Config::debug_default()
};

// ... Rocket ignition and assertion ...

let figment = rocket.figment().clone()
    .merge((Config::PORT, 8888))
    .merge((Config::ADDRESS, "171.64.200.10"));

let rocket = rocket::custom(&config)
    .configure(figment)
    .ignite().await?;

// ... assertions ...
```

### Response
N/A (Configuration Setup)
```

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

### Get Start Bound of a Range (Rust)

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/ops/struct.Range

Returns the start bound of a `Range` for types implementing `RangeBounds`. This is applicable to `Range<&T>`.

```rust
fn start_bound(&self) -> Bound<&T>
```

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

### Example Usage

Source: https://docs.rs/rocket/latest/rocket/local/asynchronous/struct.Client

Example of creating a Client from a Rocket instance and dispatching a local POST request.

```APIDOC
### Example

The following snippet creates a `Client` from a `Rocket` instance and dispatches a local `POST /` request with a body of `Hello, world!`.

```rust
use rocket::local::asynchronous::Client;

let rocket = rocket::build();
let client = Client::tracked(rocket).await.expect("valid rocket");
let response = client.post("/")
    .body("Hello, world!")
    .dispatch()
    .await;
```
```

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

### Rust: Get Start and End Bounds of RangeInclusive

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/ops/struct.RangeInclusive_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to retrieve the start and end bounds of a `RangeInclusive` using the `start()` and `end()` methods. It also notes that these values are unspecified after iteration.

```Rust
assert_eq!((3..=5).start(), &3);
```

```Rust
assert_eq!((3..=5).end(), &5);
```

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

### Initialize FileServer with Options (Rust)

Source: https://docs.rs/rocket/latest/src/rocket/fs/server.rs_search=u32+-%3E+bool

Demonstrates initializing FileServer with specific options to control its behavior, such as disabling index file serving or dot file serving. This example shows serving files with custom options and different ranks.

```rust
# #[macro_use] extern crate rocket;
use rocket::fs::FileServer;

#[launch]
fn rocket() -> _ {
    // Example usage is missing in the provided text, this is a placeholder
    rocket::build()
}
```

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

### Getting Content-Type from LocalResponse

Source: https://docs.rs/rocket/latest/rocket/local/asynchronous/struct.LocalResponse_search=

This example demonstrates how to get the `ContentType` from a `LocalResponse`. It returns an `Option<ContentType>` because the content type might not be set or might be invalid.

```rust
use rocket::local::asynchronous::LocalResponse;

let response: LocalResponse = response;
let content_type = response.content_type();

```

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

### Route::new Example

Source: https://docs.rs/rocket/latest/rocket/route/struct.Route_search=std%3A%3Avec

An example demonstrating the usage of the `Route::new` constructor.

```APIDOC
## Route::new

### Description
Creates a new `Route` with a default rank. This is a convenient constructor for common routing scenarios.

### Method
Associated Function (`Route::new`)

### Endpoint
N/A (Constructor)

### Parameters
- **method** (`Method`): The HTTP method for the route.
- **uri** (`&str`): The URI path for the route. Must be a valid Rocket route URI.
- **handler** (`H` where `H: Handler`): The handler function for this route.

### Panics
Panics if `uri` is not a valid Rocket route URI.

### Example
```rust
use rocket::Route;
use rocket::http::Method;

// This is a rank -9 route matching requests to `GET /`
let index = Route::new(Method::Get, "/", rocket::route::dummy_handler);

assert_eq!(index.rank, -9);
assert_eq!(index.method, Method::Get);
assert_eq!(index.uri, "/");
```
```

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

### Initialization and Styling Methods

Source: https://docs.rs/rocket/latest/rocket/mtls/x509/struct.ASN1Time_search=u32+-%3E+bool

Methods for creating new `Painted` instances and applying wholesale styles.

```APIDOC
## Initialization and Styling

### new

Create a new `Painted` with a default `Style`.

#### Method

`new(self) -> Painted<Self>`

#### Constraints

`where Self: Sized`

### paint

Apply a style wholesale to `self`. Any previous style is replaced.

#### Method

`paint<S>(&self, style: S) -> Painted<&Self>`

#### Constraints

`where S: Into<Style>`
```

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

### Getting Pointers from MaybeUninit Slices

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/mem/union.MaybeUninit_search=u32+-%3E+bool

Provides examples of using `slice_as_ptr` and `slice_as_mut_ptr` to get pointers to the first element of a slice of `MaybeUninit`. These are nightly-only experimental APIs.

```rust
pub const fn slice_as_ptr<T>(this: &[MaybeUninit<T>]) -> *const T
```

```rust
pub const fn slice_as_mut_ptr<T>(this: &mut [MaybeUninit<T>]) -> *mut T
```

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

### Initialization and Styling

Source: https://docs.rs/rocket/latest/rocket/mtls/x509/ber/enum.Class_search=std%3A%3Avec

Methods for creating new `Painted` instances and applying styles.

```APIDOC
## INITIALIZATION AND STYLING

### `new(self) -> Painted<Self>`

Create a new `Painted` with a default `Style`.

### `paint<S>(&self, style: S) -> Painted<&Self>`

where S: Into<Style>

Apply a style wholesale to `self`. Any previous style is replaced.

#### Parameters

* `style` (S: Into<Style>) - The style to apply.
```

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

### Get Vec Length in Rust

Source: https://docs.rs/rocket/latest/rocket/data/struct.Capped_search=std%3A%3Avec

Provides an example of getting the number of elements in a `Vec<T>`. The `len()` method returns the current length of the vector.

```rust
impl<T> Vec<T> {
    pub fn len(&self) -> usize;
}
```

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

### BTreeMap Retrieval

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/collections/struct.BTreeMap

Provides examples for retrieving values associated with a key using `get` and `get_mut`.

```APIDOC
## GET /get/{key}

### Description
Retrieves a reference to the value corresponding to the key.

### Method
GET

### Endpoint
/get/{key}

### Parameters
#### Path Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **Option<&V>** - A reference to the value, or None if the key is not found.

#### Response Example
```json
"a"
```

## GET /get_mut/{key}

### Description
Retrieves a mutable reference to the value corresponding to the key.

### Method
GET

### Endpoint
/get_mut/{key}

### Parameters
#### Path Parameters
- **key** (Q) - Required - The key to look up.

### Response
#### Success Response (200)
- **Option<&mut V>** - A mutable reference to the value, or None if the key is not found.

#### Response Example
```json
"b"
```
```

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

### Rocket Server Launch Example (Rust)

Source: https://docs.rs/rocket/latest/rocket/struct.Rocket

Provides an example of launching the Rocket server and handling its completion, typically via graceful shutdown or manual interruption. It uses the `#[rocket::main]` macro for async main function execution.

```rust
#[rocket::main]
async fn main() {
    let result = rocket::build().launch().await;

    // this is reachable only after `Shutdown::notify()` or `Ctrl+C`.
    println!("Rocket: deorbit.");
}
```

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

### Rocket CookieJar Example: Adding and Accessing Cookies

Source: https://docs.rs/rocket/latest/src/rocket/cookies.rs_search=u32+-%3E+bool

Demonstrates how to add cookies to a `CookieJar` and access them using `get()` and `get_pending()`. `get()` retrieves cookies from the incoming request, while `get_pending()` shows modifications made within the current request lifecycle. This example highlights the difference between cookies retrieved from the request and those added during processing.

```rust
1use std::fmt;
2
3use parking_lot::Mutex;
4
5use crate::Config;
6use crate::http::private::cookie;
7
8#[doc(inline)]
9pub use self::cookie::{Cookie, SameSite, Iter};
10
11/// Collection of one or more HTTP cookies.
12///
13/// `CookieJar` allows for retrieval of cookies from an incoming request. It
14/// also tracks modifications (additions and removals) and marks them as
15/// pending.
16///
17/// # Pending
18///
19/// Changes to a `CookieJar` are _not_ visible via the normal [`get()`] and
20/// [`get_private()`] methods. This is typically the desired effect as a
21/// `CookieJar` always reflects the cookies in an incoming request. In cases
22/// where this is not desired, the [`get_pending()`] method is available, which
23/// always returns the latest changes.
24///
25/// ```rust
26/// # #[macro_use] extern crate rocket;
27/// use rocket::http::{CookieJar, Cookie};
28///
29/// #[get("/message")]
30/// fn message(jar: &CookieJar<'_>) {
31///     jar.add(("message", "hello!"));
32///     jar.add(Cookie::build(("session", "bye!")).expires(None));
33///
34///     // `get()` does not reflect changes.
35///     assert!(jar.get("session").is_none());
36///     assert_eq!(jar.get("message").map(|c| c.value()), Some("hi"));
37///
38///     // `get_pending()` does.
39///     let session_pending = jar.get_pending("session");
40///     let message_pending = jar.get_pending("message");
41///     assert_eq!(session_pending.as_ref().map(|c| c.value()), Some("bye!"));
42///     assert_eq!(message_pending.as_ref().map(|c| c.value()), Some("hello!"));
43///     # jar.remove("message");
44///     # assert_eq!(jar.get("message").map(|c| c.value()), Some("hi"));
45///     # assert!(jar.get_pending("message").is_none());
46/// }
47/// # fn main() {
48/// #     use rocket::local::blocking::Client;
49/// #     let client = Client::debug_with(routes![message]).unwrap();
50/// #     let response = client.get("/message")
51/// #         .cookie(("message", "hi"))
52/// #         .dispatch();
53/// #
54/// #     assert!(response.status().class().is_success());
55/// # }
56/// ```
57///
58/// # Usage
59///
60/// A type of `&CookieJar` can be retrieved via its `FromRequest` implementation
61/// as a request guard or via the [`Request::cookies()`] method. Individual
62/// cookies can be retrieved via the [`get()`] and [`get_private()`] methods. 
63/// Pending changes can be observed via the [`get_pending()`] method. Cookies
64/// can be added or removed via the [`add()`], [`add_private()`], [`remove()`],
65/// and [`remove_private()`] methods.
66///
67/// [`Request::cookies()`]: crate::Request::cookies()
68/// [`get()`]: #method.get
69/// [`get_private()`]: #method.get_private
70/// [`get_pending()`]: #method.get_pending
71/// [`add()`]: #method.add
72/// [`add_private()`]: #method.add_private
73/// [`remove()`]: #method.remove
74/// [`remove_private()`]: #method.remove_private
75///
76/// ## Examples
77///
78/// The following example shows `&CookieJar` being used as a request guard in a
79/// handler to retrieve the value of a "message" cookie.
80///
81/// ```rust
82/// # #[macro_use] extern crate rocket;
83/// use rocket::http::CookieJar;
84///
85/// #[get("/message")]
86/// fn message<'a>(jar: &'a CookieJar<'_>) -> Option<&'a str> {
87///     jar.get("message").map(|cookie| cookie.value())
88/// }
89/// # fn main() {  }
90/// ```
91///
92/// The following snippet shows `&CookieJar` being retrieved from a `Request` in
93/// a custom request guard implementation for `User`. A [private cookie]
94/// containing a user's ID is retrieved. If the cookie exists and the ID parses
95/// as an integer, a `User` structure is validated. Otherwise, the guard
96/// forwards.
97///
98/// [private cookie]: #method.add_private
99///
100/// ```rust
101/// # #[macro_use] extern crate rocket;
102/// # #[cfg(feature = "secrets")] { 
103/// use rocket::http::Status;
104/// use rocket::request::{self, Request, FromRequest};
105/// use rocket::outcome::IntoOutcome;
106///
107/// // In practice, we'd probably fetch the user from the database.
108/// struct User(usize);
109///
110/// #[rocket::async_trait]
111/// impl<'r> FromRequest<'r> for User {
112///     type Error = std::convert::Infallible;
113///
114///     async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
115///         request.cookies()
116///             .get_private("user_id")
117///             .and_then(|c| c.value().parse().ok())
118///             .map(|id| User(id))
119///             .or_forward(Status::Unauthorized)
120///     }
121/// }
122/// # }
123/// # fn main() { }
124/// ```
125///
126/// # Private Cookies
127///
128/// _Private_ cookies are just like regular cookies except that they are
129/// encrypted using authenticated encryption, a form of encryption which
130/// simultaneously provides confidentiality, integrity, and authenticity. This
131/// means that private cookies cannot be inspected, tampered with, or

```

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

### Initialization and Styling

Source: https://docs.rs/rocket/latest/rocket/mtls/x509/struct.X509ExtensionParser

Methods for creating and applying styles to text.

```APIDOC
## POST /websites/rs_rocket/new

### Description
Create a new `Painted` with a default `Style`.

### Method
POST

### Endpoint
/websites/rs_rocket/new

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None (Takes ownership of `Self`)

### Request Example
```json
{
  "example": "Painted::new()"
}
```

### Response
#### Success Response (200)
- **Output** (Painted<Self>) - A new `Painted` instance with a default style.

#### Response Example
```json
{
  "example": "A new Painted instance"
}
```

## POST /websites/rs_rocket/paint

### Description
Apply a style wholesale to `self`. Any previous style is replaced.

### Method
POST

### Endpoint
/websites/rs_rocket/paint

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **style** (S where S: Into<Style>) - Required - The style to apply.

### Request Example
```json
{
  "example": "painted.paint(yansi::Style::new().red().bold());"
}
```

### Response
#### Success Response (200)
- **Output** (Painted<&Self>) - The text with the applied style.

#### Response Example
```json
{
  "example": "Painted text with applied style"
}
```
```

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

### Rust: Using #[launch] or #[main] Attributes Example

Source: https://docs.rs/rocket/latest/rocket/fn.execute_search=

Demonstrates the preferred way to launch a Rocket application using the `#[launch]` or `#[main]` attributes. This example shows how to conditionally start a Rocket server in the foreground or background, or perform other actions, providing a more structured and idiomatic approach compared to manual `execute` calls.

```rust
#[rocket::main]
async fn main() {
    let rocket = rocket::build();
    if should_start_server_in_foreground {
        rocket::build().launch().await;
    } else if should_start_server_in_background {
        rocket::tokio::spawn(rocket.launch());
    } else {
        // do something else
    }
}

```

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

### Rust HashSet Get Element Example

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/collections/hash_set/struct.HashSet_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to retrieve a reference to an element in a HashSet if it exists, using the `get` method. It demonstrates successful retrieval and the case where the element is not found.

```rust
use std::collections::HashSet;

let set = HashSet::from([1, 2, 3]);
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);

```

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

### Rust: Example of Launching Rocket with `#[main]`

Source: https://docs.rs/rocket/latest/src/rocket/lib.rs

This example demonstrates the recommended way to launch a Rocket application using the `#[rocket::main]` attribute. It shows how to build a Rocket instance and handle different launch scenarios within an async `main` function.

```rust
#[rocket::main]
async fn main() {
    # let should_start_server_in_foreground = false;
    # let should_start_server_in_background = false;
    let rocket = rocket::build();
    if should_start_server_in_foreground {
        rocket::build().launch().await;
    } else if should_start_server_in_background {
        rocket::tokio::spawn(rocket.launch());
    } else {
        // do something else
    }
}
```

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

### RSplitN Iterator Example

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/slice/struct.RSplitN_search=

Demonstrates the usage of the RSplitN iterator by splitting a slice of integers. The example splits the slice at elements divisible by 3, starting from the end, and asserts the resulting subslices.

```rust
let slice = [10, 40, 30, 20, 60, 50];
let mut iter = slice.rsplitn(2, |num| *num % 3 == 0);
assert_eq!(iter.next(), Some(&[50][..]));
assert_eq!(iter.next(), Some(&[10, 40, 30, 20][..]));
assert_eq!(iter.next(), None);
```

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

### Initialization and Styling

Source: https://docs.rs/rocket/latest/rocket/enum.Build_search=

Methods for creating new painted text instances and applying wholesale styles.

```APIDOC
## POST /websites/rs_rocket/new

### Description
Creates a new `Painted` instance with a default style.

### Method
POST

### Endpoint
/websites/rs_rocket/new

### Parameters
#### Request Body
None

### Request Example
```json
{
  "example": "request body"
}
```

### Response
#### Success Response (200)
- **painted_instance** (Painted) - A new painted text instance.

#### Response Example
```json
{
  "example": "New Painted instance"
}
```

## POST /websites/rs_rocket/paint

### Description
Applies a style wholesale to the text, replacing any previous style.

### Method
POST

### Endpoint
/websites/rs_rocket/paint

### Parameters
#### Request Body
- **style** (Style) - Required - The style to apply.

### Request Example
```json
{
  "style": "Red"
}
```

### Response
#### Success Response (200)
- **painted_text** (string) - The styled text.

#### Response Example
```json
{
  "example": "Painted text with applied style"
}
```
```

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

### GET /segments

Source: https://docs.rs/rocket/latest/rocket/struct.Request_search=

Retrieves and parses all path segments starting from the nth segment.

```APIDOC
## GET /segments

### Description
Retrieves and parses into `T` all of the path segments in the request URI beginning and including the 0-indexed `n`th non-empty segment. `T` must implement `FromSegments`.

### Method
GET

### Endpoint
`/segments`

### Parameters
#### Query Parameters
- **n** (RangeFrom<usize>) - Required - The starting index for segments (e.g., `0..`).
- **T** (*Type*) - Required - The type to parse the segments into (must implement `FromSegments`).

### Request Example
```rust
// Assuming `get` is a function that returns a Request object
use std::path::PathBuf;
let request = get("/a/b/c");
let segments_0 = request.segments::<PathBuf>(0..);
```

### Response
#### Success Response (200)
- **Result<T, T::Error>** - The parsed segments or an error if parsing fails.

#### Response Example
```json
// Example for Ok(PathBuf::from("a/b/c"))
{
  "path": "a/b/c"
}
// Example for Err(_)
{
  "error": "parsing error message"
}
```
```

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

### Rust HashSet Get Element Example

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/collections/hash_set/struct.HashSet_search=

Demonstrates how to retrieve a reference to an element in a HashSet using the `get` method. It returns `Some(&T)` if the element is found and `None` otherwise. The value can be borrowed.

```rust
use std::collections::HashSet;

let set = HashSet::from([1, 2, 3]);
assert_eq!(set.get(&2), Some(&2));
assert_eq!(set.get(&4), None);
```

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

### Static File Server Example with NamedFile in Rust

Source: https://docs.rs/rocket/latest/src/rocket/fs/named_file.rs_search=

Illustrates a basic static file server using NamedFile. This example shows how to construct a file path, handle directory requests by looking for an index.html, and open the file using NamedFile.open. It returns an Option<NamedFile> from the route handler.

```rust
use rocket::get;
use std::path::{PathBuf, Path};

use rocket::fs::{NamedFile, relative};

#[get("/file/<path..>")]
pub async fn second(path: PathBuf) -> Option<NamedFile> {
    let mut path = Path::new(relative!("static")).join(path);
    if path.is_dir() {
        path.push("index.html");
    }

    NamedFile::open(path).await.ok()
}
```

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

### Initialization and Styling

Source: https://docs.rs/rocket/latest/rocket/config/struct.Config_search=

Methods for creating new painted text objects and applying styles.

```APIDOC
## Initialization and Styling

### Description
Methods for creating new painted text objects and applying styles.

### Methods

#### new
- **Description**: Creates a new `Painted` with a default `Style`. Read more.
- **Method**: (Associated function of `Painted`)
- **Endpoint**: N/A
- **Parameters**: 
  - **self** (Self) - Required - The object to create a new `Painted` from.

#### paint
- **Description**: Apply a style wholesale to `self`. Any previous style is replaced. Read more.
- **Method**: (Implicitly called on `Painted` object)
- **Endpoint**: N/A
- **Parameters**: 
  - **style** (S: Into<Style>) - Required - The style to apply.

### Request Example
```rust
// Creating a new painted object
let painted_text = Painted::new(value);

// Applying a style
let styled_text = painted_text.paint(yansi::Style::new().red().bold());
```

### Response
#### Success Response (200)
- **Painted<Self>** (Painted<Self>) - A new `Painted` object.
- **Painted<&Self>** (Painted<&Self>) - The painted text object with the applied style.

#### Response Example
```rust
// Example output showing text with a default or applied style
```
```

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

### LocalResponse: Get Body

Source: https://docs.rs/rocket/latest/rocket/local/blocking/struct.LocalResponse_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of accessing the response body of a `LocalResponse` object in Rust.

```rust
use rocket::local::blocking::LocalResponse;

let response: LocalResponse = response;
let body = response.body();
```

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

### Style Application and Initialization

Source: https://docs.rs/rocket/latest/rocket/local/asynchronous/struct.Client_search=

Methods for creating new `Painted` objects and applying styles wholesale.

```APIDOC
## Style Application and Initialization

### Description
Provides methods for initializing a new `Painted` object with default styles and for applying a style to the entire object, replacing any existing style.

### Methods
- `new()`: Creates a new `Painted` object with a default `Style`.
- `paint<S>(style: S)`: Applies a given `style` (which can be converted into a `Style`) to `self`, replacing any previous style.

### Request Body
N/A (These are method calls)

### Request Example
```rust
use yansi::Paint;

// Example for new()
let painted_text = Painted::new();

// Example for paint()
let styled_text = painted_text.paint("some style");
```

### Response
#### Success Response (200)
- `Painted<Self>`: For `new()`.
- `Painted<&Self>`: For `paint()`.

#### Response Example
N/A (This is a method call that returns a new object or modifies the existing one)
```

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

### Rust Route Definition and Example

Source: https://docs.rs/rocket/latest/src/rocket/route/route.rs_search=std%3A%3Avec

Defines the `Route` struct in Rust, used for handling HTTP requests in Rocket. It includes an example demonstrating how to create and inspect a route using the `#[get]` macro.

```rust
use std::fmt;
use std::convert::From;
use std::borrow::Cow;

use yansi::Paint;

use crate::http::{uri, Method, MediaType};
use crate::route::{Handler, RouteUri, BoxFuture};
use crate::sentinel::Sentry;

/// A request handling route.
///
/// A route consists of exactly the information in its fields. While a `Route`
/// can be instantiated directly, doing so should be a rare or nonexistent
/// event. Instead, a Rocket application should use Rocket's
/// [`#[route]`](macro@crate::route) series of attributes to generate a `Route`.
///
/// ```rust
/// # #[macro_use] extern crate rocket;
/// # use std::path::PathBuf;
/// #[get("/route/<path..>?query", rank = 2, format = "json")]
/// fn route_name(path: PathBuf) { /* handler procedure */ }
///
/// use rocket::http::{Method, MediaType};
///
/// let route = routes![route_name].remove(0);
/// assert_eq!(route.name.unwrap(), "route_name");
/// assert_eq!(route.method, Method::Get);
/// assert_eq!(route.uri, "/route/<path..>?query");
/// assert_eq!(route.rank, 2);
/// assert_eq!(route.format.unwrap(), MediaType::JSON);
/// ```
///
/// Note that the `rank` and `format` attribute parameters are optional. See
/// [`#[route]`](macro@crate::route) for details on macro usage. Note also that
/// a route's mounted _base_ becomes part of its URI; see [`RouteUri`] for
/// details.
///
/// # Routing
///
/// A request _matches_ a route _iff_:
///
///   * The route's method matches that of the incoming request.
///   * The route's format (if any) matches that of the incoming request.
///     - If route specifies a format, it only matches requests for that format.
///     - If route doesn't specify a format, it matches requests for any format.
///     - A route's `format` matches against the `Accept` header in the request
///       when the route's method [`supports_payload()`] and `Content-Type`
///       header otherwise.
///     - Non-specific `Accept` header components (`*`) match anything.
///   * All static components in the route's path match the corresponding
///     components in the same position in the incoming request.
///   * All static components in the route's query string are also in the
///     request query string, though in any position. If there is no query
///     in the route, requests with and without queries match.
///
/// Rocket routes requests to matching routes.
///
/// [`supports_payload()`]: Method::supports_payload()
///
/// # Collisions
///
/// Two routes are said to _collide_ if there exists a request that matches both
/// routes. Colliding routes present a routing ambiguity and are thus disallowed
/// by Rocket. Because routes can be constructed dynamically, collision checking
/// is done at [`ignite`](crate::Rocket::ignite()) time, after it becomes
/// statically impossible to add any more routes to an instance of `Rocket`.
///
/// Note that because query parsing is always lenient -- extra and missing query
/// parameters are allowed -- queries do not directly impact whether two routes
/// collide.
///
/// ## Resolving Collisions
///
/// Collisions are resolved through _ranking_. Routes with lower ranks have
/// higher precedence during routing than routes with higher ranks. Thus, routes
/// are attempted in ascending rank order. If a higher precedence route returns
/// an `Outcome` of `Forward`, the next highest precedence route is attempted, 
/// and so on, until a route returns `Success` or `Error`, or there are no
/// more routes to try. When all routes have been attempted, Rocket issues a
/// `404` error, handled by the appropriate [`Catcher`](crate::Catcher).
///
/// ## Default Ranking
///
/// Most collisions are automatically resolved by Rocket's _default rank_. The
/// default rank prefers static components over dynamic components in both paths
/// and queries: the _more_ static a route's path and query are, the lower its
/// rank and thus the higher its precedence.
///
/// There are three "colors" to paths and queries:
///   1. `static` - all components are static
///   2. `partial` - at least one, but not all, components are dynamic
///   3. `wild` - all components are dynamic
///
/// Static paths carry more weight than static queries. The same is true for
/// partial and wild paths. This results in the following default ranking
/// table:
///
/// | path    | query   | rank |
/// |---------|---------|------|
/// | static  | static  | -12  |
/// | static  | partial | -11  |
/// | static  | wild    | -10  |
/// | static  | none    | -9   |
/// | partial | static  | -8   |
/// | partial | partial | -7   |
/// | partial | wild    | -6   |
/// | partial | none    | -5   |
/// | wild    | static  | -4   |
/// | wild    | partial | -3   |
/// | wild    | wild    | -2   |

```

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

### Example: Consume Braced to Get Underlying UUID (Rust)

Source: https://docs.rs/rocket/latest/rocket/serde/uuid/fmt/struct.Braced_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates consuming a `Braced` instance to retrieve the original `Uuid` using the `into_uuid` method. This example verifies that the correct `Uuid` is returned.

```rust
use uuid::Uuid;

let braced = Uuid::nil().braced();
assert_eq!(braced.into_uuid(), Uuid::nil());
```

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

### Launching Rocket with Liftoff Fairing (Rust Example)

Source: https://docs.rs/rocket/latest/src/rocket/lib.rs_search=u32+-%3E+bool

This example demonstrates how to build a Rocket instance, attach a liftoff fairing that executes asynchronous code upon liftoff, and then launch the application using `rocket::execute`. The liftoff fairing includes a delay for demonstration purposes.

```rust
use rocket::fairing::AdHoc;

let rocket = rocket::build()
    .attach(AdHoc::on_liftoff("Liftoff Printer", |_| Box::pin(async move {
        println!("Stalling liftoff for a second...");
        rocket::tokio::time::sleep(std::time::Duration::from_secs(1)).await;
        println!("And we\'re off!");
    })));

ocket::execute(rocket.launch());
```

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

### OccupiedEntry Example Usage - Rust

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/collections/hash_set/struct.OccupiedEntry_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the usage of OccupiedEntry, including inserting, getting, and removing elements from a HashSet. This example utilizes the nightly-only `hash_set_entry` feature and requires the `mtls` and `std` crate features.

```rust
#![feature(hash_set_entry)]

use std::collections::hash_set::{Entry, HashSet};

let mut set = HashSet::new();
set.extend(["a", "b", "c"]);

let _entry_o = set.entry("a").insert();
assert_eq!(set.len(), 3);

// Existing key
match set.entry("a") {
    Entry::Vacant(_) => unreachable!(),
    Entry::Occupied(view) => {
        assert_eq!(view.get(), &"a");
    }
}

assert_eq!(set.len(), 3);

// Existing key (take)
match set.entry("c") {
    Entry::Vacant(_) => unreachable!(),
    Entry::Occupied(view) => {
        assert_eq!(view.remove(), "c");
    }
}
assert_eq!(set.get(&"c"), None);
assert_eq!(set.len(), 2);
```

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

### Initialization and Styling

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/slice/struct.ArrayWindows_search=

Methods for creating new painted instances and applying wholesale styles.

```APIDOC
## POST /websites/rs_rocket/new

### Description
Create a new `Painted` with a default `Style`.

### Method
POST

### Endpoint
/websites/rs_rocket/new

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "message": "Create a new painted instance"
}
```

### Response
#### Success Response (200)
- **painted_instance** (Painted<Self>) - A new painted instance with default style.

#### Response Example
```json
{
  "painted_instance": "<opaque painted object>"
}
```

## POST /websites/rs_rocket/paint

### Description
Apply a style wholesale to `self`. Any previous style is replaced.

### Method
POST

### Endpoint
/websites/rs_rocket/paint

### Parameters
#### Path Parameters
None

#### Query Parameters
- **style** (Style) - Required - The style to apply.

#### Request Body
None

### Request Example
```json
{
  "message": "Apply a specific style",
  "style": "Red"
}
```

### Response
#### Success Response (200)
- **painted_instance** (Painted<&Self>) - The painted text with the specified style applied.

#### Response Example
```json
{
  "painted_instance": "\u001b[31mtext\u001b[39m"
}
```
```

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

### Basic Rocket Application Example

Source: https://docs.rs/rocket/latest/index

Demonstrates a minimal Rocket application in Rust. It includes setting up a basic 'hello world' route and launching the Rocket server.

```rust
#[macro_use] extern crate rocket;

#[get("/")]
fn hello() -> &'static str {
    "Hello, world!"
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![hello])
}

```

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

### oct_digit0 Example Usage

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/character/streaming/fn.oct_digit0_search=

Demonstrates the usage of the `oct_digit0` function with different input strings. The examples show successful parsing of octal digits and the expected behavior when the input is incomplete or starts with a non-octal character.

```rust
assert_eq!(oct_digit0::<_, (_, ErrorKind)>("21cZ"), Ok(("cZ", "21")));
assert_eq!(oct_digit0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));
assert_eq!(oct_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

```

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

### Getting String Length in Rust

Source: https://docs.rs/rocket/latest/rocket/form/name/struct.Name_search=u32+-%3E+bool

Provides examples of how to get the length of a string in bytes using the `.len()` method in Rust. This is a standard string operation inherited via `Deref<Target = str>`.

```rust
let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);

```

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

### Rocket FileServer Options Bitwise OR Example

Source: https://docs.rs/rocket/latest/rocket/fs/struct.Options

Demonstrates combining multiple FileServer options using the bitwise OR operator in Rocket. This example shows how to enable both the Index and DotFiles features simultaneously.

```rust
use rocket::fs::Options;

let combined_options = Options::Index | Options::DotFiles;

```

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

### Example: Create HashSet Intersection (Rust)

Source: https://docs.rs/rocket/latest/rocket/mtls/oid/asn1_rs/nom/lib/std/collections/hash_set/struct.Intersection_search=u32+-%3E+bool

Demonstrates how to create an `Intersection` iterator by calling the `intersection` method on a `HashSet`. This example shows the basic setup for finding common elements between two sets.

```rust
use std::collections::HashSet;

let a = HashSet::from([1, 2, 3]);
let b = HashSet::from([4, 2, 3, 4]);

let mut intersection = a.intersection(&b);

```

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

### Rocket Launch with State Management Example

Source: https://docs.rs/rocket/latest/rocket/trait.Sentinel_search=u32+-%3E+bool

Demonstrates how to manage state within a Rocket application and how the State sentinel prevents launch if the specified state is not managed. This example shows the correction by adding `.manage()`.

```rust
#[get("/<id>")]
fn index(id: usize, state: &State<String>) -> Response {
    /* ... */
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![index])
        .manage(String::from("my managed string"))
}
```

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

### Rocket CookieJar: Add, Get, and Pending Cookies Example

Source: https://docs.rs/rocket/latest/src/rocket/cookies.rs_search=

Demonstrates how to use `CookieJar` to add cookies, retrieve them using `get()`, and access pending changes with `get_pending()`. It highlights that `get()` reflects the initial request cookies, while `get_pending()` shows modifications made within the same request lifecycle.

```rust
1use std::fmt;
2
3use parking_lot::Mutex;
4
5use crate::Config;
6use crate::http::private::cookie;
7
8#[doc(inline)]
9pub use self::cookie::{Cookie, SameSite, Iter};
10
11/// Collection of one or more HTTP cookies.
12///
13/// `CookieJar` allows for retrieval of cookies from an incoming request. It
14/// also tracks modifications (additions and removals) and marks them as
15/// pending.
16///
17/// # Pending
18///
19/// Changes to a `CookieJar` are _not_ visible via the normal [`get()`] and
20/// [`get_private()`] methods. This is typically the desired effect as a
21/// `CookieJar` always reflects the cookies in an incoming request. In cases
22/// where this is not desired, the [`get_pending()`] method is available, which
23/// always returns the latest changes.
24///
25/// ```rust
26/// # #[macro_use] extern crate rocket;
27/// use rocket::http::{CookieJar, Cookie};
28///
29/// #[get("/message")]
30/// fn message(jar: &CookieJar<'_>) {
31///     jar.add(("message", "hello!"));
32///     jar.add(Cookie::build(("session", "bye!")).expires(None));
33///
34///     // `get()` does not reflect changes.
35///     assert!(jar.get("session").is_none());
36///     assert_eq!(jar.get("message").map(|c| c.value()), Some("hi"));
37///
38///     // `get_pending()` does.
39///     let session_pending = jar.get_pending("session");
40///     let message_pending = jar.get_pending("message");
41///     assert_eq!(session_pending.as_ref().map(|c| c.value()), Some("bye!"));
42///     assert_eq!(message_pending.as_ref().map(|c| c.value()), Some("hello!"));
43///     # jar.remove("message");
44///     # assert_eq!(jar.get("message").map(|c| c.value()), Some("hi"));
45///     # assert!(jar.get_pending("message").is_none());
46/// }
47/// # fn main() {
48/// #     use rocket::local::blocking::Client;
49/// #     let client = Client::debug_with(routes![message]).unwrap();
50/// #     let response = client.get("/message")
51/// #         .cookie(("message", "hi"))
52/// #         .dispatch();
53/// #
54/// #     assert!(response.status().class().is_success());
55/// # }
56/// ```
57///
58/// # Usage
59///
60/// A type of `&CookieJar` can be retrieved via its `FromRequest` implementation
61/// as a request guard or via the [`Request::cookies()`] method. Individual
62/// cookies can be retrieved via the [`get()`] and [`get_private()`] methods. 
63/// Pending changes can be observed via the [`get_pending()`] method. Cookies
64/// can be added or removed via the [`add()`], [`add_private()`], [`remove()`],
65/// and [`remove_private()`] methods.
66///
67/// [`Request::cookies()`]: crate::Request::cookies()
68/// [`get()`]: #method.get
69/// [`get_private()`]: #method.get_private
70/// [`get_pending()`]: #method.get_pending
71/// [`add()`]: #method.add
72/// [`add_private()`]: #method.add_private
73/// [`remove()`]: #method.remove
74/// [`remove_private()`]: #method.remove_private
75///
76/// ## Examples
77///
78/// The following example shows `&CookieJar` being used as a request guard in a
79/// handler to retrieve the value of a "message" cookie.
80///
81/// ```rust
82/// # #[macro_use] extern crate rocket;
83/// use rocket::http::CookieJar;
84///
85/// #[get("/message")]
86/// fn message<'a>(jar: &'a CookieJar<'_>) -> Option<&'a str> {
87///     jar.get("message").map(|cookie| cookie.value())
88/// }
89/// # fn main() {  }
90/// ```
91///
92/// The following snippet shows `&CookieJar` being retrieved from a `Request` in
93/// a custom request guard implementation for `User`. A [private cookie] 
94/// containing a user's ID is retrieved. If the cookie exists and the ID parses
95/// as an integer, a `User` structure is validated. Otherwise, the guard
96/// forwards.
97///
98/// [private cookie]: #method.add_private
99///
100/// ```rust
101/// # #[macro_use] extern crate rocket;
102/// # #[cfg(feature = "secrets")] { 
103/// use rocket::http::Status;
104/// use rocket::request::{self, Request, FromRequest};
105/// use rocket::outcome::IntoOutcome;
106///
107/// // In practice, we'd probably fetch the user from the database.
108/// struct User(usize);
109///
110/// #[rocket::async_trait]
111/// impl<'r> FromRequest<'r> for User {
112///     type Error = std::convert::Infallible;
113///
114///     async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
115///         request.cookies()
116///             .get_private("user_id")
117///             .and_then(|c| c.value().parse().ok())
118///             .map(|id| User(id))
119///             .or_forward(Status::Unauthorized)
120///     }
121/// }
122/// # } 
123/// # fn main() { }
124/// ```
125///
126/// # Private Cookies
127///
128/// _Private_ cookies are just like regular cookies except that they are
129/// encrypted using authenticated encryption, a form of encryption which
130/// simultaneously provides confidentiality, integrity, and authenticity. This
131/// means that private cookies cannot be inspected, tampered with, or

```

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

### Rocket FileServer IndexFile Option Example

Source: https://docs.rs/rocket/latest/rocket/fs/struct.Options

Shows how to use the Options::IndexFile flag with Rocket's FileServer to serve a single file as the root of a mount path, instead of requiring the mount path to be a directory.

```rust
use rocket::fs::{FileServer, Options};

// Serve 'static/cat.jpeg' at the '/cat' path.
#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/cat", FileServer::new("static/cat.jpeg", Options::IndexFile))
}

```