TypedMap

https://docs.rs/typedmap/0.6.0/typedmap/
Admin
TypedMap is a type-safe hash map for Rust that stores key-value pairs of any type while ensuring...
Tokens:76,990
Snippets:433
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example Usage of to_owned

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedKeyValueGuard.html

An example demonstrating how to convert a borrowed key-value pair from a TypedDashMap into an owned TypedMap using `to_owned`.

```APIDOC
```rust
use typedmap::{TypedDashMap, TypedMap};
use typedmap::clone::SyncCloneBounds;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug, Clone)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let map: TypedDashMap<(), SyncCloneBounds, SyncCloneBounds> = TypedDashMap::new_with_bounds();
map.insert(Key(3), 3);

let mut new_map: TypedMap<(), SyncCloneBounds, SyncCloneBounds> = TypedMap::new_with_bounds();
for entry in map.iter() {
    new_map.insert_key_value(entry.to_owned());
}
```
```

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

### Initialize IterMut

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IterMut.html

Example showing how to create a mutable iterator from a TypedMap instance.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
	type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.iter_mut();
```

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

### Iterate over TypedMap entries

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Iter.html

Example showing how to create and use an iterator for a TypedMap.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.iter();
```

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

### Initialize TypedMap and insert key-value pair

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IntoIter.html

Example demonstrating how to define a key type with TypedMapKey and insert it into a TypedMap.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
```

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

### Iterate over TypedMap keys

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Keys.html

Example demonstrating how to create a TypedMap, insert a key-value pair, and obtain an iterator over the keys.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.keys();
```

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

### Converting TypedKeyValueMutGuard to Owned

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedKeyValueMutGuard.html

Example demonstrating how to convert a borrowed key-value pair into an owned TypedKeyValue by cloning.

```rust
use typedmap::{TypedDashMap, TypedMap};use typedmap::clone::SyncCloneBounds;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug, Clone)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let map: TypedDashMap<(), SyncCloneBounds, SyncCloneBounds> = TypedDashMap::new_with_bounds();
map.insert(Key(3), 3);

let mut new_map: TypedMap<(), SyncCloneBounds, SyncCloneBounds> = TypedMap::new_with_bounds();
for entry in map.iter_mut() {
    new_map.insert_key_value(entry.to_owned());
}
```

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

### Implement custom bounds for a trait

Source: https://docs.rs/typedmap/0.6.0/typedmap/macro.impl_custom_bounds.html

Example showing how to define a custom trait, a bounds struct, and apply the necessary macros.

```rust
use std::any::Any;
use typedmap::{impl_custom_bounds, impl_dyn_trait_wrapper};

// Trait that you require
trait Component {}
// Requirement bounds used in TypedMap or TypedDashMap
struct CustomBounds;
impl_dyn_trait_wrapper!(DynComponent, Component);
impl_custom_bounds!(CustomBounds, DynComponent, Component);
```

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

### Retrieve entry with get

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

Retrieves an entry from the map if it exists. Returns None if the key is not present.

```rust
use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.get(&Key(3)).is_none());
map.insert(Key(3), 4);
assert_eq!(*map.get(&Key(3)).unwrap(), 4);
```

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

### Initialize ValuesMut iterator

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.ValuesMut.html

Example showing how to define a key type and initialize a mutable iterator from a TypedMap.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.values();
```

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

### Example Usage of TypedMap and ValuesMut

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.ValuesMut.html

Demonstrates how to create a TypedMap, insert a key-value pair, and obtain a mutable iterator over its values using the values() method.

```APIDOC
## §Example
```
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.values();
```

```

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

### entry()

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

Gets the given key’s corresponding entry in the map for in-place manipulation.

```APIDOC
## pub fn entry<K>(&self, key: K) -> Entry<'_, K, KB, VB, Marker>

### Description
Gets the given key’s corresponding entry in the map for in-place manipulation.

### Request Example
```rust
let mut counter = letters.entry(Key(ch)).or_insert(0);
*counter += 1;
```
```

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

### Iterate over TypedDashMap entries

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Iter.html

Example showing how to create and use an iterator for a TypedDashMap.

```rust
use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 3);
let iter = map.iter();
```

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

### Consume VacantEntry to Get Key

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashentry/struct.VacantEntry.html

Consumes the VacantEntry to take ownership of the key.

```rust
pub fn into_key(self) -> K
```

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

### Get Key Container Reference

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedKeyValueRef.html

Returns an immutable reference to the underlying container holding the keys.

```rust
pub fn key_container_ref(&self) -> &KB::Container
```

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

### Add marker traits to custom bounds

Source: https://docs.rs/typedmap/0.6.0/typedmap/macro.impl_custom_bounds.html

Example of adding marker traits like Send and Sync to the custom bounds implementation.

```rust
impl_custom_bounds!(CustomBounds, DynComponent, Component, +Send+Sync);
```

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

### GET /api/typedmap/is_empty

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Checks if the TypedMap is empty.

```APIDOC
## GET /api/typedmap/is_empty

### Description
Returns true if the map contains no elements.

### Method
GET

### Endpoint
`/api/typedmap/is_empty`

### Response
#### Success Response (200)
- **empty** (bool) - True if the map is empty, false otherwise.

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

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

### GET /api/typedmap/capacity

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Returns the current capacity of the TypedMap.

```APIDOC
## GET /api/typedmap/capacity

### Description
Returns the number of elements the map can hold without reallocating.

### Method
GET

### Endpoint
`/api/typedmap/capacity`

### Response
#### Success Response (200)
- **capacity** (usize) - The current capacity of the map.

#### Response Example
```json
{
  "capacity": 10
}
```
```

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

### GET /api/typedmap/len

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Returns the number of elements currently stored in the TypedMap.

```APIDOC
## GET /api/typedmap/len

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

### Method
GET

### Endpoint
`/api/typedmap/len`

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

#### Response Example
```json
{
  "length": 5
}
```
```

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

### Initialize and Insert into TypedMap

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Demonstrates how to initialize a TypedMap with a specific capacity and insert a key-value pair. Asserts the initial empty state and the state after insertion.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = f32;
}

let mut map: TypedMap = TypedMap::with_capacity(10);
assert!(map.is_empty());
map.insert(Key(3), 4.0);
assert!(!map.is_empty());
```

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

### GET /api/typedmap/contains_key

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Checks if the TypedMap contains a value for the specified key.

```APIDOC
## GET /api/typedmap/contains_key

### Description
Returns true if the map contains a value for the specified key.

### Method
GET

### Endpoint
`/api/typedmap/contains_key`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to check for existence.

### Response
#### Success Response (200)
- **exists** (bool) - True if the key exists in the map, false otherwise.

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

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

### Use CloneBounds with TypedMap

Source: https://docs.rs/typedmap/0.6.0/typedmap/clone/struct.CloneBounds.html

Demonstrates how to use CloneBounds to store cloneable keys and values in a TypedMap, including the use of clone_box for retrieving items.

```rust
use std::sync::Arc;
use typedmap::{TypedMap, TypedMapKey};
use typedmap::clone::{clone_box, CloneBounds};
let mut map: TypedMap::<(), CloneBounds, CloneBounds, _> = TypedMap::default();

#[derive(PartialEq, Eq, Hash, Debug)]
struct Key;

#[derive(Clone, Eq, PartialEq, Hash, Debug)]
struct CloneKey;

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for CloneKey {
    type Value = u32;
}

map.insert(CloneKey, 32);
// Won't compile, because Key is not Clone
// map.insert(Key, 32);

for elem in map.iter() {
    let cloned = clone_box(elem.key_container_ref());
    let key = *cloned.as_any_box().downcast::<CloneKey>().unwrap();
    assert_eq!(key, CloneKey);

    let cloned = clone_box(elem.value_container_ref());
    let value = *cloned.as_any_box().downcast::<u32>().unwrap();
    assert_eq!(value, 32);
}
```

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

### GET /api/typedmap/get_key_value

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Retrieves the key-value pair associated with a given key from the TypedMap.

```APIDOC
## GET /api/typedmap/get_key_value

### Description
Retrieves the key-value pair corresponding to the supplied key.

### Method
GET

### Endpoint
`/api/typedmap/get_key_value`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **key_value_pair** (Option<(&K, &K::Value)>) - A tuple containing the key and a reference to its value if the key exists, otherwise None.

#### Response Example
```json
{
  "key_value_pair": ["<key>", "<value_reference>"]
}
```
```

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

### Blanket Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/bounds/struct.AnyBounds.html

Shows blanket implementations for common traits like `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto` that apply to `AnyBounds`.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
where T: 'static + ?Sized,

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
where T: ?Sized,

#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
where T: ?Sized,

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T
where U: From<T>,

#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

#### type Error = Infallible
The type returned in the event of a conversion error.

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

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

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

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

### GET /api/typedmap/get

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Retrieves a reference to the value associated with a given key from the TypedMap.

```APIDOC
## GET /api/typedmap/get

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

### Method
GET

### Endpoint
`/api/typedmap/get`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **value** (Option<&K::Value>) - A reference to the value if the key exists, otherwise None.

#### Response Example
```json
{
  "value": "<value_reference>"
}
```
```

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

### Get Length of TypedMap

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Returns the number of elements currently stored in the map.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedMap = TypedMap::with_capacity(10);
assert_eq!(map.len(), 0);
map.insert(Key(3), 4);
assert_eq!(map.len(), 1);
```

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

### Get Value from Ref

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Ref.html

Retrieves an immutable reference to the value from a Ref object.

```rust
pub fn value(&self) -> &K::Value

```

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

### TryFrom Trait

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Iter.html

Documentation for the TryFrom trait implementation for type conversion.

```APIDOC
## impl<T, U> TryFrom<U> for T

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

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

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

### Get Key from Ref

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Ref.html

Retrieves an immutable reference to the key from a Ref object.

```rust
pub fn key(&self) -> &K

```

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

### Get Value from RefMut

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.RefMut.html

Retrieves an immutable reference to the value from a RefMut instance.

```rust
pub fn value(&self) -> &K::Value
```

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

### Transformation and Collection

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.ValuesMut.html

Adapters for transforming elements, collecting into collections, and partitioning.

```APIDOC
## Iterator Adapters: Transformation and Collection

### scan<St, B, F>

An iterator adapter which holds internal state and produces a new iterator.

- **initial_state** (St) - The initial state for the scan.
- **f** (FnMut(&mut St, Self::Item) -> Option<B>) - The closure to update state and produce elements.

### flat_map<U, F>

Creates an iterator that works like map, but flattens nested structure.

- **f** (FnMut(Self::Item) -> U) - The closure to transform elements into iterators.

### map_windows<F, R, const N: usize>

Calls a function for each contiguous window of size `N` over `self` and returns an iterator over the outputs.

- **f** (FnMut(&[Self::Item; N]) -> R) - The closure to apply to each window.
- **N** (const usize) - The size of the window.

### collect<B>()

Transforms an iterator into a collection.

- **B** (FromIterator<Self::Item>) - The type of collection to create.

### try_collect<B>()

Fallibly transforms an iterator into a collection, short-circuiting if a failure is encountered.

- **B** (FromIterator<<Self::Item as Try>::Output>) - The type of collection to create.

### collect_into<E>(collection: &mut E)

Collects all the items from an iterator into a mutable collection.

- **collection** (&mut E) - The mutable collection to extend.

### partition<B, F>

Consumes an iterator, creating two collections based on a predicate.

- **f** (FnMut(&Self::Item) -> bool) - The predicate to partition elements.
- **B** (Default + Extend<Self::Item>) - The type of collections to create.

### is_partitioned<P>

Checks if the elements of this iterator are partitioned according to a predicate.

- **predicate** (FnMut(Self::Item) -> bool) - The predicate to check partitioning.

```

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

### Blanket Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/bounds/struct.SyncAnyBounds.html

Shows blanket implementations for common traits like `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto` that apply to `SyncAnyBounds` through generic implementations.

```APIDOC
## Blanket Implementations

This section lists blanket implementations that apply to `SyncAnyBounds` via generic trait bounds.

### `impl<T> Any for T`
- `type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`
- `borrow(&self) -> &T`: Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`
- `borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.

### `impl<T> From<T> for T`
- `from(t: T) -> T`: Returns the argument unchanged.

### `impl<T, U> Into<U> for T where U: From<T>`
- `into(self) -> U`: Calls `U::from(self)`.

### `impl<T, U> TryFrom<U> for T where U: Into<T>`
- `type Error = Infallible`
- `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

### `impl<T, U> TryInto<U> for T where U: TryFrom<T>`
- `type Error = <U as TryFrom<T>>::Error`
- `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

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

### Iterate over TypedDashMap mutably

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.IterMut.html

Example showing how to initialize a TypedDashMap and obtain a mutable iterator.

```rust
use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = u32;
}

let mut map: TypedDashMap = TypedDashMap::new();
map.insert(Key(3), 3);
let iter = map.iter_mut();
```

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

### Insert and Retrieve Values

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

Demonstrates inserting keys and values into a TypedDashMap and handling return values for existing keys.

```rust
use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Debug, Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert!(map.insert(Key(3), 4).is_none());
assert_eq!(map.insert(Key(3), 5), Some(4));
assert_eq!(*map.get(&Key(3)).unwrap(), 5);
```

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

### GET /api/typedmap/get_mut

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Retrieves a mutable reference to the value associated with a given key from the TypedMap.

```APIDOC
## GET /api/typedmap/get_mut

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

### Method
GET

### Endpoint
`/api/typedmap/get_mut`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **value** (Option<&mut K::Value>) - A mutable reference to the value if the key exists, otherwise None.

#### Response Example
```json
{
  "value": "<mutable_value_reference>"
}
```
```

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

### Collecting and Partitioning Iterators

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IterMut.html

Methods for consuming iterators to create collections or partition elements.

```APIDOC
## Iterator Adapters: Collecting and Partitioning

### `collect<B>() -> B`

#### Description
Transforms an iterator into a collection.

#### Method
`collect`

#### Return Value
- **B**: A collection type that implements `FromIterator`.

### `collect_into<E>(collection: &mut E)`

#### Description
Collects all the items from an iterator into a mutable collection.

#### Method
`collect_into`

#### Parameters
- **collection** (&mut E): A mutable reference to a collection that implements `Extend`.

### `partition<B, F>(f: F) -> (B, B)`

#### Description
Consumes an iterator, creating two collections from it based on a predicate.

#### Method
`partition`

#### Parameters
- **f** (F): A closure that takes a reference to an item and returns a boolean.

#### Return Value
- **(B, B)**: A tuple containing two collections.

### `is_partitioned<P>(predicate: P) -> bool`

#### Description
Checks if the elements of this iterator are partitioned according to a predicate.

#### Method
`is_partitioned`

#### Parameters
- **predicate** (P): A closure that takes an item and returns a boolean.
```

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

### TryInto Trait

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Iter.html

Documentation for the TryInto trait implementation for type conversion.

```APIDOC
## impl<T, U> TryInto<U> for T

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

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

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

### Any Trait Implementation

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Ref.html

Implements the Any trait for any type T, providing a way to get the TypeId of the object.

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

```

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

### Blanket Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IterMut.html

Common blanket implementations available for types, including `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `IntoIterator`, `TryFrom`, and `TryInto`.

```APIDOC
## Blanket Implementations

### Description
These are common implementations that apply to many types in Rust, providing fundamental functionalities.

### Implementations

#### `Any`
Allows a type to be downcastable to a specific type at runtime.

- **Method**
  - `type_id(&self) -> TypeId`: Gets the `TypeId` of `self`.

#### `Borrow<T>`
Provides immutable access to a borrowed value.

- **Method**
  - `borrow(&self) -> &T`: Immutably borrows from an owned value.

#### `BorrowMut<T>`
Provides mutable access to a borrowed value.

- **Method**
  - `borrow_mut(&mut self) -> &mut T`: Mutably borrows from an owned value.

#### `From<T>`
Enables conversion from a source type `T` into the target type.

- **Method**
  - `from(t: T) -> T`: Returns the argument unchanged (identity conversion).

#### `Into<U>`
Enables conversion from the source type `T` into a target type `U` where `U: From<T>`.

- **Method**
  - `into(self) -> U`: Calls `U::from(self)`.

#### `IntoIterator`
Allows a type to be converted into an iterator.

- **Associated Types**
  - `Item = <I as Iterator>::Item`: The type of the elements being iterated over.
  - `IntoIter = I`: The type of the iterator itself.
- **Method**
  - `into_iter(self) -> I`: Creates an iterator from a value.

#### `TryFrom<U>`
Enables fallible conversion from a source type `U` into the target type `T`.

- **Associated Type**
  - `Error = Infallible`: The type returned in the event of a conversion error (in this case, infallible, meaning conversion always succeeds).
- **Method**
  - `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.

#### `TryInto<U>`
Enables fallible conversion from the source type `T` into a target type `U` where `U: TryFrom<T>`.

- **Associated Type**
  - `Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.
- **Method**
  - `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.
```

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

### Get Mutable Value from RefMut

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.RefMut.html

Retrieves a mutable reference to the value from a RefMut instance.

```rust
pub fn value_mut(&mut self) -> &mut K::Value
```

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

### TypedMap Core Components

Source: https://docs.rs/typedmap/0.6.0/typedmap/entry/index.html

Overview of the main structs and enums available in the typedmap crate.

```APIDOC
## TypedMap Module

### Summary

Entry for TypedMap.

### Structs

#### OccupiedEntry

Represents an entry in the map that is already occupied.

#### VacantEntry

Represents an entry in the map that is vacant.

### Enums

#### Entry

An enum that can be either an `OccupiedEntry` or a `VacantEntry`.
```

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

### Get Type ID

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashentry/enum.Entry.html

Returns the `TypeId` of the implementing type. This is part of the `Any` trait implementation.

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

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

### Get map length with len

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

Returns the total number of entries currently stored in the map.

```rust
use typedmap::TypedDashMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedDashMap = TypedDashMap::with_capacity(10);
assert_eq!(map.len(), 0);
map.insert(Key(3), 4);
assert_eq!(map.len(), 1);
```

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

### Iterator Aggregation and Comparison Methods

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Iter.html

Methods for calculating sums, products, and comparing iterators.

```APIDOC
## sum

### Description
Sums the elements of an iterator.

### Response
- **S** - The sum of all elements in the iterator.
```

```APIDOC
## product

### Description
Iterates over the entire iterator, multiplying all the elements.

### Response
- **P** - The product of all elements in the iterator.
```

```APIDOC
## eq

### Description
Determines if the elements of this iterator are equal to those of another.

### Parameters
- **other** (IntoIterator) - Required - The other iterator to compare against.

### Response
- **bool** - Returns true if the iterators are equal, false otherwise.
```

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

### Define a TypedMap Key and Initialize Iterator

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Drain.html

Demonstrates how to define a key type for TypedMap and initialize an iterator using the into_iter method.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);

impl TypedMapKey for Key {
	type Value = u32;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
let iter = map.into_iter();
```

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

### Get Value Container Mutable Reference

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedKeyValue.html

Returns a mutable reference to the value's container.

```rust
pub fn value_container_mut(&mut self) -> &mut VB::Container
```

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

### Blanket Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Ref.html

Details blanket implementations for common traits like Any, Borrow, From, Into, Receiver, and TryFrom/TryInto.

```APIDOC
## Blanket Implementations

### Any
Implements the `Any` trait, providing runtime type information.

### Borrow
Implements the `Borrow` trait for immutable borrowing.

### BorrowMut
Implements the `BorrowMut` trait for mutable borrowing.

### From
Implements the `From` trait for conversions into the type.

### Into
Implements the `Into` trait for conversions from the type.

### Receiver
Implements the `Receiver` trait for types that can be dereferenced.

### TryFrom
Implements the `TryFrom` trait for fallible conversions into the type.

### TryInto
Implements the `TryInto` trait for fallible conversions from the type.
```

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

### Ordering Comparisons

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.ValuesMut.html

Methods for checking less than, less than or equal to, greater than, and greater than or equal to.

```APIDOC
## fn lt<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are lexicographically less than those of another.

### Method
`lt`

### Endpoint
N/A (Method on Iterator trait)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (bool)
- `true`: If the iterator is lexicographically less than the other.
- `false`: Otherwise.

#### Response Example
`false`
```

```APIDOC
## fn le<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are lexicographically less than or equal to those of another.

### Method
`le`

### Endpoint
N/A (Method on Iterator trait)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (bool)
- `true`: If the iterator is lexicographically less than or equal to the other.
- `false`: Otherwise.

#### Response Example
`true`
```

```APIDOC
## fn gt<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are lexicographically greater than those of another.

### Method
`gt`

### Endpoint
N/A (Method on Iterator trait)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (bool)
- `true`: If the iterator is lexicographically greater than the other.
- `false`: Otherwise.

#### Response Example
`false`
```

```APIDOC
## fn ge<I>(self, other: I) -> bool

### Description
Determines if the elements of this `Iterator` are lexicographically greater than or equal to those of another.

### Method
`ge`

### Endpoint
N/A (Method on Iterator trait)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (bool)
- `true`: If the iterator is lexicographically greater than or equal to the other.
- `false`: Otherwise.

#### Response Example
`true`
```

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

### Get Key Container Mutable Reference

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedKeyValue.html

Returns a mutable reference to the key's container.

```rust
pub fn key_container_mut(&mut self) -> &mut KB::Container
```

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

### Get Key-Value Pair (Immutable)

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.RefMut.html

Retrieves immutable references to both the key and the value from a RefMut instance.

```rust
pub fn pair(&self) -> (&K, &K::Value)
```

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

### Collection and Partitioning

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IntoIter.html

Methods for transforming iterators into collections or checking partitioning status.

```APIDOC
## fn collect<B>(self) -> B

### Description
Transforms an iterator into a collection.

## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it.

## fn is_partitioned<P>(self, predicate: P) -> bool

### Description
Checks if the elements of this iterator are partitioned according to the given predicate.
```

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

### Get Value Container Reference

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedKeyValueRef.html

Returns an immutable reference to the underlying container holding the values.

```rust
pub fn value_container_ref(&self) -> &VB::Container
```

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

### Bounds Trait Implementation for AnyBounds

Source: https://docs.rs/typedmap/0.6.0/typedmap/bounds/struct.AnyBounds.html

Explains the `Bounds` trait implementation for `AnyBounds`, defining `KeyContainer` and `Container` types, and methods for accessing `Any`.

```APIDOC
## Trait Implementations

### impl Bounds for AnyBounds

#### type KeyContainer = dyn ContainerWithHash<AnyBounds>
Type used to store keys with those bounds. It should be `dyn ContainerWithHash<Self> + Marker traits`.

#### type Container = dyn Any
Type used to store values that fulfill specified bounds (e.g. `dyn Any + Send + Sync` or `dyn CloneAny`).

#### fn as_any(this: &Self::Container) -> &dyn Any

#### fn as_any_mut(this: &mut Self::Container) -> &mut dyn Any

#### fn as_any_box(this: Box<Self::Container>) -> Box<dyn Any>
```

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

### TypedKeyValueGuard Trait Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedKeyValueGuard.html

Demonstrates the trait implementations for TypedKeyValueGuard, including Send, Sync, Freeze, and UnwindSafe.

```APIDOC
## TypedKeyValueGuard Trait Implementations

### `Freeze`
`impl<'a, Marker, KB, VB> Freeze for TypedKeyValueGuard<'a, Marker, KB, VB>`

### `!RefUnwindSafe`
`impl<'a, Marker, KB, VB> !RefUnwindSafe for TypedKeyValueGuard<'a, Marker, KB, VB>`

### `Send`
`impl<'a, Marker, KB, VB> Send for TypedKeyValueGuard<'a, Marker, KB, VB>`
where Marker: Send, <KB as Bounds>::KeyContainer: Sync, <VB as Bounds>::Container: Sync,

### `Sync`
`impl<'a, Marker, KB, VB> Sync for TypedKeyValueGuard<'a, Marker, KB, VB>`
where Marker: Sync, <KB as Bounds>::KeyContainer: Sync, <VB as Bounds>::Container: Sync,

### `Unpin`
`impl<'a, Marker, KB, VB> Unpin for TypedKeyValueGuard<'a, Marker, KB, VB>`
where Marker: Unpin,

### `!UnwindSafe`
`impl<'a, Marker, KB, VB> !UnwindSafe for TypedKeyValueGuard<'a, Marker, KB, VB>`
```

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

### From and Into Conversions

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Keys.html

Enables conversions between types using the `From` and `Into` traits.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged. This is the implementation for `impl<T> From<T> for T`.

### Method
GET

### Endpoint
N/A (Associated function)

## fn into(self) -> U

### Description
Calls `U::from(self)`. This is the implementation for `impl<T, U> Into<U> for T where U: From<T>`.

### Method
GET

### Endpoint
N/A (Method on a struct)
```

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

### TypedDashMap Operations

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

This section covers common operations for the TypedDashMap, including getting, inserting, and checking for keys.

```APIDOC
## GET /api/typedmap/get

### Description
Retrieves an entry from the map based on the provided key.

### Method
GET

### Endpoint
`/api/typedmap/get`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to look up in the map.

### Response
#### Success Response (200)
- **value** (K::Value) - The value associated with the key, if found.

#### Response Example
```json
{
  "value": 4
}
```
```

```APIDOC
## POST /api/typedmap/insert

### Description
Inserts a key-value pair into the map.

### Method
POST

### Endpoint
`/api/typedmap/insert`

### Request Body
- **key** (K) - Required - The key to insert.
- **value** (K::Value) - Required - The value to associate with the key.

### Response
#### Success Response (200)
- **message** (string) - Confirmation of successful insertion.

#### Response Example
```json
{
  "message": "Key-value pair inserted successfully."
}
```
```

```APIDOC
## GET /api/typedmap/contains_key

### Description
Checks if the map contains a specific key.

### Method
GET

### Endpoint
`/api/typedmap/contains_key`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key to check for.

### Response
#### Success Response (200)
- **contains** (boolean) - True if the key exists in the map, false otherwise.

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

```APIDOC
## DELETE /api/typedmap/remove

### Description
Removes an entry from the map based on the provided key.

### Method
DELETE

### Endpoint
`/api/typedmap/remove`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key of the entry to remove.

### Response
#### Success Response (200)
- **removed** (boolean) - True if the entry was removed, false otherwise.
- **key** (K) - The removed key, if an entry was present.
- **value** (K::Value) - The removed value, if an entry was present.

#### Response Example
```json
{
  "removed": true,
  "key": "some_key",
  "value": "some_value"
}
```
```

```APIDOC
## DELETE /api/typedmap/remove_if

### Description
Removes an entry from the map if a provided conditional function returns true.

### Method
DELETE

### Endpoint
`/api/typedmap/remove_if`

### Parameters
#### Query Parameters
- **key** (K) - Required - The key of the entry to potentially remove.
- **condition** (function) - Required - A function that takes the key and value and returns true if the entry should be removed.

### Response
#### Success Response (200)
- **removed** (boolean) - True if the entry was removed, false otherwise.
- **key** (K) - The removed key, if an entry was present and removed.
- **value** (K::Value) - The removed value, if an entry was present and removed.

#### Response Example
```json
{
  "removed": true,
  "key": "some_key",
  "value": "some_value"
}
```
```

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

### Min/Max Comparison Methods

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.IterMut.html

Methods for finding the minimum or maximum elements based on keys or comparison functions.

```APIDOC
## fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that gives the maximum value from the specified function.

## fn max_by<F>(self, compare: F) -> Option<Self::Item>

### Description
Returns the element that gives the maximum value with respect to the specified comparison function.

## fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

### Description
Returns the element that gives the minimum value from the specified function.

## fn min_by<F>(self, compare: F) -> Option<Self::Item>

### Description
Returns the element that gives the minimum value with respect to the specified comparison function.
```

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

### Get Key-Value Pair from Ref

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.Ref.html

Retrieves immutable references to both the key and the value from a Ref object as a tuple.

```rust
pub fn pair(&self) -> (&K, &K::Value)

```

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

### Iterate Over TypedMap Keys

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Shows how to iterate over the keys of a TypedMap. Each key is a `&dyn Any` and needs to be downcast to its specific type to be used.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq, Debug)]
struct Key(usize);
#[derive(Hash, PartialEq, Eq, Debug)]
struct SKey(&'static str);

impl TypedMapKey for Key {
    type Value = u32;
}

impl TypedMapKey for SKey {
    type Value = usize;
}

let mut map: TypedMap = TypedMap::new();
map.insert(Key(3), 3);
map.insert(SKey("four"), 4);

for key in map.keys() {
    let mut found = false;
    if let Some(Key(number)) = key.downcast_ref::<Key>() {
        assert_eq!(*number, 3);
        found = true;
    }
    if let Some(SKey(a_str)) = key.downcast_ref::<SKey>() {
        assert_eq!(*a_str, "four");
        found = true;
    }
    assert!(found);
}
```

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

### Define impl_custom_bounds_with_key_container macro

Source: https://docs.rs/typedmap/0.6.0/typedmap/macro.impl_custom_bounds_with_key_container.html

Macro definition for implementing custom bounds with a key container.

```rust
macro_rules! impl_custom_bounds_with_key_container {
    ($bounds:ident, $dyn:ident, $key_container:ty, $trait_name:ident) => { ... };
    ($bounds:ident, $dyn:ident, $key_container:ty, $trait_name:ident, $(+ $marker_traits:ident)*) => { ... };
}
```

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

### TryFrom and TryInto Implementations

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.ValuesMut.html

Defines fallible conversion traits for the TypedMap library.

```APIDOC
## TryFrom Implementation

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

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

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

## TryInto Implementation

### Description
Performs a fallible conversion into type U.

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

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

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

### Get Capacity of TypedMap

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Returns the number of elements the map can hold without needing to reallocate its internal storage.

```rust
use typedmap::TypedMap;

let map: TypedMap = TypedMap::with_capacity(10);
assert!(map.capacity() >= 10);
```

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

### TryFrom and TryInto Conversions

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.Keys.html

Enables fallible conversions between types using the `TryFrom` and `TryInto` traits.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error. For `TryFrom<U> for T` where `U: Into<T>`, this is `Infallible` as the conversion is always successful.

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

### Description
Performs the conversion. Read more.

### Method
GET

### Endpoint
N/A (Associated function)

## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

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

### Description
Performs the conversion. Read more.

### Method
GET

### Endpoint
N/A (Method on a struct)
```

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

### Get Value from TypedMap

Source: https://docs.rs/typedmap/0.6.0/typedmap/hashmap/struct.TypedMap.html

Retrieves a reference to the value associated with a given key. Returns None if the key is not found.

```rust
use typedmap::TypedMap;
use typedmap::TypedMapKey;

#[derive(Hash, PartialEq, Eq)]
struct Key(usize);

impl TypedMapKey for Key {
    type Value = usize;
}

let mut map: TypedMap = TypedMap::with_capacity(10);
map.insert(Key(3), 4);
assert_eq!(map.get(&Key(3)), Some(&4));
assert_eq!(map.get(&Key(4)), None);
```

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

### TypedDashMap Constructors

Source: https://docs.rs/typedmap/0.6.0/typedmap/dashmap/struct.TypedDashMap.html

Provides details on how to create new instances of TypedDashMap.

```APIDOC
## TypedDashMap Constructors

### `fn new<Marker>() -> Self`

Creates a new `TypedDashMap` with a specified marker type.

#### Parameters

* `Marker` - The type used to differentiate key-value mappings.

### `fn new_with_bounds<Marker, KB, VB>() -> Self`

Creates a new `TypedDashMap` with specified marker, key bounds, and value bounds.

### `fn with_capacity<Marker>(capacity: usize) -> Self`

Creates a new `TypedDashMap` with a specified capacity and marker type.

#### Parameters

* `capacity` - The initial capacity of the map.

### `fn with_capacity_and_hasher<Marker, KB, VB, S>(capacity: usize, hash_builder: S) -> Self`

Creates a new `TypedDashMap` with specified capacity, hasher, and marker type.

#### Parameters

* `capacity` - The initial capacity of the map.
* `hash_builder` - The hash builder to use for the map.

### `fn with_hasher<Marker, KB, VB, S>(hash_builder: S) -> Self`

Creates a new `TypedDashMap` with a specified hasher and marker type.

#### Parameters

* `hash_builder` - The hash builder to use for the map.
```
Tokens:
Raw