Iocaine

https://docs.rs/iocaine/3.0.1/iocaine/
Admin
Iocaine is a Rust crate providing a comprehensive set of utilities and components for building...
Tokens:73,739
Snippets:1,483
Trust Score:9.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Serve with CheckpointCharlie

Source: https://docs.rs/iocaine/3.0.1/iocaine/checkpoint_charlie/struct

Starts a server using the CheckpointCharlie instance, listening on the provided Listener. This is an asynchronous operation.

```Rust
pub async fn serve(&self, listener: Listener) -> Result<()>
```

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

### Create a New Painted Instance

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/struct

Creates a new `Painted` instance with a default `Style`. This is the starting point for applying styles to text.

```rust
let painted = Painted::new();
```

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

### Rust: Example of setting foreground color

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/fake_moustache/struct

Demonstrates how to set the foreground color to white using both the `fg()` method and the `white()` shorthand.

```Rust
use yansi::{Paint, Color};

painted.fg(Color::White);

painted.white();
```

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

### Rust Paint Trait color Methods Examples

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/freezer/struct

Provides examples of using specific color methods (primary, fixed, rgb, black, red, green, yellow, blue, magenta) from the `yansi::Paint` trait in Rust to style text. These methods offer a concise way to apply predefined colors.

```rust
println!("{}", value.primary());
```

```rust
println!("{}", value.fixed(color));
```

```rust
println!("{}", value.rgb(r, g, b));
```

```rust
println!("{}", value.black());
```

```rust
println!("{}", value.red());
```

```rust
println!("{}", value.green());
```

```rust
println!("{}", value.yellow());
```

```rust
println!("{}", value.blue());
```

```rust
println!("{}", value.magenta());
```

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

### Set Background Color to Red using on_red()

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Demonstrates setting the background color to red using the `on_red()` method, which is preferred over the generic `bg()` method for specific color settings due to its conciseness. This example requires the `yansi::Paint` import.

```rust
use yansi::Paint;

painted.on_red();
```

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

### Basic Paint Usage - Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/struct

Demonstrates how to use the `Paint` trait to apply foreground colors to text. This includes examples for setting primary, fixed, RGB, and named colors.

```rust
use yansi::{Paint, Color};

painted.fg(Color::White);

println!("{}", value.primary());

println!("{}", value.fixed(color));

println!("{}", value.rgb(r, g, b));

println!("{}", value.black());

println!("{}", value.red());
```

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

### Create a new 'Painted' object

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/struct

Creates a new `Painted` object with a default `Style`. This is the starting point for applying styles to text.

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

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

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

### Creating a New Painted Instance in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Shows how to create a new `Painted` instance with a default `Style` using the `new()` constructor. This is the starting point for applying various text styles and manipulations. Requires `Self` to be `Sized`.

```rust
let painted_text = Painted::new();
```

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

### Create New Painted Object

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/struct

Creates a new `Painted` object with a default `Style`. This is a fundamental method for starting to style text with the yansi crate.

```rust
let painted_text = Painted::new(text_to_style);
```

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

### Rust Arc Strong Count Example

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Illustrates how to get the number of strong references to an Arc. This is useful for debugging and understanding shared ownership. The example shows creating an Arc, cloning it, and asserting the strong count.

```Rust
use std::sync::Arc;

let five = Arc::new(5);
let _also_five = Arc::clone(&five);

// This assertion is deterministic because we haven't shared
// the `Arc` between threads.
assert_eq!(2, Arc::strong_count(&five));
```

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

### Rust Arc Downgrade Example

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Demonstrates how to create a weak reference from an Arc. This is useful for breaking reference cycles. The example shows creating an Arc, downgrading it to a Weak pointer, and asserting the weak count.

```Rust
use std::sync::Arc;

let five = Arc::new(5);
let _weak_five = Arc::downgrade(&five);

// This assertion is deterministic because we haven't shared
// the `Arc` or `Weak` between threads.
assert_eq!(1, Arc::weak_count(&five));
```

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

### Zeroed Arc Construction with Allocator (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Demonstrates creating an Arc with memory initialized to zero bytes using a custom allocator. The example shows assuming initialization after creation.

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

use std::sync::Arc;
use std::alloc::System;

let zero = Arc::<u32, _>::new_zeroed_in(System);
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)
```

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

### Create New Painted Instance with Default Style

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/freezer/enum

Creates a new `Painted` instance with a default `Style`. This is a constructor function for the `Painted` type, ensuring a starting point for styling operations.

```rust
let painted_instance = Painted::new();
```

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

### Rust Paint Trait fg() Method Example

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/freezer/struct

Demonstrates how to set the foreground color of a painted string using the `fg()` method from the `yansi::Paint` trait in Rust. This allows for custom text styling.

```rust
use yansi::{Paint, Color};

painted.fg(Color::White);
```

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

### Pointer Initialization and Dereferencing

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/freezer/enum

Provides unsafe methods for managing raw pointers. Includes initialization with a given initializer, dereferencing to get immutable references, mutable dereferencing, and dropping the pointed-to object.

```rust
unsafe {
    let ptr = Pointable::init(initializer);
    let value: &T = Pointable::deref(ptr);
    let mut_value: &mut T = Pointable::deref_mut(ptr);
    Pointable::drop(ptr);
}
```

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

### Applying Background Colors to Text in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/struct

Provides examples for setting various background colors for text in Rust. Functions like `on_black`, `on_red`, `on_green`, etc., are used to apply specific named colors to the text's background.

```rust
println!("{}", value.on_black());
```

```rust
println!("{}", value.on_red());
```

```rust
println!("{}", value.on_green());
```

```rust
println!("{}", value.on_yellow());
```

```rust
println!("{}", value.on_blue());
```

```rust
println!("{}", value.on_magenta());
```

```rust
println!("{}", value.on_cyan());
```

```rust
println!("{}", value.on_white());
```

```rust
println!("{}", value.on_bright_black());
```

```rust
println!("{}", value.on_bright_red());
```

```rust
println!("{}", value.on_bright_green());
```

```rust
println!("{}", value.on_bright_yellow());
```

```rust
println!("{}", value.on_bright_blue());
```

```rust
println!("{}", value.on_bright_magenta());
```

```rust
println!("{}", value.on_bright_cyan());
```

```rust
println!("{}", value.on_bright_white());
```

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

### Set Background Color to Basic Colors using yansi in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/enum

Provides examples for setting background colors to basic terminal colors like Black, Red, Green, Yellow, Blue, Magenta, Cyan, and White using specific `on_color()` methods from the `yansi` crate.

```Rust
println!("{}", value.on_black());
```

```Rust
println!("{}", value.on_red());
```

```Rust
println!("{}", value.on_green());
```

```Rust
println!("{}", value.on_yellow());
```

```Rust
println!("{}", value.on_blue());
```

```Rust
println!("{}", value.on_magenta());
```

```Rust
println!("{}", value.on_cyan());
```

```Rust
println!("{}", value.on_white());
```

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

### Rust Arc Make Mut Example (Clone-on-Write)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Shows how to obtain a mutable reference to the data inside an Arc using `make_mut`. If there are other strong references, the data is cloned to ensure unique ownership. If only weak references exist, they are dissociated. This is a form of clone-on-write.

```Rust
use std::sync::Arc;

// Assuming Arc<T, A> is imported and T: CloneToUninit, A: Allocator + Clone
// Example usage would require a concrete type and allocator.
// let mut my_arc = Arc::new(vec![1, 2, 3]);
// let mutable_data = Arc::make_mut(&mut my_arc);
// mutable_data.push(4);
// assert_eq!(my_arc.len(), 4);
// This snippet is illustrative and requires a full context for compilation.
```

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

### WurstsalatGeneratorPro Constructor and Learning (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/wurstsalat_generator_pro/struct

Provides methods for creating a new WurstsalatGeneratorPro instance and for learning from a list of files. The `learn_from_files` method returns a Result, indicating potential errors during the learning process.

```rust
pub fn new() -> Self

pub fn learn_from_files<S: AsRef<str>>(files: &[S]) -> Result<Self, Error>
```

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

### Style Application and Creation

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/fake_moustache/struct

Methods for creating new styled text objects and applying wholesale styles.

```APIDOC
## Style Application and Creation

Methods for creating new styled text objects and applying wholesale styles.

### `new()`

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

### `paint<S>(style: S)`

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

- **style** (S): A type that can be converted into a `Style`.
```

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

### Initialize Arc with Zeroed Data (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Shows how to create an Arc with memory initialized to zero bytes using `try_new_zeroed_in`. This method requires the `allocator_api` feature and uses the `System` allocator. The `assume_init` method is then called to get the initialized value.

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

use std::sync::Arc;
use std::alloc::System;

let zero = Arc::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

```

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

### Set Background Color with Fixed or RGB Values (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

These functions provide the means to set the background color using either a fixed u8 value or specific RGB components. They operate on a `Painted` object reference and return a new `Painted` object with the adjusted background color. Examples demonstrate practical application.

```Rust
println!("{}", value.on_fixed(color));
```

```Rust
println!("{}", value.on_rgb(r, g, b));
```

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

### Pointable Trait Implementation in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/struct

The `Pointable` trait provides methods for managing raw pointers. It includes functionalities for getting the alignment of a pointer, initializing an object from an initializer, dereferencing a pointer to get a reference, mutably dereferencing a pointer, and dropping the object pointed to by a pointer. This trait is generic over the type `T` that can be pointed to.

```Rust
impl<T> Pointable for T
Source§
#### const ALIGN: usize
The alignment of pointer.
Source§
#### type Init = T
The type for initializers.
Source§
#### unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
Source§
#### unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
Source§
#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
Source§
#### unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
Source§
```

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

### Set Foreground Color with Fixed or RGB Values (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

These functions allow setting the foreground color using either a fixed u8 value or specific RGB components. They take a reference to a `Painted` object and return a new `Painted` object with the specified foreground color. Examples show how to apply these colors.

```Rust
println!("{}", value.fixed(color));
```

```Rust
println!("{}", value.rgb(r, g, b));
```

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

### Create New Painted Text

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/qr_journey/struct

Creates a new `Painted` text object with a default style. This is the entry point for applying styles to text.

```rust
fn new(self) -> Painted<Self>
where
    Self: Sized,
{
```

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

### Conditional Styling with .whenever() in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/enum

Demonstrates conditional styling of strings based on a `Condition`. The `.whenever()` method allows applying styles only when a specified condition is met, replacing any prior condition. An example shows styling only when both stdout and stderr are TTYs.

```rust
use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
```

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

### Set Background Color with Named Colors (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

These functions enable setting the background color of text using predefined named colors. They accept a reference to a `Painted` object and return a modified `Painted` object with the specified background color. Examples illustrate their usage.

```Rust
println!("{}", value.on_primary());
```

```Rust
println!("{}", value.on_black());
```

```Rust
println!("{}", value.on_red());
```

```Rust
println!("{}", value.on_green());
```

```Rust
println!("{}", value.on_yellow());
```

```Rust
println!("{}", value.on_blue());
```

```Rust
println!("{}", value.on_magenta());
```

```Rust
println!("{}", value.on_cyan());
```

```Rust
println!("{}", value.on_white());
```

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

### TryFrom and TryInto Traits

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Documentation for the `TryFrom` and `TryInto` traits, enabling fallible type conversions.

```APIDOC
## TryFrom and TryInto Traits

### Description
Enable fallible conversions between types.

### `TryFrom<U>` Trait

#### Associated Types

- **`Error`** (`Infallible`): The type returned in the event of a conversion error.

#### Methods

- **`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`**
  Performs the conversion.

### `TryInto<U>` Trait

#### Associated Types

- **`Error`** (`<U as TryFrom<T>>::Error`): The type returned in the event of a conversion error.

#### Methods

- **`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`**
  Performs the conversion.
```

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

### Get Archived Metadata

Source: https://docs.rs/iocaine/3.0.1/iocaine/checkpoint_charlie/struct

Implements the ArchivePointee trait for type T. Defines the associated type ArchivedMetadata and a method to convert archived metadata.

```Rust
type ArchivedMetadata = ();

fn pointer_metadata(
    _: &<T as ArchivePointee>::ArchivedMetadata,
) -> <T as Pointee>::Metadata
```

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

### Create CheckpointCharlie Instance

Source: https://docs.rs/iocaine/3.0.1/iocaine/checkpoint_charlie/struct

Constructs a new CheckpointCharlie instance. It requires parameters for language, compiler path, initial seed, metrics, and an optional configuration.

```Rust
pub fn new<P: AsRef<Path>, C: AsRef<Path>, S: Serialize>(
    language: Language,
    compiler: Option<C>,
    path: &Option<P>,
    initial_seed: &str,
    metrics: &TenXProgrammer,
    config: Option<S>,
) -> Result<Self>
```

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

### Instantiate TenXProgrammer (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

Provides a constructor function `new` for creating a `TenXProgrammer` instance. It requires a path for persistence and an interval for how often to persist metrics.

```rust
pub fn new(
    persist_path: &Option<PathBuf>,
    persist_interval: Duration,
) -> Result<Self>
```

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

### VZip Trait

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Documentation for the `VZip` trait, for zipping multiple lanes of data.

```APIDOC
## VZip Trait

### Description
Provides functionality for zipping multiple lanes of data.

### Methods

#### `fn vzip(self) -> V`
Zips the lanes of the type.
```

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

### Create yansi::Paint with Default Style

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/wurstsalat_generator_pro/struct

Constructs a new `Painted` object with a default style. This is the entry point for applying styles to text using the yansi crate.

```rust
// Assuming 'T' is a type that can be converted into a Painted object
// let painted_object = T::new();
```

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

### Get Underlying Allocator from Arc (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Returns a reference to the allocator used by the `Arc`. This is an experimental nightly-only feature related to allocator APIs. It's an associated function, called as `Arc::allocator(&a)`.

```rust
#![feature(allocator_api)]
use std::sync::Arc;

// Assuming Arc is created with a specific allocator
// let my_arc = Arc::new_in(value, MyAllocator);
// let allocator_ref = Arc::allocator(&my_arc);
```

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

### Apply Style with paint() - Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/fake_moustache/struct

Illustrates applying a style wholesale to a `Painted` object using the `.paint()` method. This method replaces any previous style and requires the style parameter to be convertible into a `Style`.

```rust
painted.paint(style)
```

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

### Dereferencing a Pointer in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Shows how to safely dereference a raw pointer to get a reference to the object it points to, using the `deref` function from the `Pointable` trait. This is an unsafe operation and requires the pointer to be valid.

```rust
let reference: &T = unsafe { T::deref(ptr) };
```

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

### Yansi Paint API

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/gobbledygook/struct

Provides methods for styling text with foreground and background colors.

```APIDOC
## Paint API

### Description
Methods for applying foreground and background colors to text.

### Methods

#### `fg(&self, value: Color) -> Painted<&T>`

Returns a styled value derived from `self` with the foreground set to `value`. Prefer color-specific builder methods like `red()` and `green()`.

##### Example
```rust
use yansi::{Paint, Color};

painted.fg(Color::White);
painted.white();
```

#### `bg(&self, value: Color) -> Painted<&T>`

Returns a styled value derived from `self` with the background set to `value`. Prefer color-specific builder methods like `on_red()` and `on_green()`.

##### Example
```rust
use yansi::{Paint, Color};

painted.bg(Color::Red);
painted.on_red();
```

#### `primary(&self) -> Painted<&T>`

Sets the foreground color to `Color::Primary`.

##### Example
```rust
println!("{}", value.primary());
```

#### `fixed(&self, color: u8) -> Painted<&T>`

Sets the foreground color to `Color::Fixed`.

##### Example
```rust
println!("{}", value.fixed(color));
```

#### `rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>`

Sets the foreground color to `Color::Rgb`.

##### Example
```rust
println!("{}", value.rgb(r, g, b));
```

#### `black(&self) -> Painted<&T>`

Sets the foreground color to `Color::Black`.

##### Example
```rust
println!("{}", value.black());
```

#### `red(&self) -> Painted<&T>`

Sets the foreground color to `Color::Red`.

##### Example
```rust
println!("{}", value.red());
```

#### `green(&self) -> Painted<&T>`

Sets the foreground color to `Color::Green`.

##### Example
```rust
println!("{}", value.green());
```

#### `yellow(&self) -> Painted<&T>`

Sets the foreground color to `Color::Yellow`.

##### Example
```rust
println!("{}", value.yellow());
```

#### `blue(&self) -> Painted<&T>`

Sets the foreground color to `Color::Blue`.

##### Example
```rust
println!("{}", value.blue());
```

#### `magenta(&self) -> Painted<&T>`

Sets the foreground color to `Color::Magenta`.

##### Example
```rust
println!("{}", value.magenta());
```

#### `cyan(&self) -> Painted<&T>`

Sets the foreground color to `Color::Cyan`.

##### Example
```rust
println!("{}", value.cyan());
```

#### `white(&self) -> Painted<&T>`

Sets the foreground color to `Color::White`.

##### Example
```rust
println!("{}", value.white());
```

#### `bright_black(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightBlack`.

##### Example
```rust
println!("{}", value.bright_black());
```

#### `bright_red(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightRed`.

##### Example
```rust
println!("{}", value.bright_red());
```

#### `bright_green(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightGreen`.

##### Example
```rust
println!("{}", value.bright_green());
```

#### `bright_yellow(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightYellow`.

##### Example
```rust
println!("{}", value.bright_yellow());
```

#### `bright_blue(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightBlue`.

##### Example
```rust
println!("{}", value.bright_blue());
```

#### `bright_magenta(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightMagenta`.

##### Example
```rust
println!("{}", value.bright_magenta());
```

#### `bright_cyan(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightCyan`.

##### Example
```rust
println!("{}", value.bright_cyan());
```

#### `bright_white(&self) -> Painted<&T>`

Sets the foreground color to `Color::BrightWhite`.

##### Example
```rust
println!("{}", value.bright_white());
```

#### `on_primary(&self) -> Painted<&T>`

Sets the background color to `Color::Primary`.

##### Example
```rust
println!("{}", value.on_primary());
```

#### `on_fixed(&self, color: u8) -> Painted<&T>`

Sets the background color to `Color::Fixed`.

##### Example
```rust
println!("{}", value.on_fixed(color));
```
```

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

### TenXProgrammer Struct

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

Documentation for the TenXProgrammer struct, including its fields and available methods.

```APIDOC
## Struct TenXProgrammer

### Description
Represents a TenXProgrammer with a metric registry, an optional persistence path, and a persistence interval.

### Fields
* **registry** (`MetricRegistry`): The metric registry.
* **persist_path** (`Option<PathBuf>`): An optional path for persisting metrics.
* **persist_interval** (`Duration`): The interval for persisting metrics.

### Methods
* **new(persist_path: &Option<PathBuf>, persist_interval: Duration) -> Result<Self>**
  Creates a new TenXProgrammer instance.
* **persist(&self) -> Result<()>**
  Persists the current metrics.
* **load_metrics(&self) -> Result<PersistedMetrics>**
  Loads metrics from the persistence path.
* **abort(&self)**
  Aborts the TenXProgrammer.
* **serve(self, listener: Listener) -> Result<()>**
  Starts serving metrics via a listener asynchronously.

### Trait Implementations
* **Clone**
  * `clone(&self) -> TenXProgrammer`: Returns a duplicate of the value.
  * `clone_from(&mut self, source: &Self)`: Performs copy-assignment from `source`.
* **Default**
  * `default() -> TenXProgrammer`: Returns the default value for the type.
* **From<TenXProgrammer> for ServerVariant**
  * `from(txp: TenXProgrammer) -> Self`: Converts to `ServerVariant` from `TenXProgrammer`.

### Auto Trait Implementations
* `Freeze`
* `!RefUnwindSafe`
* `Send`
* `Sync`
* `Unpin`
* `!UnwindSafe`

### Blanket Implementations
* **Any**
  * `type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.
* **ArchivePointee**
  * `ArchivedMetadata` (type alias for `()`)
  * `pointer_metadata(_: &<Self as ArchivePointee>::ArchivedMetadata) -> <Self as Pointee>::Metadata`: Converts archived metadata to pointer metadata.
* **Borrow<T>**
  * `borrow(&self) -> &T`: Immutably borrows from an owned value.
* **BorrowMut<T>**
  * `borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.
* **CloneToUninit** (experimental, nightly-only)
  * `clone_to_uninit(&self, dest: *mut u8)`: Performs copy-assignment from `self` to `dest`.
* **Deserialize<With<T, W>, D>**
  * `deserialize(&self, deserializer: &mut D) -> Result<With<T, W>, <D as Fallible>::Error>`: Deserializes using the given deserializer.
* **From<T>**
  * `from(t: T) -> T`: Returns the argument unchanged.
* **FromRef<T>**
  * `from_ref(input: &T) -> T`: Converts to this type from a reference to the input type.
* **Instrument**
  * `instrument(self, span: Span) -> Instrumented<Self>`: Instruments this type with the provided `Span`.
  * `in_current_span(self) -> Instrumented<Self>`: Instruments this type with the current `Span`.
* **Into<U>**
  * `into(self) -> U`: Calls `U::from(self)`.
* **IntoEither**
  * `into_either(self, into_left: bool) -> Either<Self, Self>`: Converts `self` into a `Left` or `Right` variant of `Either`.
  * `into_either_with<F>(self, into_left: F) -> Either<Self, Self>`: Converts `self` based on a closure's return value.
* **Paint**
  * `fg(&self, value: Color) -> Painted<&Self>`: Returns a styled value with the foreground set to `value`.
```

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

### Get Weak Reference Count from Arc (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Retrieves the number of `Weak` pointers currently pointing to the `Arc`'s allocation. This method is safe on its own, but the returned count can be immediately outdated by other threads, requiring careful handling.

```rust
use std::sync::Arc;

// let weak_count = Arc::weak_count(&my_arc);
```

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

### Re-exporting QRJourney from iocaine

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/index

This snippet demonstrates how the `QRJourney` type from the `qr_journey` crate is made publicly available through the iocaine crate. This re-export simplifies the usage of `QRJourney` for iocaine users.

```rust
pub use qr_journey::QRJourney;
```

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

### Get Raw Pointer to Arc Data (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Provides a raw pointer to the data managed by the `Arc` without consuming the `Arc`. The pointer remains valid as long as strong references exist. The reference count is not affected.

```rust
use std::sync::Arc;

let x = Arc::new("hello".to_owned());
let y = Arc::clone(&x);
let x_ptr = Arc::as_ptr(&x);
assert_eq!(x_ptr, Arc::as_ptr(&y));
assert_eq!(unsafe { &*x_ptr }, "hello");
```

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

### Applying Style Wholesale with .paint() in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/enum

Illustrates applying a style to an entire `Painted` object using the `.paint()` method. This method replaces any existing style. The input style `S` must be convertible into `Style`.

```rust
let styled_text = painted.paint(style);
```

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

### Enable Wrapping with .quirk() in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/enum

Demonstrates how to enable text wrapping for styled output using the `.quirk(Quirk::Wrap)` method. This requires importing `Paint` and `Quirk` from the `yansi` crate.

```rust
use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);
```

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

### Implement yansi::Paint for StringList in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/struct

Demonstrates using the yansi crate's Paint trait with StringList, showing how to set foreground colors using `fg()` and specific color methods like `primary()`.

```rust
impl Paint for T
where T: ?Sized,

fn fg(&self, value: Color) -> Painted<&T>

fn primary(&self) -> Painted<&T>

// Example usage:
// use yansi::{Paint, Color};
// painted.fg(Color::White);
// painted.white();

```

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

### Clearing Styles with .clear() (Deprecated) in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/enum

Provides an example of using the deprecated `.clear()` method to reset styling. It's recommended to use `.resetting()` instead due to naming conflicts. This method historically set the quirk to `Quirk::Clear`.

```rust
println!("{}", value.clear());
```

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

### HRT Struct

Source: https://docs.rs/iocaine/3.0.1/iocaine/queer/struct

The HRT struct itself, with its constructor.

```APIDOC
## Struct HRT

### Summary

```rust
pub struct HRT;
```

### Implementations

#### pub fn new() -> Self

Creates a new instance of the HRT struct.
```

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

### Create and Run Body Instance in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/struct

Demonstrates how to create a new instance of the `Body` struct using its `new` constructor and how to asynchronously execute its `run` method. The `new` function returns a `Result`, indicating potential errors during initialization.

```rust
pub fn new(inner: Freezer) -> Result<Self>
pub async fn run(self) -> Result<()>

```

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

### paint() Method for Applying Style

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

The `paint()` method applies a given style to the current instance, replacing any previous style.

```rust
let styled_text = some_text.paint(style);
```

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

### Dereference Pointer to Get Immutable Reference

Source: https://docs.rs/iocaine/3.0.1/iocaine/queer/struct

Dereferences a raw pointer (`usize`) to obtain an immutable reference (`&'a T`) to the pointed-to data. This is an `unsafe` operation due to the inherent risks of raw pointer manipulation, such as dangling pointers or data races.

```rust
unsafe fn deref<'a>(ptr: usize) -> &'a T
```

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

### Create a new Painted object

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/gobbledygook/struct

Creates a new `Painted` object with a default `Style`. This is the entry point for creating styled strings. It consumes `self` and returns a `Painted<Self>`.

```rust
let painted_string = Painted::new(some_string);
```

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

### Get Specific File from SquashFS in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/struct

This function retrieves a specific embedded file from a SquashFS image based on its path. It returns an Option containing an EmbeddedFile if found, otherwise None. It takes a file path string slice as input.

```Rust
pub fn get(file_path: &str) -> Option<EmbeddedFile>

```

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

### HRT Blanket Implementations (Generic)

Source: https://docs.rs/iocaine/3.0.1/iocaine/queer/struct

Showcases various blanket implementations for the HRT struct, enabling generic functionality like `Any`, `ArchivePointee`, `Borrow`, `BorrowMut`, `Deserialize`, `From`, `Instrument`, `Into`, `IntoEither`, and `Paint`.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
fn type_id(&self) -> TypeId

```

```rust
impl<T> ArchivePointee for T
type ArchivedMetadata = ()
fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

```

```rust
impl<T> Borrow<T> for T
where T: ?Sized,
fn borrow(&self) -> &T

```

```rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
fn borrow_mut(&mut self) -> &mut T

```

```rust
impl<F, W, T, D> Deserialize<With<T, W>, D> for F
where W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,
fn deserialize( &self, deserializer: &mut D, ) -> Result<With<T, W>, <D as Fallible>::Error>

```

```rust
impl<T> From<T> for T
fn from(t: T) -> T

```

```rust
impl<T> Instrument for T
fn instrument(self, span: Span) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>

```

```rust
impl<T, U> Into<U> for T
where U: From<T>,
fn into(self) -> U

```

```rust
impl<T> IntoEither for T
fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

```

```rust
impl<T> Paint for T
where T: ?Sized,
fn fg(&self, value: Color) -> Painted<&T>
fn primary(&self) -> Painted<&T>
fn fixed(&self, color: u8) -> Painted<&T>
fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>
fn black(&self) -> Painted<&T>
fn red(&self) -> Painted<&T>

```

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

### HRT Paint Implementation

Source: https://docs.rs/iocaine/3.0.1/iocaine/queer/struct

Details on how HRT implements the Paint trait for styling text.

```APIDOC
## impl Paint for T

### fg(&self, value: Color) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Primary`].

##### Example
```
use yansi::{Paint, Color};

painted.fg(Color::White);
```

### primary(&self) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Primary`].

##### Example
```
println!("{}", value.primary());
```

### fixed(&self, color: u8) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Fixed`].

##### Example
```
println!("{}", value.fixed(color));
```

### rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Rgb`].

##### Example
```
println!("{}", value.rgb(r, g, b));
```

### black(&self) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Black`].

##### Example
```
println!("{}", value.black());
```

### red(&self) -> Painted<&T>

Returns `self` with the `fg()` set to [`Color :: Red`].

##### Example
```
println!("{}", value.red());
```
```

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

### Body Implementations

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/struct

Details on the implementations available for the `Body` struct.

```APIDOC
## impl Body

### `pub fn new(inner: Freezer) -> Result<Self>`

**Description**: Creates a new `Body` instance with the provided `Freezer`.

**Method**: POST (Conceptual - this is a constructor)

**Endpoint**: N/A (struct constructor)

**Parameters**:
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* `inner` (Freezer) - Required - The `Freezer` instance to wrap.

### `pub async fn run(self) -> Result<()>`

**Description**: Executes the associated `Freezer` logic asynchronously.

**Method**: POST (Conceptual - this is an async method call)

**Endpoint**: N/A (method call)

**Parameters**:
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None (operates on `self`)

### Request Example
```rust
// Example for new()
let freezer_instance = Freezer::new(); // Assuming Freezer has a new() constructor
let body_instance = Body::new(freezer_instance)?;

// Example for run()
body_instance.run().await?;
```

### Response
#### Success Response (200)
* `()` - Indicates successful execution for `run()`.

#### Response Example
```json
// For new(): No direct JSON response, returns Result<Body>
// For run(): No direct JSON response, returns Result<()>
```
```

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

### Demonstrate Arc::into_inner Guarantee in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

This example shows the guarantee provided by `Arc::into_inner`, which ensures that one of the threads successfully retrieves the inner value when multiple threads attempt to call it on clones of an Arc. It requires the `std::sync::Arc` module.

```rust
use std::sync::Arc;

let x = Arc::new(3);
let y = Arc::clone(&x);

// Two threads calling `Arc::into_inner` on both clones of an `Arc`:
let x_thread = std::thread::spawn(|| Arc::into_inner(x));
let y_thread = std::thread::spawn(|| Arc::into_inner(y));

let x_inner_value = x_thread.join().unwrap();
let y_inner_value = y_thread.join().unwrap();

// One of the threads is guaranteed to receive the inner value:
assert!(matches!(
    (x_inner_value, y_inner_value),
    (None, Some(3)) | (Some(3), None)
));
// The result could also be `(None, None)` if the threads called
// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.
```

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

### Background Color Methods

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/struct

Methods to set the background color of the text.

```APIDOC
## Background Color Methods

### Description
Methods to set the background color of the text. Prefer color-specific methods like `on_red()` over the generic `bg()`.

### Methods
- `bg(value: Color)`: Sets background to the specified `Color` value. Use rarely.
- `on_primary()`: Sets background to `Color::Primary`.
- `on_fixed(color: u8)`: Sets background to `Color::Fixed` with the given `u8` value.
- `on_rgb(r: u8, g: u8, b: u8)`: Sets background to `Color::Rgb` with the specified RGB values.
- `on_black()`: Sets background to `Color::Black`.
- `on_red()`: Sets background to `Color::Red`.
- `on_green()`: Sets background to `Color::Green`.
- `on_yellow()`: Sets background to `Color::Yellow`.
- `on_blue()`: Sets background to `Color::Blue`.
- `on_magenta()`: Sets background to `Color::Magenta`.
- `on_cyan()`: Sets background to `Color::Cyan`.
- `on_white()`: Sets background to `Color::White`.
- `on_bright_black()`: Sets background to `Color::BrightBlack`.
- `on_bright_red()`: Sets background to `Color::BrightRed`.
- `on_bright_green()`: Sets background to `Color::BrightGreen`.
- `on_bright_yellow()`: Sets background to `Color::BrightYellow`.
- `on_bright_blue()`: Sets background to `Color::BrightBlue`.

### Request Example
```rust
use yansi::{Paint, Color};

painted.bg(Color::Red);
// or
painted.on_red();
```

### Response Example
```rust
// Returns a Painted<&T> with the background color set.
```
```

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

### Set Foreground Color with Named Colors (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/tenx_programmer/struct

These functions allow setting the foreground color of text using predefined named colors. They take a reference to a `Painted` object and return a new `Painted` object with the specified foreground color. Examples demonstrate basic usage.

```Rust
println!("{}", value.primary());
```

```Rust
println!("{}", value.black());
```

```Rust
println!("{}", value.red());
```

```Rust
println!("{}", value.green());
```

```Rust
println!("{}", value.yellow());
```

```Rust
println!("{}", value.blue());
```

```Rust
println!("{}", value.magenta());
```

```Rust
println!("{}", value.cyan());
```

```Rust
println!("{}", value.white());
```

```Rust
println!("{}", value.bright_black());
```

```Rust
println!("{}", value.bright_red());
```

```Rust
println!("{}", value.bright_green());
```

```Rust
println!("{}", value.bright_yellow());
```

```Rust
println!("{}", value.bright_blue());
```

```Rust
println!("{}", value.bright_magenta());
```

```Rust
println!("{}", value.bright_cyan());
```

```Rust
println!("{}", value.bright_white());
```

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

### WithSubscriber Trait

Source: https://docs.rs/iocaine/3.0.1/iocaine/bruce/struct

Documentation for the `WithSubscriber` trait, for attaching subscribers to types.

```APIDOC
## WithSubscriber Trait

### Description
Allows attaching a `Subscriber` to a type.

### Methods

#### `fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>`
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper.

#### `fn with_current_subscriber(self) -> WithDispatch<Self>`
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper.
```

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

### Dereference Pointer to Get Mutable Reference

Source: https://docs.rs/iocaine/3.0.1/iocaine/queer/struct

Dereferences a raw pointer (`usize`) to obtain a mutable reference (`&'a mut T`) to the pointed-to data. This `unsafe` operation requires extreme caution to avoid data races and other memory safety issues. Ensure the pointer is valid and no other references exist.

```rust
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
```

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

### Apply Text Attributes using Specific Methods in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/enum

Demonstrates applying various text attributes like Bold, Dim, Italic, Underline, Blink, and Rapid Blink using their respective shorthand methods provided by the `yansi` crate in Rust.

```Rust
println!("{}", value.bold());
```

```Rust
println!("{}", value.dim());
```

```Rust
println!("{}", value.italic());
```

```Rust
println!("{}", value.underline());
```

```Rust
println!("{}", value.blink());
```

```Rust
println!("{}", value.rapid_blink());
```

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

### QR Code Generation and Conversion with QRJourney

Source: https://docs.rs/iocaine/3.0.1/iocaine/bullshit/qr_journey/struct

This snippet covers the core functionalities of the QRJourney struct for generating QR codes. It includes methods to create PNG and SVG representations from string content and a specified size, and to convert the generated QR code into binary or base64 encoded strings. The functions return a `Result` which may contain a `QRJourney` instance or an error.

```rust
pub struct QRJourney(/* private fields */);

impl QRJourney {
    pub fn generate_png<S: AsRef<str>>(content: S, size: u64) -> Result<Self>;
    pub fn generate_svg<S: AsRef<str>>(content: S, size: u64) -> Result<Self>;
    pub fn as_binary(&self) -> Vec<u8>;
    pub fn as_base64(&self) -> String;
}
```

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

### Try to Unwrap Arc with Single Reference (Rust)

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

Illustrates the use of `Arc::try_unwrap` to extract the inner value from an Arc when it has exactly one strong reference. If there are multiple strong references, it returns an error containing the original Arc. This example also shows the case where unwrapping fails due to multiple references.

```rust
use std::sync::Arc;

let x = Arc::new(3);
assert_eq!(Arc::try_unwrap(x), Ok(3));

let x = Arc::new(4);
let _y = Arc::clone(&x);
assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);

```

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

### Apply Text Quirks using quirk() and specific methods

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/freezer/enum

Demonstrates applying text quirks like Wrap. The `quirk()` method is general but less preferred than specific methods like `wrap()`. It requires importing `Quirk` from yansi.

```rust
use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);
```

```rust
use yansi::Paint;

painted.wrap();
```

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

### Applying Bright Style in Rust

Source: https://docs.rs/iocaine/3.0.1/iocaine/sex_dungeon/means_of_production/enum

Shows how to apply a bright visual style to a string using the `.bright()` method. This returns the `Painted` object with the `Quirk::Bright` setting.

```rust
println!("{}", value.bright());
```

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

### Prevent Stack Overflow with Arc::into_inner in Rust Linked List

Source: https://docs.rs/iocaine/3.0.1/iocaine/morgue/state_of_decay/type

This example demonstrates a practical use case for `Arc::into_inner` to prevent stack overflows when dropping a long linked list. By manually implementing `Drop` and using `Arc::into_inner` within a loop, it avoids deep recursion. This requires `std::sync::Arc` and standard thread functionality.

```rust
use std::sync::Arc;

// Definition of a simple singly linked list using `Arc`:
#[derive(Clone)]
struct LinkedList<T>(Option<Arc<Node<T>>>);
struct Node<T>(T, Option<Arc<Node<T>>>);

// Dropping a long `LinkedList<T>` relying on the destructor of `Arc`
// can cause a stack overflow. To prevent this, we can provide a
// manual `Drop` implementation that does the destruction in a loop:
impl<T> Drop for LinkedList<T> {
    fn drop(&mut self) {
        let mut link = self.0.take();
        while let Some(arc_node) = link.take() {
            if let Some(Node(_value, next)) = Arc::into_inner(arc_node) {
                link = next;
            }
        }
    }
}

// Implementation of `new` and `push` omitted
impl<T> LinkedList<T> {
    /* ... */
}

// The following code could have still caused a stack overflow
// despite the manual `Drop` impl if that `Drop` impl had used
// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.

// Create a long list and clone it
let mut x = LinkedList::new();
let size = 100000;
for i in 0..size {
    x.push(i); // Adds i to the front of x
}
let y = x.clone();

// Drop the clones in parallel
let x_thread = std::thread::spawn(|| drop(x));
let y_thread = std::thread::spawn(|| drop(y));
x_thread.join().unwrap();
y_thread.join().unwrap();
```
Tokens:
Raw