Dashmap

https://docs.rs/dashmap/latest
Admin
Dashmap is a concurrent associative array/hashmap implementation in Rust, providing thread-safe...
Tokens:348,786
Snippets:2,935
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Test DashMap get and try_get_mut

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=

Demonstrates how to retrieve values using get and check for mutable access with try_get_mut. Asserts that the entry is locked when using try_get_mut.

```rust
let _result1_locking = map.get("Johnny");

            let result2 = map.try_get_mut("Johnny");
            assert!(result2.is_locked());
```

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

### get

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html

Get a reference to an entry in the set.

```APIDOC
## get

### Description
Get a reference to an entry in the set.

### Method
`get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K>>`

### Parameters
#### Path Parameters
- **key** (*&Q*) - Description: The key to retrieve a reference to.

### Example
```rust
use dashmap::DashSet;

let youtubers = DashSet::new();
youtubers.insert("Bosnian Bill");
assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");
```
```

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

### get

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html?search=

Get a reference to an entry in the set.

```APIDOC
## get

### Description
Get a reference to an entry in the set.

### Method
`get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K>>`

### Parameters
#### Path Parameters
- **key** (*&Q*) - The key to retrieve a reference to.

### Example
```rust
use dashmap::DashSet;

let youtubers = DashSet::new();
youtubers.insert("Bosnian Bill");
assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");
```
```

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

### Basic Iter usage example

Source: https://docs.rs/dashmap/latest/dashmap/iter/struct.Iter.html?search=

Demonstrates how to create a DashMap, insert an element, and use the iter() method to count the number of elements.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("hello", "world");
assert_eq!(map.iter().count(), 1);
```

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

### DashMap::with_capacity

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Creates a new DashMap with a specified starting capacity.

```APIDOC
## DashMap::with_capacity

### Description
Creates a new DashMap with a specified starting capacity.

### Method
`DashMap::with_capacity(capacity: usize)`

### Parameters
* `capacity` (usize) - The initial capacity of the DashMap.

### Returns
A new `DashMap` with the specified capacity.

### Examples
```rust
use dashmap::DashMap;

let mappings = DashMap::with_capacity(2);
mappings.insert(2, 4);
mappings.insert(8, 16);
```
```

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

### DashSet::with_capacity

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html

Creates a new DashSet with a specified starting capacity. It uses the default hasher.

```APIDOC
## DashSet::with_capacity

### Description
Creates a new DashSet with a specified starting capacity. It uses the default hasher.

### Method
`DashSet::with_capacity(capacity: usize)`

### Parameters
* `capacity` (usize) - The initial capacity of the DashSet.

### Returns
A new `DashSet<K, S>` with the specified capacity.

### Example
```rust
use dashmap::DashSet;

let numbers = DashSet::with_capacity(2);
numbers.insert(2);
numbers.insert(8);
```
```

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

### DashMap::with_capacity_and_hasher

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Creates a new DashMap with a specified starting capacity and hasher.

```APIDOC
## DashMap::with_capacity_and_hasher

### Description
Creates a new DashMap with a specified starting capacity and hasher.

### Method
`DashMap::with_capacity_and_hasher(capacity: usize, hasher: S)`

### Parameters
* `capacity` (usize) - The initial capacity of the DashMap.
* `hasher` (S) - The hash builder to use for the DashMap.

### Returns
A new `DashMap` with the specified capacity and hasher.

### Examples
```rust
use dashmap::DashMap;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher(2, s);
mappings.insert(2, 4);
mappings.insert(8, 16);
```
```

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

### DashMap::with_capacity_and_hasher_and_shard_amount

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Creates a new DashMap with a specified starting capacity, hasher and shard_amount.

```APIDOC
## DashMap::with_capacity_and_hasher_and_shard_amount

### Description
Creates a new DashMap with a specified starting capacity, hasher and shard_amount.
`shard_amount` should be greater than 0 and be a power of two. If a `shard_amount` which is not a power of two is provided, the function will panic.

### Method
`DashMap::with_capacity_and_hasher_and_shard_amount(capacity: usize, hasher: S, shard_amount: usize)`

### Parameters
* `capacity` (usize) - The initial capacity of the DashMap.
* `hasher` (S) - The hash builder to use for the DashMap.
* `shard_amount` (usize) - The number of shards to use for the DashMap. Must be a power of two.

### Returns
A new `DashMap` with the specified capacity, hasher, and shard amount.

### Examples
```rust
use dashmap::DashMap;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher_and_shard_amount(2, s, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
```
```

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

### Insert and Get Elements in DashSet

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html?search=u32+-%3E+bool

Demonstrates basic insertion and retrieval of elements in a DashSet. Ensures that inserted elements can be retrieved successfully.

```rust
use dashmap::DashSet;

let set = DashSet::new();

set.insert(0);

assert_eq!(set.get(&0).as_deref(), Some(&0));
```

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

### Get Methods

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for retrieving values associated with a key. `_get` and `_get_mut` provide direct access, while `_try_get` and `_try_get_mut` offer non-blocking attempts.

```APIDOC
## `_get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>`

### Description
Retrieves an immutable reference to the value associated with the given key.

### Parameters
- `key`: The key to search for.

### Returns
An `Option<Ref<'a, K, V>>` which is `Some` if the key exists, containing an immutable reference to the value, or `None` otherwise.

## `_get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>`

### Description
Retrieves a mutable reference to the value associated with the given key.

### Parameters
- `key`: The key to search for.

### Returns
An `Option<RefMut<'a, K, V>>` which is `Some` if the key exists, containing a mutable reference to the value, or `None` otherwise.

## `_try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>`

### Description
Attempts to retrieve an immutable reference to the value associated with the given key without blocking.

### Parameters
- `key`: The key to search for.

### Returns
A `TryResult<Ref<'a, K, V>>` which can be `TryResult::Present` with an immutable reference if the key exists and the shard is not locked, `TryResult::Absent` if the key does not exist, or `TryResult::Locked` if the shard is currently locked.

## `_try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>`

### Description
Attempts to retrieve a mutable reference to the value associated with the given key without blocking.

### Parameters
- `key`: The key to search for.

### Returns
A `TryResult<RefMut<'a, K, V>>` which can be `TryResult::Present` with a mutable reference if the key exists and the shard is not locked, `TryResult::Absent` if the key does not exist, or `TryResult::Locked` if the shard is currently locked.
```

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

### ReadOnlyView Search Examples

Source: https://docs.rs/dashmap/latest/dashmap/struct.ReadOnlyView.html?search=

Demonstrates various ways to search within a ReadOnlyView, illustrating common patterns and type conversions.

```APIDOC
## Search Examples

This section provides examples of how to search within a `ReadOnlyView` of a DashMap.

### Example Searches

*   `std::vec`
*   `u32 -> bool`
*   `Option<T>, (T -> U) -> Option<U>`
```

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

### Example: Get Shard Count

Source: https://docs.rs/dashmap/latest/dashmap/struct.ReadOnlyView.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to obtain the number of shards in a ReadOnlyView. This requires the `raw-api` feature.

```rust
use dashmap::DashMap;

let map = DashMap::<(), ()>::new().into_read_only();
println!("Amount of shards: {}", map.shards().len());
```

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

### RwLock Creation

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLock.html?search=u32+-%3E+bool

Demonstrates how to create a new RwLock instance with initial data.

```APIDOC
## `RwLock::new`

### Description
Creates a new instance of an `RwLock<T>` which is unlocked.

### Method
`new`

### Parameters
- `val` (T) - The initial value to be protected by the RwLock.

### Returns
A new `RwLock<R, T>` instance.
```

```APIDOC
## `RwLock::from_raw`

### Description
Creates a new instance of an `RwLock<T>` based on a pre-existing `RawRwLock<T>`.

### Method
`from_raw`

### Parameters
- `raw_rwlock` (R) - The raw lock implementation.
- `val` (T) - The initial value to be protected by the RwLock.

### Returns
A new `RwLock<R, T>` instance.
```

```APIDOC
## `RwLock::const_new`

### Description
Creates a new instance of an `RwLock<T>` based on a pre-existing `RawRwLock<T>`.
This allows creating a `RwLock<T>` in a constant context on stable Rust.
This method is a legacy alias for `from_raw`.

### Method
`const_new`

### Parameters
- `raw_rwlock` (R) - The raw lock implementation.
- `val` (T) - The initial value to be protected by the RwLock.

### Returns
A new `RwLock<R, T>` instance.
```

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

### DashMap Initialization with Default

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html

Shows how to create a DashMap using its default implementation, which is equivalent to calling `DashMap::new()`. It then proceeds to insert and retrieve a value.

```rust
let dm: DashMap<u32, u32> = DashMap::default();

dm.insert(0, 0);

assert_eq!(dm.get(&0).unwrap().value(), &0);
```

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

### Create DashSet using default

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html

Demonstrates creating an empty DashSet using the `default()` method.

```rust
let set: DashSet<u32> = DashSet::default();
```

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

### Get

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html

Gets a reference to the value associated with a key.

```APIDOC
## _get

### Description
Gets a reference to the value associated with a key.

### Method
`&'a self, key: &Q`

### Type Parameters
- `Q`: The type to compare the key with.

### Where Clause
`K: Borrow<Q>, Q: Hash + Eq + ?Sized`

### Returns
`Option<Ref<'a, K, V>>` - An optional reference to the value.
```

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

### type Init = T

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The type for initializers.

```APIDOC
## type Init = T

### Description
The type for initializers.

### Method
`Init`

### Parameters
None

### Returns
T
```

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

### Try Get

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html

Attempts to get a reference to the value associated with a key, returning a TryResult.

```APIDOC
## _try_get

### Description
Attempts to get a reference to the value associated with a key, returning a TryResult.

### Method
`&'a self, key: &Q`

### Type Parameters
- `Q`: The type to compare the key with.

### Where Clause
`K: Borrow<Q>, Q: Hash + Eq + ?Sized`

### Returns
`TryResult<Ref<'a, K, V>>` - A TryResult containing an optional reference to the value.
```

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

### Create a DashSet with initial capacity

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html?search=

Use `DashSet::with_capacity(capacity)` to create a DashSet with a specified starting capacity, which can improve performance by pre-allocating memory.

```rust
use dashmap::DashSet;

let numbers = DashSet::with_capacity(2);
numbers.insert(2);
numbers.insert(8);
```

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

### IterMut Usage Example

Source: https://docs.rs/dashmap/latest/dashmap/iter/struct.IterMut.html?search=std%3A%3Avec

This example demonstrates how to use IterMut to iterate over a DashMap and modify its values.

```APIDOC
## Example Usage

This example shows how to obtain a mutable iterator from a `DashMap` and use it to modify the values.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("Johnny", 21);

// Get a mutable iterator and increment each value
map.iter_mut().for_each(|mut r| *r += 1);

// Verify the value has been updated
assert_eq!(*map.get("Johnny").unwrap(), 22);
```
```

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

### unsafe fn init(init: <T as Pointable>::Init) -> usize

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a with the given initializer.

```APIDOC
## unsafe fn init(init: <T as Pointable>::Init) -> usize

### Description
Initializes a with the given initializer.

### Method
`init`

### Parameters
- **init** (<T as Pointable>::Init) - The initializer value.

### Returns
`usize` (pointer to the initialized memory)
```

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

### Get Entry from DashMap

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html

Retrieves an entry from the DashMap. Use `get` for immutable access and `try_get_mut` for mutable access, checking if the entry is locked.

```rust
let _result1_locking = map.get("Johnny");

let result2 = map.try_get_mut("Johnny");
assert!(result2.is_locked());
```

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

### Testing Read-Only View Get Operations

Source: https://docs.rs/dashmap/latest/src/dashmap/read_only.rs.html

Ensures that `get` and `get_key_value` methods on the read-only view return correct values and that `contains_key` works as expected.

```rust
let map = construct_sample_map();

        let view = map.clone().into_read_only();

        for key in map.iter().map(|entry| *entry.key()) {
            assert!(view.contains_key(&key));

            let map_entry = map.get(&key).unwrap();

            assert_eq!(view.get(&key).unwrap(), map_entry.value());

            let key_value: (&i32, &String) = view.get_key_value(&key).unwrap();

            assert_eq!(key_value.0, map_entry.key());

            assert_eq!(key_value.1, map_entry.value());
        }
```

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

### Constructing a Sample DashMap

Source: https://docs.rs/dashmap/latest/src/dashmap/read_only.rs.html

A helper function to create a DashMap with sample key-value pairs for testing purposes.

```rust
fn construct_sample_map() -> DashMap<i32, String> {
        let map = DashMap::new();

        map.insert(1, "one".to_string());

        map.insert(10, "ten".to_string());

        map.insert(27, "twenty seven".to_string());

        map.insert(45, "forty five".to_string());

        map
    }
```

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

### ReadOnlyView Get Operations

Source: https://docs.rs/dashmap/latest/src/dashmap/read_only.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to retrieve values associated with a key. `get` returns a reference to the value, while `get_key_value` returns references to both the key and the value.

```rust
    /// Returns a reference to the value corresponding to the key.
    pub fn get<Q>(&'a self, key: &Q) -> Option<&'a V>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + ?Sized,
    {
        self.get_key_value(key).map(|(_k, v)| v)
    }

    /// Returns the key-value pair corresponding to the supplied key.
    pub fn get_key_value<Q>(&'a self, key: &Q) -> Option<(&'a K, &'a V)>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + ?Sized,
    {
        let hash = self.map.hash_u64(&key);

        let idx = self.map.determine_shard(hash as usize);

        let shard = unsafe { self.map._get_read_shard(idx) };

        shard.find(hash, |(k, _v)| key == k.borrow()).map(|b| {
            let (k, v) = unsafe { b.as_ref() };
            (k, v.get())
        })
    }
```

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

### Create a DashMap with initial capacity

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Use `DashMap::with_capacity(capacity)` to create a DashMap with a pre-allocated capacity. This can improve performance by reducing reallocations if the approximate size is known beforehand.

```rust
use dashmap::DashMap;

let mappings = DashMap::with_capacity(2);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

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

### DashMap with Custom Hasher (RandomState)

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html

Shows how to initialize a DashMap with a specific hasher, in this case, `RandomState` from the standard library. It then performs insertions and retrievals.

```rust
let dm_hm_default: DashMap<u32, u32, RandomState> = 
    DashMap::with_hasher(RandomState::new());

for i in 0..10 {
    dm_hm_default.insert(i, i);

    assert_eq!(i, *dm_hm_default.get(&i).unwrap().value());
}
```

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

### Get a reference to an element in the DashSet

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html?search=

Use `get()` to retrieve an immutable reference to a key if it exists in the set. This is useful for reading values without modifying them.

```rust
use dashmap::DashSet;

let youtubers = DashSet::new();
youtubers.insert("Bosnian Bill");
assert_eq!(*youtubers.get("Bosnian Bill").unwrap(), "Bosnian Bill");
```

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

### Create a DashMap with capacity, hasher, and shard amount

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Use `DashMap::with_capacity_and_hasher_and_shard_amount(capacity, hasher, shard_amount)` to create a DashMap with precise control over initial capacity, hashing, and sharding. The `shard_amount` must be a power of two and greater than 0.

```rust
use dashmap::DashMap;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher_and_shard_amount(2, s, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

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

### CloneToUninit

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=

Nightly-only experimental API for cloning data into uninitialized memory.

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

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Parameters
- `dest` (*mut u8): A mutable pointer to the destination memory.

### Safety
This function is unsafe as it requires careful management of memory and pointers.
```

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

### Get Element from Read-Only View

Source: https://docs.rs/dashmap/latest/src/dashmap/read_only.rs.html?search=

Illustrates retrieving elements from a read-only view using `get()` and `get_key_value()`. It confirms that the retrieved values match those in the original map.

```rust
assert!(view.contains_key(&key));
let map_entry = map.get(&key).unwrap();
assert_eq!(view.get(&key).unwrap(), map_entry.value());
let key_value: (&i32, &String) = view.get_key_value(&key).unwrap();
assert_eq!(key_value.0, map_entry.key());
assert_eq!(key_value.1, map_entry.value());
```

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

### RawRwLock::INIT

Source: https://docs.rs/dashmap/latest/dashmap/struct.RawRwLock.html?search=std%3A%3Avec

Provides the initial value for an unlocked RawRwLock.

```APIDOC
## RawRwLock::INIT

### Description
Initial value for an unlocked `RwLock`.

### Type
`Self`
```

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

### Entry Management

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=std%3A%3Avec

Provides methods for accessing and manipulating entries within the DashMap. These include methods for getting an entry, trying to get an entry, and accessing the underlying hasher.

```APIDOC
## `_entry`

### Description
Retrieves an `Entry` for the given key, which allows for conditional manipulation of the map based on the key's presence.

### Method
`_entry(key: K) -> Entry<'a, K, V>`

### Parameters
- **key** (K) - The key to look up.

### Returns
An `Entry` enum, which can be either `Occupied` or `Vacant`.
```

```APIDOC
## `_try_entry`

### Description
Attempts to retrieve an `Entry` for the given key. Returns `None` if the shard cannot be acquired.

### Method
`_try_entry(key: K) -> Option<Entry<'a, K, V>>`

### Parameters
- **key** (K) - The key to look up.

### Returns
An `Option<Entry>` which is `Some(Entry)` if the shard was acquired, or `None` otherwise.
```

```APIDOC
## `_hasher`

### Description
Returns a clone of the `BuildHasher` used by the `DashMap`.

### Method
`_hasher() -> S`

### Returns
A clone of the `BuildHasher`.
```

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

### Create a DashMap with capacity and shard amount

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Use `DashMap::with_capacity_and_shard_amount(capacity, shard_amount)` to create a DashMap with both a specified initial capacity and shard count. The `shard_amount` must be a power of two and greater than 0.

```rust
use dashmap::DashMap;

let mappings = DashMap::with_capacity_and_shard_amount(32, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

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

### Entry Management

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for accessing and manipulating entries within the DashMap. These include methods to get an entry, try to get an entry, and check for the existence of a key.

```APIDOC
## `_entry`

### Description
Retrieves an `Entry` for the given key, allowing for conditional manipulation of the map's contents.

### Signature
`fn _entry(&'a self, key: K) -> Entry<'a, K, V>`

## `_try_entry`

### Description
Attempts to retrieve an `Entry` for the given key, returning `None` if the shard cannot be acquired.

### Signature
`fn _try_entry(&'a self, key: K) -> Option<Entry<'a, K, V>>`

## `_hasher`

### Description
Returns a clone of the `BuildHasher` used by the `DashMap`.

### Signature
`fn _hasher(&self) -> S`

## `insert` (via `Shl` trait)

### Description
Inserts a key-value pair into the map. If the map did not have this key present, `None` is returned. If the map did have this key present, the value is updated, and the old value is returned.

### Signature
`fn shl(self, pair: (K, V)) -> Option<V>`

## `get` (via `Shr` trait)

### Description
Returns a reference to the value corresponding to the key. The entry is unwrapped, panicking if the key is not found.

### Signature
`fn shr(self, key: &Q) -> Ref<'a, K, V>`

## `get_mut` (via `Bitor` trait)

### Description
Returns a mutable reference to the value corresponding to the key. The entry is unwrapped, panicking if the key is not found.

### Signature
`fn bitor(self, key: &Q) -> RefMut<'a, K, V>`

## `remove` (via `Sub` trait)

### Description
Removes a key from the map, returning the value at the key if the key was previously in the map.

### Signature
`fn sub(self, key: &Q) -> Option<(K, V)>`

## `contains_key` (via `BitAnd` trait)

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

### Signature
`fn bitand(self, key: &Q) -> bool`
```

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

### Default

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html?search=std%3A%3Avec

Provides a way to create a default DashSet instance.

```APIDOC
## default() -> Self

### Description
Returns the “default value” for a type.

### Method
`default`

### Returns
A new, empty DashSet instance.
```

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

### Try Get Mutable Reference (Non-Blocking)

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Attempts to get a mutable reference without blocking. Returns TryResult::Locked if the shard is currently held by another operation.

```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

*map.try_get_mut("Johnny").unwrap() += 1;
assert_eq!(*map.get("Johnny").unwrap(), 22);

let _result1_locking = map.get("Johnny");

let result2 = map.try_get_mut("Johnny");
assert!(result2.is_locked());
```

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

### Try Get Immutable Reference (Non-Blocking)

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Attempts to get an immutable reference without blocking. Returns TryResult::Locked if the shard is currently held by another operation.

```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

assert_eq!(*map.try_get("Johnny").unwrap(), 21);

let _result1_locking = map.get_mut("Johnny");

let result2 = map.try_get("Johnny");
assert!(result2.is_locked());
```

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

### RwLock::new

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLock.html

Creates a new, unlocked instance of `RwLock<T>`.

```APIDOC
## RwLock::new

### Description
Creates a new instance of an `RwLock<T>` which is unlocked.

### Method
`new`

### Parameters
* **val** (`T`) - The value to be protected by the `RwLock`.

### Returns
`RwLock<R, T>`
```

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

### Rust Search Example: Option<T>, (T -> U) -> Option<U>

Source: https://docs.rs/dashmap/latest/src/dashmap/setref/mod.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates a common search pattern for Rust types, focusing on the Option enum and function type transformations.

```rust
Option<T>, (T -> U) -> Option<U>
```

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

### Accessing Key and Value

Source: https://docs.rs/dashmap/latest/dashmap/mapref/multiple/struct.RefMutMulti.html?search=std%3A%3Avec

Provides methods to immutably access the key and value of the referenced pair. Use `key()` to get a reference to the key and `value()` to get a reference to the value.

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

```rust
pub fn value(&self) -> &V
```

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

### impl<T> CloneToUninit for T

Source: https://docs.rs/dashmap/latest/dashmap/iter/struct.Iter.html

Experimental (nightly-only) implementation of `CloneToUninit` for types that implement `Clone`. This allows cloning into uninitialized memory.

```APIDOC
## impl<T> CloneToUninit for T

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

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. This unsafe method is used for cloning data into uninitialized memory locations.
```

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

### fn type_id(&self) -> TypeId

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the `TypeId` of `self`.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Returns
`TypeId`
```

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

### Create a DashSet with capacity and custom hasher

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html?search=

Use `DashSet::with_capacity_and_hasher(capacity, hasher)` to create a DashSet with both a specified capacity and a custom hasher.

```rust
use dashmap::DashSet;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let numbers = DashSet::with_capacity_and_hasher(2, s);
numbers.insert(2);
numbers.insert(8);
```

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

### Get

Source: https://docs.rs/dashmap/latest/dashmap/trait.Map.html?search=std%3A%3Avec

Retrieves an immutable reference to the value associated with a key.

```APIDOC
## _get

### Description
Retrieves an immutable reference to the value associated with the given key. Returns `None` if the key is not found.

### Method
`_get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>`

### Parameters
#### Path Parameters
- `key` (Q): The key to look up. `Q` must be borrowable from `K`.

### Returns
- `Option<Ref<'a, K, V>>`: An `Option` containing a reference to the value if found, otherwise `None`.
```

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

### DashSet::new

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html

Creates a new, empty DashSet with a default capacity.

```APIDOC
## DashSet::new

### Description
Creates a new DashSet with a capacity of 0.

### Method
`new()`

### Returns
A new `DashSet` instance.

### Examples
```rust
use dashmap::DashSet;

let games = DashSet::new();
games.insert("Veloren");
```
```

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

### impl<T> Any for T

Source: https://docs.rs/dashmap/latest/dashmap/mapref/one/struct.Ref.html?search=std%3A%3Avec

Provides a `type_id` method to get the `TypeId` of an object.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.
```

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

### DashSet::new

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashSet.html?search=

Creates a new, empty DashSet with a default capacity.

```APIDOC
## DashSet::new

### Description
Creates a new DashSet with a capacity of 0.

### Method
`new()`

### Parameters
None

### Returns
A new, empty `DashSet`.

### Examples
```rust
use dashmap::DashSet;

let games = DashSet::new();
games.insert("Veloren");
```
```

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

### Get Operations

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html

Methods for retrieving values associated with a given key.

```APIDOC
## _get

### Description
Retrieves an immutable reference to the value corresponding to the key. Returns `None` if the key is not found.

### Signature
```rust
fn _get<Q>(&'a self, key: &Q) -> Option<Ref<'a, K, V>>
where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,
```

## _get_mut

### Description
Retrieves a mutable reference to the value corresponding to the key. Returns `None` if the key is not found.

### Signature
```rust
fn _get_mut<Q>(&'a self, key: &Q) -> Option<RefMut<'a, K, V>>
where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,
```

## _try_get

### Description
Attempts to retrieve an immutable reference to the value. Returns `TryResult::Locked` if the shard is locked, `TryResult::Absent` if the key is not found, or `TryResult::Present` with a reference if found.

### Signature
```rust
fn _try_get<Q>(&'a self, key: &Q) -> TryResult<Ref<'a, K, V>>
where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,
```

## _try_get_mut

### Description
Attempts to retrieve a mutable reference to the value. Returns `TryResult::Locked` if the shard is locked, `TryResult::Absent` if the key is not found, or `TryResult::Present` with a mutable reference if found.

### Signature
```rust
fn _try_get_mut<Q>(&'a self, key: &Q) -> TryResult<RefMut<'a, K, V>>
where
    K: Borrow<Q>,
    Q: Hash + Eq + ?Sized,
```
```

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

### Get Mut

Source: https://docs.rs/dashmap/latest/dashmap/trait.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a mutable reference to the value associated with a key.

```APIDOC
## _get_mut

### Description
Retrieves a mutable reference to the value associated with the given key. Returns `None` if the key is not found in the map.

### Parameters
- `key` (`&Q`): The key to look up.

### Type Parameters
- `Q`: The type to compare the key with.

### Returns
- `Option<RefMut<'a, K, V>>`: A mutable reference to the value if the key exists, otherwise `None`.
```

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

### Display Implementation

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLockWriteGuard.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a Display implementation for RwLockWriteGuard, allowing it to be formatted for display.

```APIDOC
impl<'a, R, T> Display for RwLockWriteGuard<'a, R, T>
where R: RawRwLock + 'a,
      T: Display + 'a + ?Sized
```

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

### get

Source: https://docs.rs/dashmap/latest/dashmap/struct.ReadOnlyView.html?search=std%3A%3Avec

Retrieves a reference to the value associated with a given key, if it exists.

```APIDOC
## get

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

### Method
`get(key: &Q) -> Option<&'a V>`

### Parameters
- **key** (`&Q`): The key to look up.
  - `K: Borrow<Q>`
  - `Q: Hash + Eq + ?Sized`

### Response
- `Option<&'a V>`: An `Option` containing a reference to the value if the key is found, otherwise `None`.
```

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

### Create a DashMap with capacity and custom hasher

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Use `DashMap::with_capacity_and_hasher(capacity, hasher)` to create a DashMap with a specified initial capacity and a custom hashing algorithm. This allows for fine-grained control over map initialization and hashing.

```rust
use dashmap::DashMap;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mappings = DashMap::with_capacity_and_hasher(2, s);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

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

### Get element from DashSet

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html

Shows how to retrieve an element from the DashSet using its key.

```rust
assert_eq!(set.get(&0).as_deref(), Some(&0));
```

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

### Use DashMap TryGet Method

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=

Illustrates the `try_get` method for non-blocking retrieval of a value, and `try_get_mut` for mutable access.

```Rust
{ 
    let map = DashMap::new();
    map.insert("Johnny", 21);

    assert_eq!(*map.try_get("Johnny").unwrap(), 21);

    let _result1_locking = map.get_mut("Johnny");

    let result2 = map.try_get("Johnny");
    assert!(result2.is_locked());
}

{
    let map = DashMap::new();
    map.insert("Johnny", 21);

    *map.try_get_mut("Johnny").unwrap() += 1;
    assert_eq!(*map.get("Johnny").unwrap(), 22);
}
```

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

### Get Original RwLock

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLockReadGuard.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a reference to the original `RwLock` object from a `RwLockReadGuard`.

```rust
pub fn rwlock(s: &RwLockReadGuard<'a, R, T>) -> &'a RwLock<R, T>
```

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

### DashSet::new

Source: https://docs.rs/dashmap/latest/src/dashmap/set.rs.html?search=

Creates a new, empty DashSet with a default hasher and zero initial capacity.

```APIDOC
## DashSet::new

### Description
Creates a new DashSet with a capacity of 0.

### Method
`DashSet::new()`

### Parameters
None

### Returns
A new, empty `DashSet`.

### Examples
```rust
use dashmap::DashSet;

let games = DashSet::new();
games.insert("Veloren");
```
```

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

### Try Get

Source: https://docs.rs/dashmap/latest/dashmap/trait.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to retrieve an immutable reference to the value, returning a `TryResult`.

```APIDOC
## _try_get

### Description
Attempts to retrieve an immutable reference to the value associated with the given key. This method may return a `TryResult` to indicate potential contention or other issues.

### Parameters
- `key` (`&Q`): The key to look up.

### Type Parameters
- `Q`: The type to compare the key with.

### Returns
- `TryResult<Ref<'a, K, V>>`: A `TryResult` containing an immutable reference to the value if successful, or an error state.
```

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

### DashMap::new

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new, empty DashMap with a default capacity and hasher.

```APIDOC
## DashMap::new

### Description
Creates a new DashMap with a capacity of 0.

### Examples

```rust
use dashmap::DashMap;

let reviews = DashMap::new();
reviews.insert("Veloren", "What a fantastic game!");
```
```

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

### fold_with

Source: https://docs.rs/dashmap/latest/dashmap/rayon/map/struct.IterMut.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs a parallel fold operation starting with a given initial value.

```APIDOC
## fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>

### Description
Applies `fold_op` to the given `init` value with each item of this iterator, finally producing the value for further use.

### Type Parameters
* `T`: The type of the initial value and the accumulator.
* `F`: The folding closure, which takes the accumulator and an item, and returns the updated accumulator.

### Parameters
* `init`: The initial value for the accumulator.
* `fold_op`: The closure to apply for folding.

### Returns
A `FoldWith` iterator that produces the final folded value.
```

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

### Length and Capacity

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to get the current number of elements and the total allocated capacity.

```APIDOC
## `_len(&self) -> usize`

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

### Returns
The total number of key-value pairs stored in the map.

## `_capacity(&self) -> usize`

### Description
Returns the total capacity of all shards in the DashMap.

### Returns
The total allocated capacity for all shards.
```

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

### entry

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides advanced entry API similar to `std::collections::HashMap::entry`. Be cautious about deadlocking if holding references.

```APIDOC
## entry

### Description
Advanced entry API that tries to mimic `std::collections::HashMap`. See the documentation on `dashmap::mapref::entry` for more details.

**Locking behaviour:** May deadlock if called when holding any sort of reference into the map.

### Parameters
- `key`: K - The key to use for the entry.

### Returns
- `Entry<'a, K, V>` - An entry for the given key.
```

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

### Get Underlying RwLock

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLockReadGuard.html?search=

Retrieves a reference to the original reader-writer lock object from a RwLockReadGuard.

```rust
pub fn rwlock(s: &RwLockReadGuard<'a, R, T>) -> &'a RwLock<R, T>

```

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

### Reserving Capacity with try_reserve

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use `try_reserve` to ensure a DashMap can hold a minimum number of elements without reallocating. It also shows how to check the map's capacity before and after reservation.

```rust
let mut map: DashMap<i32, i32> = DashMap::new();
// DashMap is empty and doesn't allocate memory
assert_eq!(map.capacity(), 0);

map.try_reserve(10).unwrap();

// And now map can hold at least 10 elements
assert!(map.capacity() >= 10);
```

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

### Try Get Mut

Source: https://docs.rs/dashmap/latest/dashmap/trait.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Attempts to retrieve a mutable reference to the value, returning a `TryResult`.

```APIDOC
## _try_get_mut

### Description
Attempts to retrieve a mutable reference to the value associated with the given key. This method may return a `TryResult` to indicate potential contention or other issues.

### Parameters
- `key` (`&Q`): The key to look up.

### Type Parameters
- `Q`: The type to compare the key with.

### Returns
- `TryResult<RefMut<'a, K, V>>`: A `TryResult` containing a mutable reference to the value if successful, or an error state.
```

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

### Basic DashMap Insertion and Retrieval

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html

Demonstrates the fundamental usage of DashMap by creating a new map, inserting a key-value pair, and then retrieving the value.

```rust
let dm = DashMap::new();

dm.insert(0, 0);

assert_eq!(dm.get(&0).unwrap().value(), &0);
```

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

### Get Read Shard

Source: https://docs.rs/dashmap/latest/dashmap/trait.Map.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides direct, unsafe access to a specific shard for reading.

```APIDOC
## _get_read_shard

### Description
Unsafely retrieves a reference to a specific shard for read operations. The index must be within the valid range of shards.

### Safety
The index must not be out of bounds.

### Parameters
- `i` (`usize`): The index of the shard to retrieve.

### Returns
- `&'a RawTable<(K, SharedValue<V>)>`: An immutable reference to the specified shard.
```

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

### Create a DashMap with hasher and shard amount

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Use `DashMap::with_hasher_and_shard_amount(hasher, shard_amount)` to create a DashMap with a custom hasher and a specified number of shards. The `shard_amount` must be a power of two and greater than 0.

```rust
use dashmap::DashMap;
use std::collections::hash_map::RandomState;

let s = RandomState::new();
let mappings = DashMap::with_hasher_and_shard_amount(s, 32);
mappings.insert(2, 4);
mappings.insert(8, 16);
```

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

### try_get_mut()

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Attempts to get a mutable reference, returning `TryResult::Locked` if the shard is busy.

```APIDOC
## try_get_mut<Q>(key: &Q)

### Description
Get a mutable reference to an entry in the map, if the shard is not locked. If the shard is locked, the function will return TryResult::Locked.

### Method
`try_get_mut(key: &Q)`

### Parameters
*   **key** (&Q) - The key to search for.

### Request Example
```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

*map.try_get_mut("Johnny").unwrap() += 1;
assert_eq!(*map.get("Johnny").unwrap(), 22);

let _result1_locking = map.get("Johnny");

let result2 = map.try_get_mut("Johnny");
assert!(result2.is_locked());
```

### Response
#### Success Response (TryResult<RefMut<'a, K, V>>)
Returns `TryResult::Ok` with a mutable reference if successful, or `TryResult::Locked` if the shard is busy.
```

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

### try_get()

Source: https://docs.rs/dashmap/latest/dashmap/struct.DashMap.html?search=std%3A%3Avec

Attempts to get an immutable reference, returning `TryResult::Locked` if the shard is busy.

```APIDOC
## try_get<Q>(key: &Q)

### Description
Get an immutable reference to an entry in the map, if the shard is not locked. If the shard is locked, the function will return TryResult::Locked.

### Method
`try_get(key: &Q)`

### Parameters
*   **key** (&Q) - The key to search for.

### Request Example
```rust
use dashmap::DashMap;
use dashmap::try_result::TryResult;

let map = DashMap::new();
map.insert("Johnny", 21);

assert_eq!(*map.try_get("Johnny").unwrap(), 21);

let _result1_locking = map.get_mut("Johnny");

let result2 = map.try_get("Johnny");
assert!(result2.is_locked());
```

### Response
#### Success Response (TryResult<Ref<'a, K, V>>)
Returns `TryResult::Ok` with an immutable reference if successful, or `TryResult::Locked` if the shard is busy.
```

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

### DashMap::new

Source: https://docs.rs/dashmap/latest/src/dashmap/lib.rs.html?search=

Creates a new, empty DashMap with a default capacity. This is a convenient way to initialize a DashMap for general use.

```APIDOC
## DashMap::new

### Description
Creates a new, empty DashMap with a default capacity. This is a convenient way to initialize a DashMap for general use.

### Method
`new()`

### Endpoint
N/A (SDK method)

### Parameters
None

### Request Example
```rust
use dashmap::DashMap;

let reviews = DashMap::new();
reviews.insert("Veloren", "What a fantastic game!");
```

### Response
#### Success Response
A new, empty `DashMap` instance.

### Response Example
N/A (SDK method)
```

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

### Unwrap the SharedValue to get the inner value

Source: https://docs.rs/dashmap/latest/dashmap/struct.SharedValue.html

Consumes the SharedValue and returns the inner value.

```rust
pub fn into_inner(self) -> T
```

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

### Default Implementation

Source: https://docs.rs/dashmap/latest/dashmap/type.RwLock.html

Provides a Default implementation for RwLock, allowing instances to be created with default values.

```APIDOC
## Default Implementation

### Description
Returns the default value for `RwLock`. This is useful for creating an unlocked `RwLock` without an initial value if `T` also implements `Default`.

### Trait Method
`fn default() -> RwLock<R, T>`
```

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

### Get a shared reference to the inner value

Source: https://docs.rs/dashmap/latest/dashmap/struct.SharedValue.html

Provides immutable access to the wrapped value.

```rust
pub fn get(&self) -> &T
```

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

### Test inserting into a vacant entry

Source: https://docs.rs/dashmap/latest/src/dashmap/mapref/entry.rs.html

Demonstrates the usage of `insert_entry` on a `VacantEntry`. It shows how to create a new entry with a value and verify its presence in the map.

```rust
#[test]
fn test_insert_entry_into_vacant() {
    let map: DashMap<u32, u32> = DashMap::new();

    let entry = map.entry(1);

    assert!(matches!(entry, Entry::Vacant(_)));

    let entry = entry.insert_entry(2);

    assert_eq!(*entry.get(), 2);

    drop(entry);

    assert_eq!(*map.get(&1).unwrap(), 2);
}
```
Tokens:
Raw