Memterm

https://docs.rs/memterm/0.1.0/memterm/
Admin
Memterm is a lightweight Rust virtual terminal emulator that handles ANSI escape sequences and...
Tokens:85,621
Snippets:601
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### BTreeMap get method example

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Demonstrates how to retrieve a value from a BTreeMap using its key. Returns None if the key is not found.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

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

### HashMap length example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Shows how to get the number of elements currently in a HashMap. The length is updated after insertions.

```rust
use std::collections::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

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

### HashMap Get Key-Value Example

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_AIXTERM.html

Shows how to retrieve both the key and value for a given lookup key. This is useful for specific scenarios like non-identical keys considered equal or obtaining the stored key.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);
```

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

### HashMap get example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Retrieves a reference to the value associated with a key. Returns None if the key is not found. The key can be a borrowed form.

```rust
use std::collections::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

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

### HashMap iteration example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Illustrates iterating over key-value pairs in a HashMap. The iteration performance is O(capacity).

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for (key, val) in map.iter() {
    println!("key: {key} val: {val}");
}
```

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

### HashMap keys iteration example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Shows how to iterate over the keys of a HashMap. Note that iteration takes O(capacity) time.

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for key in map.keys() {
    println!("{key}");
}
```

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

### HashMap capacity example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Demonstrates how to check the capacity of a HashMap. The capacity is a lower bound, and the HashMap may hold more elements.

```rust
use std::collections::HashMap;
let map: HashMap<i32, i32> = HashMap::with_capacity(100);
assert!(map.capacity() >= 100);
```

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

### BTreeMap range method example

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Creates an iterator over a sub-range of elements in the map. Supports various range syntaxes and bound types. Panics if range start > end or if both bounds are Excluded and equal.

```rust
use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!(ירת {key}: {value});
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());
```

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

### HashMap is_empty check example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Demonstrates checking if a HashMap is empty. Returns true if no elements are present.

```rust
use std::collections::HashMap;

let mut a = HashMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());
```

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

### HashMap values iteration example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Demonstrates iterating over the values of a HashMap. Similar to keys, this operation takes O(capacity) time.

```rust
use std::collections::HashMap;

let map = HashMap::from([
    ("a", 1),
    ("b", 2),
    ("c", 3),
]);

for val in map.values() {
    println!("{val}");
}
```

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

### Check slice prefix

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Verify if a slice starts with a specific sequence. Empty slices always return true.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

```rust
let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));
```

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

### GET /HashSet/get

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Retrieves a reference to a value in the set if it exists.

```APIDOC
## GET /HashSet/get

### Description
Returns a reference to the value in the set, if any, that is equal to the given value.

### Method
GET

### Parameters
#### Query Parameters
- **value** (Q) - Required - The value to search for in the set.

### Response
#### Success Response (200)
- **value** (Option<&T>) - A reference to the found value or None.
```

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

### HashMap hasher access example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Retrieves a reference to the HashMap's BuildHasher. This is useful for understanding or replicating the hashing strategy.

```rust
use std::collections::HashMap;
use std::hash::RandomState;

let hasher = RandomState::new();
let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);
let hasher: &RandomState = map.hasher();
```

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

### Get an element from HashSet

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Use `get` to retrieve a reference to an element if it exists in the set. The element can be queried using a borrowed form.

```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);
```

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

### Get Screen Lines as Unicode

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Screen.html

Returns a vector of strings, where each string represents a line on the screen rendered as Unicode.

```rust
fn display(&mut self) -> Vec<String>
```

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

### GET /graphics/TEXT/len

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.TEXT.html

Returns the total number of style mappings currently stored in the TEXT struct.

```APIDOC
## GET /graphics/TEXT/len

### Description
Returns the number of elements in the style map.

### Method
GET

### Response
#### Success Response (200)
- **count** (usize) - The number of style mappings.

#### Response Example
{
  "count": 9
}
```

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

### BTreeMap first_key_value method example

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Returns the first key-value pair in the map, which corresponds to the minimum key. Returns None if the map is empty.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key_value(), Some((&1, &"b")));
```

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

### GET /graphics/TEXT/get

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.TEXT.html

Retrieves the style name associated with a specific ANSI style code.

```APIDOC
## GET /graphics/TEXT/get

### Description
Returns a reference to the style name corresponding to the provided ANSI style code key.

### Method
GET

### Parameters
#### Query Parameters
- **k** (u32) - Required - The ANSI style code to look up.

### Response
#### Success Response (200)
- **value** (String) - The style name (e.g., "+bold").

#### Response Example
{
  "value": "+bold"
}
```

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

### Get Default Character Options

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Screen.html

Returns a CharOpts struct representing an empty character with default foreground and background colors.

```rust
pub fn default_char(&self) -> CharOpts
```

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

### HashMap get_key_value example

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

Fetches the key-value pair for a given key. This is useful for key types where non-identical keys can be equal, or for obtaining the stored key reference.

```rust
use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and hashing operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl Hash for S {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = HashMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), None);
```

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

### BTreeMap get_key_value method example

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Retrieves a key-value pair from a BTreeMap. Useful for key types where non-identical keys can be considered equal, or for obtaining the stored key reference.

```rust
use std::cmp::Ordering;
use std::collections::BTreeMap;

#[derive(Clone, Copy, Debug)]
struct S {
    id: u32,
    name: &'static str, // ignored by equality and ordering operations
}

impl PartialEq for S {
    fn eq(&self, other: &S) -> bool {
        self.id == other.id
    }
}

impl Eq for S {}

impl PartialOrd for S {
    fn partial_cmp(&self, other: &S) -> Option<Ordering> {
        self.id.partial_cmp(&other.id)
    }
}

impl Ord for S {
    fn cmp(&self, other: &S) -> Ordering {
        self.id.cmp(&other.id)
    }
}

let j_a = S { id: 1, name: "Jessica" };
let j_b = S { id: 1, name: "Jess" };
let p = S { id: 2, name: "Paul" };
assert_eq!(j_a, j_b);

let mut map = BTreeMap::new();
map.insert(j_a, "Paris");
assert_eq!(map.get_key_value(&j_a), Some((&j_a, &"Paris")));
assert_eq!(map.get_key_value(&j_b), Some((&j_a, &"Paris"))); // the notable case
assert_eq!(map.get_key_value(&p), None);
```

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

### Initialize New Screen

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Screen.html

Creates a new Screen instance with the specified dimensions. This is the entry point for setting up the terminal screen.

```rust
pub fn new(columns: u32, lines: u32) -> Self
```

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

### Build the project with memterm

Source: https://docs.rs/memterm/0.1.0/memterm/index.html

After adding memterm as a dependency, run `cargo build` to compile your project.

```bash
cargo build

```

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

### Check for Special Start Character

Source: https://docs.rs/memterm/0.1.0/memterm/parser/struct.Parser.html

Determines if a given string slice starts with a special character recognized by the parser.

```rust
pub fn is_special_start(s: &str) -> bool
```

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

### Blanket Implementations

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_ANSI.html

Documentation for blanket implementations like Any, Borrow, BorrowMut, From, Into, Receiver, TryFrom, TryInto.

```APIDOC
## Blanket Implementations

### Description
This section covers various blanket implementations available for types, including `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `Receiver`, `TryFrom`, and `TryInto`.

### Method
BLANKET_IMPL

### Endpoint
N/A

### Parameters
None

### Request Example
None

### Response
None

### Response Example
None
```

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

### Get Mutable Element or Subslice by Index

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Safely get a mutable reference to an element or subslice. Returns None if the index is out of bounds.

```rust
let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);
```

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

### Get Mutable Reference to Last Chunk

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Safely get a mutable reference to the last N items in a slice. Returns None if the slice is shorter than N.

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

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

### GET /HashSet/is_disjoint

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Checks if two sets have no elements in common.

```APIDOC
## GET /HashSet/is_disjoint

### Description
Returns true if the set has no elements in common with the other set.

### Method
GET

### Parameters
#### Query Parameters
- **other** (HashSet<T, S>) - Required - The set to compare against.

### Response
#### Success Response (200)
- **result** (bool) - True if disjoint, false otherwise.
```

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

### BTreeMap Basic Operations

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Demonstrates basic insertion and iteration over a BTreeMap.

```APIDOC
## BTreeMap Basic Operations

### Description
Demonstrates basic insertion and iteration over a BTreeMap.

### Method
N/A (Illustrative Example)

### Endpoint
N/A

### Request Body
N/A

### Request Example
```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{key}: {value}");
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));
```

### Response
N/A
```

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

### Memterm Crate Overview

Source: https://docs.rs/memterm/0.1.0/memterm/charset/index.html

Provides an overview of the memterm crate's structure and key components.

```APIDOC
## Memterm Crate Documentation (0.1.0)

This crate provides functionality related to character set mappings.

### Modules

*   **charset**: Contains the core logic for character set handling.

### Structs

*   **MAPS**: Likely a collection or definition of various character maps.

### Constants

*   **IBMPC_MAP**: A constant representing the IBM PC character set mapping.
*   **LAT1_MAP**: A constant representing the Latin-1 character set mapping.
*   **VAX42_MAP**: A constant representing the VAX 4.2 character set mapping.
*   **VT100_MAP**: A constant representing the VT100 character set mapping.

### Platform and Features

*   Supports Rust.
*   Information on platform compatibility and feature flags may be available elsewhere.
```

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

### Implement CloneToUninit for T

Source: https://docs.rs/memterm/0.1.0/memterm/screen/enum.Charset.html

Nightly-only experimental API for copying data to uninitialized memory. Requires the type to implement Clone.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

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

### get

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Returns a reference to an element or subslice based on the provided index.

```APIDOC
## get<I>

### Description
Returns a reference to an element or subslice depending on the type of index. If given a position, returns a reference to the element; if given a range, returns the subslice.

### Parameters
#### Path Parameters
- **index** (I: SliceIndex<[T]>) - Required - The index or range to retrieve.

### Response
#### Success Response (200)
- **Option<&Output>** - A reference to the element or subslice, or None if out of bounds.
```

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

### GET /HashSet/is_superset

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Checks if the current set is a superset of another set.

```APIDOC
## GET /HashSet/is_superset

### Description
Returns true if the set is a superset of another, meaning the current set contains at least all the values in the other set.

### Method
GET

### Parameters
#### Query Parameters
- **other** (HashSet<T, S>) - Required - The potential subset.

### Response
#### Success Response (200)
- **result** (bool) - True if superset, false otherwise.
```

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

### Initialize New Parser

Source: https://docs.rs/memterm/0.1.0/memterm/parser/struct.Parser.html

Creates a new instance of the `Parser`. Requires an `Arc<Mutex<T>>` where `T` is the `ParserListener`.

```rust
pub fn new(listener: Arc<Mutex<T>>) -> Self>
```

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

### GET /HashSet/is_subset

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Checks if the current set is a subset of another set.

```APIDOC
## GET /HashSet/is_subset

### Description
Returns true if the set is a subset of another, meaning the other set contains at least all the values in the current set.

### Method
GET

### Parameters
#### Query Parameters
- **other** (HashSet<T, S>) - Required - The potential superset.

### Response
#### Success Response (200)
- **result** (bool) - True if subset, false otherwise.
```

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

### Get HashSet length

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.SPECIAL.html

Retrieve the number of elements currently stored in the set.

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

let mut v = HashSet::new();
assert_eq!(v.len(), 0);
v.insert(1);
assert_eq!(v.len(), 1);
```

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

### as_rchunks

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits the slice into a slice of N-element arrays starting from the end, and a remainder slice.

```APIDOC
## as_rchunks

### Description
Splits the slice into a slice of `N`-element arrays, starting at the end of the slice, and a remainder slice with length strictly less than `N`.

### Parameters
- **N** (const usize) - Required - The size of the arrays.

### Response
- **(&[T], &[[T; N]])** - A tuple containing the remainder slice and the slice of arrays.
```

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

### len() - Get Map Size

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Returns the number of elements currently stored in the map.

```APIDOC
## GET /len

### Description
Returns the number of elements in the map.

### Method
GET

### Endpoint
/len

### Parameters
N/A

### Request Body
N/A

### Response
#### Success Response (200)
- **usize** - The number of elements in the map.

#### Response Example
```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```
```

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

### DebugScreen Constructor

Source: https://docs.rs/memterm/0.1.0/memterm/debug_screen/struct.DebugScreen.html

Provides a way to create a new instance of the DebugScreen.

```APIDOC
## impl DebugScreen

### pub fn new() -> Self
Creates a new instance of DebugScreen.
```

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

### values() - Get Iterator Over Values

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Retrieves an iterator over the values of the map, ordered by key.

```APIDOC
## GET /values

### Description
Gets an iterator over the values of the map, in order by key.

### Method
GET

### Endpoint
/values

### Parameters
N/A

### Request Body
N/A

### Response
#### Success Response (200)
- **Values<'_, K, V>** (Iterator) - An iterator over the values.

#### Response Example
```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);
```
```

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

### keys() - Get Iterator Over Keys

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Retrieves an iterator over the keys of the map in sorted order.

```APIDOC
## GET /keys

### Description
Gets an iterator over the keys of the map, in sorted order.

### Method
GET

### Endpoint
/keys

### Parameters
N/A

### Request Body
N/A

### Response
#### Success Response (200)
- **Keys<'_, K, V>** (Iterator) - An iterator over the keys.

#### Response Example
```rust
use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);
```
```

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

### Verify TEXT style mappings

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.TEXT.html

Demonstrates checking the mapping of ANSI codes to style names within the TEXT struct.

```rust
assert_eq!(TEXT.get(&1), Some(&"+bold".to_string()));
assert_eq!(TEXT.get(&9), Some(&"+strikethrough".to_string()));
```

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

### CSI Constant

Source: https://docs.rs/memterm/0.1.0/memterm/control/constant.CSI.html

Documentation for the Control Sequence Introducer (CSI) constant.

```APIDOC
## Constant CSI

### Description
The CSI constant represents the Control Sequence Introducer (\u{009B}) used for terminal control operations.

### Definition
`pub const CSI: &str = "\u{009B}";`
```

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

### Iterate over BTreeMap entries

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Demonstrates inserting elements into a BTreeMap and iterating over them in sorted order.

```rust
use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{key}: {value}");
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));
```

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

### PartialEq Implementation for Margins

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Margins.html

Allows comparison of Margins structs for equality. The `eq` method tests for identical values, while `ne` tests for inequality.

```rust
fn eq(&self, other: &Margins) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### Mutate slice chunks in reverse

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Demonstrates using rchunks_mut to modify elements in chunks starting from the end.

```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

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

### Iterate Over Slice Elements

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Provides an iterator that yields immutable references to each element in the slice from start to end.

```rust
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

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

### Trait Implementations: From, Into, TryFrom, TryInto

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Documentation for standard conversion traits used for type transformation and error handling.

```APIDOC
## From<T>

### Description
Provides a way to convert a value of type T into another type.

### Method
fn from(t: T) -> T

---

## Into<U>

### Description
Calls U::from(self) to perform a conversion.

### Method
fn into(self) -> U

---

## TryFrom<U>

### Description
Performs a fallible conversion from U to T.

### Method
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

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

---

## TryInto<U>

### Description
Performs a fallible conversion into U.

### Method
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

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

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

### get_disjoint_mut

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Safely gets mutable references to multiple disjoint elements or slices within a mutable slice.

```APIDOC
## get_disjoint_mut

### Description
Returns mutable references to many indices at once. An index can be either a `usize`, a `Range` or a `RangeInclusive`. Note that this method takes an array, so all indices must be of the same type. If passed an array of `usize`s this method gives back an array of mutable references to single elements, while if passed an array of ranges it gives back an array of mutable references to slices. Returns an error if any index is out-of-bounds, or if there are overlapping indices. An empty range is not considered to overlap if it is located at the beginning or at the end of another range, but is considered to overlap if it is located in the middle. This method does a O(n^2) check to check that there are no overlapping indices, so be careful when passing many indices.

### Method
`get_disjoint_mut`

### Endpoint
N/A (Method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example demonstrating success
let mut data = vec![1, 2, 3, 4, 5];
let result = data.get_disjoint_mut([0..2, 3..5]);
if let Ok(refs) = result {
    let [slice1, slice2] = refs;
    slice1[0] = 10;
    slice2[1] = 50;
}
// data is now [10, 2, 3, 4, 50]

// Example demonstrating error (overlapping ranges)
let mut data = vec![1, 2, 3, 4, 5];
let result = data.get_disjoint_mut([0..3, 2..4]); // Overlapping
// result will be Err(GetDisjointMutError::Overlap)

// Example demonstrating error (out of bounds)
let mut data = vec![1, 2, 3];
let result = data.get_disjoint_mut([0, 5]); // 5 is out of bounds
// result will be Err(GetDisjointMutError::OutOfBounds)
```

### Response
#### Success Response (200)
`Result<[&mut <I as SliceIndex<[T]>>::Output; N], GetDisjointMutError>`: An array of mutable references if successful, or an error if indices are invalid or overlapping.

#### Response Example
```rust
// Success example
Ok([&mut [10, 2], &mut [4, 50]])

// Error example (overlap)
Err(GetDisjointMutError::Overlap)

// Error example (out of bounds)
Err(GetDisjointMutError::OutOfBounds)
```
```

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

### Insert Item into Sorted Vector using partition_point

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Demonstrates inserting an element into a sorted vector while maintaining sort order using partition_point to find the correct insertion index.

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

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

### get_disjoint_unchecked_mut

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Unsafely gets mutable references to multiple disjoint elements or slices within a mutable slice.

```APIDOC
## get_disjoint_unchecked_mut

### Description
Returns mutable references to many indices at once, without doing any checks. An index can be either a `usize`, a `Range` or a `RangeInclusive`. Note that this method takes an array, so all indices must be of the same type. If passed an array of `usize`s this method gives back an array of mutable references to single elements, while if passed an array of ranges it gives back an array of mutable references to slices. For a safe alternative see `get_disjoint_mut`.

### Method
`get_disjoint_unchecked_mut`

### Endpoint
N/A (Method on slice)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);
```

### Response
#### Success Response (200)
An array of mutable references to the specified disjoint elements or slices.

#### Response Example
```rust
// Example output for [0, 2] on [1, 2, 4]
[&mut 1, &mut 4]

// Example output for [0..1, 1..3] on [8, 88, 888]
[&mut [8], &mut [88, 888]]
```

### Safety
Calling this method with overlapping or out-of-bounds indices is _undefined behavior_ even if the resulting references are not used.
```

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

### ByteParser Methods

Source: https://docs.rs/memterm/0.1.0/memterm/byte_parser/struct.ByteParser.html

Methods available for the ByteParser struct to initialize, feed data, and manage charsets.

```APIDOC
## pub fn new(listener: Arc<Mutex<T>>) -> Self

### Description
Creates a new ByteParser instance with the provided parser listener.

### Parameters
- **listener** (Arc<Mutex<T>>) - Required - The listener that will receive parsed data.

## pub fn feed(&mut self, data: &[u8])

### Description
Feeds a slice of bytes into the parser for processing.

### Parameters
- **data** (&[u8]) - Required - The byte data to be parsed.

## pub fn select_other_charset(&mut self, code: &str)

### Description
Updates the character set used by the parser.

### Parameters
- **code** (&str) - Required - The charset identifier string.
```

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

### Constant BASIC

Source: https://docs.rs/memterm/0.1.0/memterm/control/constant.BASIC.html

Documentation for the BASIC constant in the memterm::control module.

```APIDOC
## Constant: memterm::control::BASIC

### Description
A constant representing a slice of string slices containing 9 elements.

### Definition
`pub const BASIC: &[&str; 9];`
```

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

### Reverse Slice In-Place

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Reverses the order of elements within the slice directly. No setup or imports are needed.

```rust
let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);
```

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

### Check Vector Capacity

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Demonstrates checking the capacity of a vector and the behavior with zero-sized elements.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

```rust
#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}
```

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

### pub fn as_simd<const LANES: usize>(&self)

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix. This is a safe wrapper around slice::align_to.

```APIDOC
## GET /slice/as_simd

### Description
Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix. This is a nightly-only experimental API.

### Method
GET

### Parameters
#### Query Parameters
- **LANES** (usize) - Required - The number of lanes for the SIMD type.

### Response
#### Success Response (200)
- **prefix** (slice) - The unaligned prefix.
- **middle** (slice) - The aligned SIMD middle slice.
- **suffix** (slice) - The unaligned suffix.
```

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

### Limited reverse slice splitting with rsplitn

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits a slice into at most n subslices starting from the end based on a predicate.

```rust
let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}
```

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

### Add memterm to Cargo.toml

Source: https://docs.rs/memterm/0.1.0/memterm/index.html

Add the memterm crate as a dependency in your Cargo.toml file to include it in your project.

```toml
[dependencies]
memterm = "0.1"

```

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

### rchunks

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap.

```APIDOC
## rchunks

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the slice, then the last chunk will not have length `chunk_size`.

### Method
`rchunks`

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The desired size of each chunk.

### Request Example
```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());
```

### Response
#### Success Response (Iterator)
- **Iterator** - An iterator yielding slices of the original slice.

#### Response Example
(See Request Example for iterator output)
```

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

### Clone Implementation for Margins

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Margins.html

Provides methods to duplicate or copy Margins values. Use `clone` for a new copy and `clone_from` for in-place assignment.

```rust
fn clone(&self) -> Margins
```

```rust
fn clone_from(&mut self, source: &Self)
```

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

### Check for Prefix

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Verifies if a slice begins with a specified sequence of elements.

```APIDOC
## GET /slice/starts_with

### Description
Returns `true` if the slice starts with the given `needle` sequence.

### Method
GET

### Endpoint
`/slice/starts_with`

### Parameters
#### Query Parameters
- **needle** (array of T) - Required - The sequence to check if it's a prefix of the slice.

### Response
#### Success Response (200)
- **result** (boolean) - `true` if the slice starts with the `needle`, `false` otherwise.

### Response Example
```json
{
  "result": true
}
```
```

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

### Implement PartialEq for Charset

Source: https://docs.rs/memterm/0.1.0/memterm/screen/enum.Charset.html

Allows for equality comparison between Charset values. This enables the use of `==` and `!=` operators.

```rust
fn eq(&self, other: &Charset) -> bool
```

```rust
fn ne(&self, other: &Rhs) -> bool
```

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

### CSI_COMMANDS Methods

Source: https://docs.rs/memterm/0.1.0/memterm/control/struct.CSI_COMMANDS.html

Methods available for interacting with the CSI_COMMANDS map, including retrieval, range queries, and iteration.

```APIDOC
## Methods for CSI_COMMANDS

### Description
These methods allow for retrieving values, checking for key existence, and iterating over the command map.

### Methods
- **get<Q>(key: &Q) -> Option<&V>**: Returns a reference to the value corresponding to the key.
- **get_key_value<Q>(k: &Q) -> Option<(&K, &V)>**: Returns the key-value pair corresponding to the supplied key.
- **first_key_value() -> Option<(&K, &V)>**: Returns the first (minimum) key-value pair in the map.
- **last_key_value() -> Option<(&K, &V)>**: Returns the last (maximum) key-value pair in the map.
- **contains_key<Q>(key: &Q) -> bool**: Returns true if the map contains a value for the specified key.
- **range<T, R>(range: R) -> Range<'_, K, V>**: Constructs a double-ended iterator over a sub-range of elements.
- **iter() -> Iter<'_, K, V>**: Gets an iterator over the entries of the map, sorted by key.
```

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

### Limited mutable reverse slice splitting with rsplitn_mut

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits a slice into at most n mutable subslices starting from the end based on a predicate.

```rust
let mut s = [10, 40, 30, 20, 60, 50];

for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(s, [1, 40, 30, 20, 60, 1]);
```

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

### Struct CharOpts

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.CharOpts.html

Represents the configuration options for a character in the memterm screen buffer.

```APIDOC
## Struct CharOpts

### Description
Represents the styling and content options for a character within the memterm screen.

### Fields
- **data** (String) - The character data.
- **fg** (String) - Foreground color configuration.
- **bg** (String) - Background color configuration.
- **bold** (bool) - Whether the character is bold.
- **italics** (bool) - Whether the character is italicized.
- **underscore** (bool) - Whether the character is underlined.
- **strikethrough** (bool) - Whether the character has a strikethrough.
- **reverse** (bool) - Whether the character colors are reversed.
- **blink** (bool) - Whether the character blinks.
```

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

### rchunks_mut

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Returns a mutable iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are mutable slices and do not overlap.

```APIDOC
## rchunks_mut

### Description
Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end of the slice. The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the length of the slice, then the last chunk will not have length `chunk_size`.

### Method
`rchunks_mut`

### Parameters
#### Query Parameters
- **chunk_size** (usize) - Required - The desired size of each chunk.

### Request Example
```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);
```

### Response
#### Success Response (Iterator)
- **Iterator** - An iterator yielding mutable slices of the original slice.

#### Response Example
(See Request Example for iterator output)
```

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

### Parser Struct and Methods

Source: https://docs.rs/memterm/0.1.0/memterm/parser/struct.Parser.html

Details on the Parser struct, its constructor, and available methods for parsing data.

```APIDOC
## Struct Parser

Source

```rust
pub struct Parser<'a, T>
where
    T: ParserListener + Send + 'a,
{
    /* private fields */
}
```

### Implementations

#### impl<'a, T>
where T: ParserListener + Send + 'a,

##### `new(listener: Arc<Mutex<T>>) -> Self`

Constructor for the Parser.

##### `is_special_start(s: &str) -> bool`

Checks if a string slice is a special start sequence.

##### `feed(&mut self, data: String)`

Feeds data into the parser.

##### `set_use_utf8(&mut self, use_utf8: bool)`

Sets whether to use UTF-8 encoding for parsing.
```

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

### Split slice into arrays from the end with as_rchunks

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits a slice into fixed-size arrays starting from the end, returning a remainder slice for the beginning.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);
```

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

### Get TypeId of a value

Source: https://docs.rs/memterm/0.1.0/memterm/charset/struct.MAPS.html

The `Any` trait provides the `type_id` method to retrieve the unique `TypeId` of a value, useful for dynamic type checking.

```rust
fn type_id(&self) -> TypeId
```

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

### VAX42_MAP Constant

Source: https://docs.rs/memterm/0.1.0/memterm/charset/constant.VAX42_MAP.html

Documentation for the VAX42_MAP constant which provides a character mapping array.

```APIDOC
## VAX42_MAP

### Description
A constant array of 256 characters representing the VAX42 character mapping.

### Definition
`pub const VAX42_MAP: [char; 256];`
```

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

### Trait Implementations

Source: https://docs.rs/memterm/0.1.0/memterm/screen/struct.Screen.html

Details various trait implementations for the Screen struct, indicating its capabilities and compatibility with Rust's standard library features.

```APIDOC
### impl Freeze for Screen

### Description
Indicates that the `Screen` type can be frozen, meaning it can be safely shared across threads after initialization.

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

```APIDOC
### impl RefUnwindSafe for Screen

### Description
Indicates that the `Screen` type is safe to use in scenarios that require unwinding the stack, specifically when references are involved.

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

```APIDOC
### impl Send for Screen

### Description
Indicates that the `Screen` type can be safely sent between threads.

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

```APIDOC
### impl Sync for Screen

### Description
Indicates that the `Screen` type can be safely shared between threads (i.e., accessed from multiple threads concurrently).

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

```APIDOC
### impl Unpin for Screen

### Description
Indicates that the `Screen` type does not require special handling for pinning, meaning it can be moved freely in memory.

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

```APIDOC
### impl UnwindSafe for Screen

### Description
Indicates that the `Screen` type is safe to use in scenarios that require unwinding the stack.

### Method
N/A (Trait implementation)

### Endpoint
N/A

### Parameters
None

### Request Example
```rust
// Example usage would depend on the context of the Screen struct
```

### Response
N/A
```

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

### as_rchunks_mut

Source: https://docs.rs/memterm/0.1.0/memterm/graphics/struct.FG_BG_256.html

Splits a mutable slice into a slice of `N`-element arrays starting from the end, and a remainder slice. The remainder is at the beginning of the original slice.

```APIDOC
## POST /websites/rs_memterm_0_1_0_memterm/as_rchunks_mut

### Description
Splits the slice into a slice of `N`-element arrays, starting at the end of the slice, and a remainder slice with length strictly less than `N`.

### Method
POST

### Endpoint
/websites/rs_memterm_0_1_0_memterm/as_rchunks_mut

### Parameters
#### Path Parameters
- **N** (const generic) - Required - The size of each chunk.

### Panics
Panics if `N` is zero.

### Request Example
```rust
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut::<2>();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);
```

### Response
#### Success Response (200)
- **(&mut [T], &mut [[T; N]])** - A tuple containing a mutable slice for the remainder and a mutable slice of `N`-element arrays.

#### Response Example
```json
{
  "example": {
    "remainder": "[remainder_element1]",
    "chunks": "[[chunk1_element1, chunk1_element2], [chunk2_element1, chunk2_element2]]"
  }
}
```
```
Tokens:
Raw