DashMap

https://github.com/xacrimon/dashmap
Admin
DashMap is a blazingly fast and easy-to-use concurrent hash map implementation in Rust, providing a...
Tokens:30,902
Snippets:427
Trust Score:9.9
License:MIT
Update:3 months ago
Show doc for...
Tokens:
Raw
### OwningIter Usage Examples

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Examples demonstrating how to consume a map using OwningIter.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
map.insert("b", 2);

let mut iter = map.into_iter();
while let Some((k, v)) = iter.next() {
    println!("{}: {}", k, v);
}
```

```rust
let map = DashMap::new();
map.insert("key", "value");

for (k, v) in map {
    println!("{}: {}", k, v);
}
```

```rust
let iter = map.into_iter();
```

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

### IterMut Usage Examples

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Examples demonstrating how to use IterMut to modify map entries.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("counter", 0);

let mut iter = map.iter_mut();
while let Some(mut entry) = iter.next() {
    *entry += 1;
}
assert_eq!(*map.get("counter").unwrap(), 1);
```

```rust
let iter = map.iter_mut();
```

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
map.insert("b", 2);

for mut entry in map.iter_mut() {
    *entry *= 2;
}
```

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

### Demonstrate locking behavior

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Example showing how reference guards maintain shard locks until they are dropped.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("key", "value");

{
    let ref_guard = map.get("key").unwrap();
    println!("{}", ref_guard.value()); // Shard is read-locked here
} // Lock released when guard is dropped
```

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

### DashSet::with_capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a new DashSet with a specified starting capacity.

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

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

### Parameters
- **capacity** (usize) - Required - Initial capacity hint

### Returns
A new `DashSet<K, RandomState>` with reserved capacity

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

let set: DashSet<String> = DashSet::with_capacity(100);
set.insert("item".to_string());
```
```

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

### Get Ref value

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Returns a reference to the set element.

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

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

### Create DashSet iterator

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Example of creating and using an immutable iterator on a DashSet.

```rust
let set = DashSet::new();
set.insert("item");

for entry in set.iter() {
    println!("{}", entry.value());
}
```

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

### Consume map with OwningIter

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Example of consuming a DashMap to iterate over its owned key-value pairs.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
map.insert("b", 2);
for (k, v) in map {
    println!("{}: {}", k, v);
}
```

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

### get

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns a raw reference to the value for a given key. No lock is held while using the returned reference.

```APIDOC
## get

### Description
Returns a raw reference to the value for a given key. No lock is held while using the returned reference.

### Signature
`pub fn get<Q>(&'a self, key: &Q) -> Option<&'a V>`

### Parameters
- **key** (&Q) - Required - Key to look up

### Returns
`Option<&'a V>` - Raw reference to value, or None if not found
```

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

### get

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the value in the occupied entry.

```APIDOC
## get

### Description
Returns a reference to the value in the occupied entry.

### Returns
- **&V** - Reference to the value
```

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

### Iterate over map entries

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Example of iterating over immutable references in a DashMap.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
for entry in map.iter() {
    println!("{}: {}", entry.key(), entry.value());
}
```

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

### Handle TryResult with pattern matching

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Example usage of try_get returning a TryResult to handle potential shard locks.

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

let map = DashMap::new();
map.insert("key", "value");
match map.try_get("key") {
    TryResult::Present(r) => println!("Found: {}", *r),
    TryResult::Absent => println!("Not found"),
    TryResult::Locked => println!("Shard locked, retry later"),
}
```

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

### Get element reference

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Retrieves a reference to an element if it exists in the set.

```rust
use dashmap::DashSet;

let set = DashSet::new();
set.insert("item");
if let Some(reference) = set.get("item") {
    println!("Found: {}", reference.value());
}
```

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

### Get map capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Returns the total capacity of the underlying map.

```rust
pub fn capacity(&self) -> usize
```

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

### Get set capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Returns the current capacity of the set before reallocation is required.

```rust
use dashmap::DashSet;

let set: DashSet<i32> = DashSet::with_capacity(100);
assert!(set.capacity() >= 100);
```

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

### Convert DashMap to ReadOnlyView

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

The method signature and usage example for converting a DashMap into a ReadOnlyView.

```rust
pub fn into_read_only(self) -> ReadOnlyView<K, V, S>
```

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("key1", 100);
map.insert("key2", 200);

let read_only = map.into_read_only();
```

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

### get

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Returns an immutable reference to an entry in the map. The reference is wrapped in a Ref guard that maintains a read lock.

```APIDOC
## get

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

### Description
Returns an immutable reference to an entry in the map. The reference is wrapped in a Ref guard that maintains a read lock.

### Parameters
- **key** (&Q) - Key to look up

### Returns
- **Option<Ref<'a, K, V>>** - Read-locked reference, or None if not found

### Locking behavior
Holds a read lock on the corresponding shard. May deadlock if called while holding a mutable reference into the map.
```

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

### Get with >> Operator

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Uses the right shift operator to retrieve a reference guard for a key.

```rust
impl<'a, K: Eq + Hash, V, S: BuildHasher + Clone, Q> Shr<&Q> for &'a DashMap<K, V, S>
where
    Q: Hash + Equivalent<K> + ?Sized,
{
    type Output = Ref<'a, K, V>;
}
```

```rust
let map = DashMap::new();
map.insert("key", "value");
let ref_guard = &map >> &"key";
```

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

### Configure DashMap initialization

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Demonstrates setting capacity, shard count, and custom hashers during map creation.

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

// With capacity
let map: DashMap<i32, String> = DashMap::with_capacity(1000);

// With shard amount (must be power of 2)
let map: DashMap<String, i32> = DashMap::with_shard_amount(64);

// With custom hasher
let hasher = RandomState::new();
let map: DashMap<i32, Vec<i32>> = DashMap::with_hasher(hasher);

// All options together
let map: DashMap<String, String> = DashMap::with_capacity_and_hasher_and_shard_amount(
    5000,   // capacity
    RandomState::new(),  // hasher
    128,    // shard_amount
);
```

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

### Initialize DashMap with Capacity, Hasher, and Shard Amount

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap with an initial capacity hint, custom hasher, and shard count. Panics if shard_amount is not a power of two or less than 2.

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

let hasher = RandomState::new();
let map: DashMap<String, String> = DashMap::with_capacity_and_hasher_and_shard_amount(2000, hasher, 128);
```

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

### Initialize DashMap with default settings

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Creates a map with default capacity, auto-calculated shard count, and default RandomState hasher.

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

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

### Enable all features

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Shows how to enable all optional features via the 'all' alias or explicit listing.

```toml
[dependencies]
dashmap = { version = "7.0", features = ["all"] }
```

```toml
[dependencies]
dashmap = { version = "7.0", features = ["raw-api", "typesize", "serde", "rayon", "arbitrary"] }
```

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

### Visualize Documentation Flow

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/INDEX.md

Represents the recommended navigation path through the documentation files.

```text
README.md (overview)
  ↓
Specific API file (dashmap.md, entry-api.md, etc.)
  ↓
types.md (type definitions)
  ↓
configuration.md (setup details)
```

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

### Initialize DashSet with new

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates an empty DashSet using default capacity and shard configuration.

```rust
use dashmap::DashSet;

let set = DashSet::new();
set.insert("element");
```

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

### Mutate map entries during iteration

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Example of modifying values while iterating over a DashMap.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
for mut entry in map.iter_mut() {
    *entry += 1;
}
```

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

### Initialize DashSet with capacity and hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a DashSet with both a specified capacity and a custom hasher.

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

let hasher = RandomState::new();
let set: DashSet<String> = DashSet::with_capacity_and_hasher(500, hasher);
```

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

### Initialize DashSet with capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a DashSet with a pre-allocated capacity hint.

```rust
use dashmap::DashSet;

let set: DashSet<String> = DashSet::with_capacity(100);
set.insert("item".to_string());
```

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

### Get value from OccupiedEntry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Retrieves a reference to the value stored in the occupied entry.

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

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("key", "value");
let entry = map.entry("key");
if let dashmap::mapref::entry::Entry::Occupied(occupied) = entry {
    println!("{}", occupied.get());
}
```

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

### Initialize DashMap with capacity and hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap with both capacity and a custom hasher.

```rust
pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> Self
```

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

let hasher = RandomState::new();
let map: DashMap<i32, i32> = DashMap::with_capacity_and_hasher(500, hasher);
```

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

### Initialize DashMap with capacity and shards

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap with both capacity and shard count configuration.

```rust
pub fn with_capacity_and_shard_amount(capacity: usize, shard_amount: usize) -> Self
```

```rust
use dashmap::DashMap;

let map: DashMap<String, i32> = DashMap::with_capacity_and_shard_amount(1000, 64);
```

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

### Get map length

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Returns the number of elements currently stored in the view.

```rust
pub fn len(&self) -> usize
```

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

### Initialize DashSet with custom hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a DashSet using a specific hash algorithm builder.

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

let hasher = RandomState::new();
let set: DashSet<i32> = DashSet::with_hasher(hasher);
set.insert(42);
```

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

### Get set length

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Retrieves the total number of elements currently in the set.

```rust
use dashmap::DashSet;

let set = DashSet::new();
set.insert("a");
set.insert("b");
assert_eq!(set.len(), 2);
```

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

### Perform basic CRUD operations with DashMap

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Demonstrates standard insertion, retrieval, modification, removal, and iteration patterns.

```rust
use dashmap::DashMap;

// Create a map
let map = DashMap::new();

// Insert
map.insert("key", "value");

// Get
if let Some(entry) = map.get("key") {
    println!("Found: {}", entry.value());
}

// Modify
if let Some(mut entry) = map.get_mut("key") {
    *entry = "new_value";
}

// Remove
map.remove("key");

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

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

### Lookup with Equivalent

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Demonstrates using a string slice to look up a key stored as a String.

```rust
use dashmap::DashMap;

let map: DashMap<String, i32> = DashMap::new();
map.insert("key".to_string(), 42);
assert!(map.contains_key("key")); // &str is Equivalent<String>
```

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

### Enable inline-more feature

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Configures the crate to pass the 'inline-more' feature to hashbrown for aggressive inlining.

```toml
[dependencies]
dashmap = { version = "7.0", features = ["inline-more"] }
```

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

### DashSet::new

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a new empty DashSet with default capacity and shard configuration.

```APIDOC
## DashSet::new()

### Description
Creates a new empty DashSet with default capacity and shard configuration.

### Signature
`pub fn new() -> Self where K: Eq + Hash`

### Returns
A new `DashSet<K, RandomState>`

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

let set = DashSet::new();
set.insert("element");
```
```

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

### Get Map Capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns the total capacity across all shards of the underlying map.

```rust
let view = map.into_read_only();
println!("Capacity: {}", view.capacity());
```

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

### Initialize DashMap with capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Sets an initial capacity hint for the map. Actual allocation may be larger to align with internal shard boundaries.

```rust
let map = DashMap::with_capacity(1000);
```

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

### Get Mutable with | Operator

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Uses the bitwise OR operator to retrieve a mutable reference guard for a key.

```rust
impl<'a, K: Eq + Hash, V, S: BuildHasher + Clone, Q> BitOr<&Q> for &'a DashMap<K, V, S>
where
    Q: Hash + Equivalent<K> + ?Sized,
{
    type Output = RefMut<'a, K, V>;
}
```

```rust
let map = DashMap::new();
map.insert("key", 5);
let mut ref_guard = &map | &"key";
```

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

### Select DashMap Constructor

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/INDEX.md

Decision tree for choosing the appropriate DashMap or DashSet constructor based on capacity, shard, and hashing requirements.

```text
Start with DashMap::new()
├─ Need capacity? → with_capacity(n)
├─ Need more shards? → with_shard_amount(n)
├─ Custom hasher? → with_hasher(h)
└─ Combine options? → with_capacity_and_hasher_and_shard_amount(c,h,s)

For DashSet:
└─ Same constructors as DashMap
```

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

### Initialize DashMap with Custom Hasher and Shard Amount

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap using a specific hasher and shard count. The shard_amount must be a power of two and greater than 1.

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

let hasher = RandomState::new();
let map: DashMap<u64, Vec<i32>> = DashMap::with_hasher_and_shard_amount(hasher, 16);
```

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

### Initialize Map with Hashable Keys

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Shows a standard DashMap initialization where keys implement Hash and Eq.

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

let map: DashMap<String, i32> = DashMap::new(); // String: Hash + Eq
```

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

### Configure Custom Hash Functions

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Implement custom hashers like FxHash to optimize performance for specific data types.

```rust
use std::hash::BuildHasher;

// Example: Use FxHash for integer-heavy workloads
// Requires adding: fx = "0.1"
use fx::FxHasher64;

let map: DashMap<i32, String> = DashMap::new();
// Use with custom hasher
```

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

### Create and use a read-only DashMap view

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Demonstrates the lifecycle of converting a mutable DashMap into a read-only view and reverting it back to a mutable state.

```rust
use dashmap::DashMap;

fn main() {
    // Step 1: Create and populate map
    let map = DashMap::new();
    map.insert("alice", 30);
    map.insert("bob", 25);
    map.insert("charlie", 35);
    
    // Step 2: Convert to read-only
    let directory = map.into_read_only();
    
    // Step 3: Read without locks
    for name in directory.keys() {
        if let Some(age) = directory.get(name) {
            println!("{}: {} years old", name, age);
        }
    }
    
    // Step 4: If needed, get mutable map back
    let map_again = directory.into_inner();
    map_again.insert("diana", 28); // Can modify again
}
```

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

### with_capacity_and_hasher_and_shard_amount

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap instance with a specified initial capacity, custom hasher, and shard amount.

```APIDOC
## pub fn with_capacity_and_hasher_and_shard_amount(capacity: usize, hasher: S, shard_amount: usize) -> Self

### Description
Creates a new DashMap with specified capacity, custom hasher, and shard amount.

### Parameters
- **capacity** (usize) - Initial capacity hint
- **hasher** (S) - Hash algorithm builder
- **shard_amount** (usize) - Number of shards (must be power of two, > 1)

### Returns
A new DashMap<K, V, S>

### Panics
Panics if shard_amount is not a power of two or less than 2.
```

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

### Initialize DashMap with custom hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Configures the map to use a specific hash algorithm builder.

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

let hasher = RandomState::new();
let map: DashMap<String, i32> = DashMap::with_hasher(hasher);
```

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

### Default Implementation for DashMap

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Initializes a new DashMap with a default hasher and zero capacity. Requires K to implement Eq and Hash, and S to implement Default, BuildHasher, and Clone.

```rust
impl<K, V, S> Default for DashMap<K, V, S>
where
    K: Eq + Hash,
    S: Default + BuildHasher + Clone,
{
    fn default() -> Self {
        Self::with_hasher(Default::default())
    }
}
```

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

### DashSet::with_capacity_and_hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a new DashSet with specified capacity and custom hasher.

```APIDOC
## DashSet::with_capacity_and_hasher(capacity: usize, hasher: S)

### Description
Creates a new DashSet with specified capacity and custom hasher.

### Parameters
- **capacity** (usize) - Required - Initial capacity hint
- **hasher** (S) - Required - Hash algorithm builder

### Returns
A new `DashSet<K, S>`

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

let hasher = RandomState::new();
let set: DashSet<String> = DashSet::with_capacity_and_hasher(500, hasher);
```
```

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

### into_key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Consumes the entry and returns the key.

```APIDOC
## pub fn into_key(self) -> K

### Description
Consumes the entry and returns the key.

### Returns
- **K** - The key
```

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

### into_key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Consumes the vacant entry and returns the key.

```APIDOC
## pub fn into_key(self) -> K

### Description
Consumes the vacant entry and returns the key.

### Returns
- **K** - The key
```

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

### Enable typesize inspection

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Requires the 'typesize' feature to allow runtime memory layout inspection.

```rust
#[cfg(feature = "typesize")]
fn inspect_size() {
    use dashmap::DashMap;
    let map: DashMap<i32, String> = DashMap::new();
    // Can inspect size information
}
```

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

### entry_ref

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Provides an entry API using a borrowed key reference to avoid key cloning, holding a write lock on the shard.

```APIDOC
## entry_ref

### Description
Entry API using a borrowed key reference, avoiding key cloning. Holds a write lock on the corresponding shard.

### Signature
`pub fn entry_ref<'q, Q>(&'a self, key: &'q Q) -> EntryRef<'a, 'q, K, Q, V>`

### Parameters
- **key** (&'q Q) - Required - Borrowed key reference

### Returns
- **EntryRef<'a, 'q, K, Q, V>** - Entry with borrowed key
```

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

### into_shards

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Consumes the DashMap and returns the underlying shards.

```APIDOC
## into_shards()

### Description
Consumes the DashMap and returns the underlying shards.

### Returns
- **Boxed Array** - Shards (Box<[CachePadded<RwLock<HashMap<K, V>>>]>)
```

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

### Retrieve Key-Value Pair

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns both the key and value as raw references.

```rust
let view = map.into_read_only();
if let Some((k, v)) = view.get_key_value("key1") {
    println!("Key: {}, Value: {}", k, v);
}
```

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

### Perform basic iteration

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Standard immutable iteration over a DashMap.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("key1", 100);
map.insert("key2", 200);

// Immutable iteration
for entry in map.iter() {
    println!("{}: {}", entry.key(), entry.value());
}
```

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

### EntryRef::or_try_insert_with Method

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Attempts to insert a value generated by a closure if the entry is vacant, returning a Result.

```rust
pub fn or_try_insert_with<E>(
    self,
    value: impl FnOnce() -> Result<V, E>,
) -> Result<RefMut<'a, K, V>, E>
where
    K: From<&'q Q>,
```

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

### Create and use iterator

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Standard creation and usage of the iterator via for-loop.

```rust
let iter = map.iter();
```

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("key", "value");

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

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

### Retrieve Entry Key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the entry's key.

```rust
let map = DashMap::new();
let entry = map.entry("mykey");
println!("Key: {}", entry.key());
```

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

### Handle capacity reservation

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Demonstrates using try_reserve to handle potential memory allocation failures.

```rust
use dashmap::DashMap;

let mut map: DashMap<i32, String> = DashMap::new();
match map.try_reserve(1_000_000) {
    Ok(()) => println!("Capacity reserved"),
    Err(_) => println!("Failed to allocate memory"),
}
```

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

### key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the entry's key.

```APIDOC
## pub fn key(&self) -> &K

### Description
Returns a reference to the entry's key.

### Returns
- **&K** - Reference to the key
```

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

### Use raw shard API

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Requires the 'raw-api' feature. Use with caution as direct manipulation can violate internal map invariants.

```rust
#[cfg(feature = "raw-api")]
fn use_raw_api() {
    use dashmap::DashMap;
    
    let map: DashMap<i32, String> = DashMap::new();
    let shard_index = map.determine_map(&42);
    println!("Shard for key 42: {}", shard_index);
}
```

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

### Perform lazy initialization

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Use or_insert_with to compute values only when the key is missing from the map.

```rust
use dashmap::DashMap;

let cache: DashMap<String, Vec<i32>> = DashMap::new();

cache.entry("key".to_string())
    .or_insert_with(|| vec![1, 2, 3]);
```

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

### keys

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Creates an iterator over all keys.

```APIDOC
## keys

### Description
Creates an iterator over all keys.

### Signature
`pub fn keys(&'a self) -> impl Iterator<Item = &'a K> + 'a`

### Returns
Iterator yielding `&'a K`
```

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

### key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the borrowed key.

```APIDOC
### `key`

```rust
pub fn key(&self) -> &Q
where
    K: From<&'q Q>,
```

Returns a reference to the borrowed key.

**Returns:** `&Q` - Reference to the key
```

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

### Enable Serde serialization

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Requires the 'serde' feature to be enabled in Cargo.toml.

```rust
#[cfg(feature = "serde")]
use serde::{Serialize, Deserialize};

let map = dashmap::DashMap::new();
map.insert("key", "value");

// Can now serialize with serde (when feature is enabled)
```

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

### VacantEntry into_key Method

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Consumes the vacant entry and returns the key.

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

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

### Increment or initialize entry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Updates an existing value or inserts a default if the key is missing.

```rust
use dashmap::DashMap;

let map: DashMap<String, i32> = DashMap::new();
map.entry("counter".to_string())
    .and_modify(|v| *v += 1)
    .or_insert(1);
```

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

### with_hasher_and_shard_amount

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Creates a new DashMap instance with a custom hasher and a specified number of shards.

```APIDOC
## pub fn with_hasher_and_shard_amount(hasher: S, shard_amount: usize) -> Self

### Description
Creates a new DashMap with custom hasher and shard amount.

### Parameters
- **hasher** (S) - Hash algorithm builder
- **shard_amount** (usize) - Number of shards (must be power of two, > 1)

### Returns
A new DashMap<K, V, S>

### Panics
Panics if shard_amount is not a power of two or less than 2.
```

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

### Implement a counter or frequency map

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Use the entry API to atomically increment values or initialize them if they do not exist.

```rust
use dashmap::DashMap;

let counts: DashMap<String, i32> = DashMap::new();

counts.entry("rust".to_string())
    .and_modify(|v| *v += 1)
    .or_insert(1);
```

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

### Ref::pair

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Returns references to both the key and value as a tuple.

```APIDOC
### Method
`pub fn pair(&self) -> (&K, &V)`

### Description
Returns references to both the key and value as a tuple.

### Returns
`(&K, &V)` - Tuple of references

### Example
```rust
let map = DashMap::new();
map.insert("name", "Alice");
let entry = map.get("name").unwrap();
let (k, v) = entry.pair();
```
```

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

### Iterate over map entries

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Manual iteration using the next method.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("a", 1);
map.insert("b", 2);

let mut iter = map.iter();
while let Some(entry) = iter.next() {
    println!("{}: {}", entry.key(), entry.value());
}
```

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

### Iterator vs Manual Loop Comparison

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Compares the idiomatic iterator approach with the complexity of manual sharding logic.

```rust
// Iterator: Clean, idiomatic, zero-cost
for entry in map.iter() {
    // Process entry
}

// vs. Manual: Would require unsafe code or
// reimplementation of sharding logic
```

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

### Consume Entry into Key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Consumes the entry and returns the key.

```rust
let map = DashMap::new();
let entry = map.entry("key");
let key = entry.into_key();
```

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

### Compute default value

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Initializes a collection if the key is missing and returns a reference to it.

```rust
use dashmap::DashMap;

let map: DashMap<String, Vec<i32>> = DashMap::new();
let entry = map.entry("items".to_string())
    .or_insert_with(Vec::new);
entry.push(42);
```

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

### EntryRef::key Method

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the borrowed key used for the entry lookup.

```rust
pub fn key(&self) -> &Q
where
    K: From<&'q Q>,
```

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

### Default Implementation for DashSet

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a new DashSet with default hasher and zero capacity.

```rust
impl<K, S> Default for DashSet<K, S>
where
    K: Eq + Hash,
    S: Default + BuildHasher + Clone,
{
    fn default() -> Self {
        Self::with_hasher(Default::default())
    }
}
```

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

### key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a reference to the key associated with the vacant entry.

```APIDOC
## pub fn key(&self) -> &K

### Description
Returns a reference to the key.

### Returns
- **&K** - Reference to the key
```

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

### Initialize DashMap with shard amount

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Sets the number of internal shards. The value must be a power of two greater than 1, or the constructor will panic.

```rust
let map: DashMap<i32, i32> = DashMap::with_shard_amount(32);
```

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

### DashSet::with_hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Creates a new DashSet with a custom hash algorithm and zero capacity.

```APIDOC
## DashSet::with_hasher(hasher: S)

### Description
Creates a new DashSet with a custom hash algorithm and zero capacity.

### Parameters
- **hasher** (S) - Required - Hash algorithm builder

### Returns
A new `DashSet<K, S>`

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

let hasher = RandomState::new();
let set: DashSet<i32> = DashSet::with_hasher(hasher);
set.insert(42);
```
```

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

### Perform batch operations

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Use extend to insert multiple items and retain to filter elements based on a predicate.

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.extend(vec![("a", 1), ("b", 2), ("c", 3)]);

map.retain(|_, &mut v| v > 1); // Keep only values > 1
```

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

### Ref::key

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Returns a reference to the key associated with the entry.

```APIDOC
### Method
`pub fn key(&self) -> &K`

### Description
Returns a reference to the key.

### Returns
`&K` - Reference to the key

### Example
```rust
let map = DashMap::new();
map.insert("user", 123);
let entry = map.get("user").unwrap();
println!("Key: {}", entry.key());
```
```

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

### into_ref

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Consumes the occupied entry and returns a mutable reference.

```APIDOC
## into_ref

### Description
Consumes the occupied entry and returns a mutable reference.

### Returns
- **RefMut<'a, K, V>** - Mutable reference
```

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

### capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Returns the total capacity across all shards.

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

### Description
Returns the total capacity (number of entries the map can hold without reallocating) across all shards. Acquires read locks on all shards.

### Returns
- **usize** - Total capacity
```

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

### Try Access DashMap Entry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

A non-blocking version of the entry API that returns None if the shard is currently locked.

```rust
use dashmap::DashMap;

let map = DashMap::new();
if let Some(entry) = map.try_entry("key") {
    entry.or_insert("value");
}
```

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

### get_key_value

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns both the key and value as raw references.

```APIDOC
## get_key_value

### Description
Returns both the key and value as raw references.

### Signature
`pub fn get_key_value<Q>(&'a self, key: &Q) -> Option<(&'a K, &'a V)>`

### Parameters
- **key** (&Q) - Required - Key to look up

### Returns
`Option<(&'a K, &'a V)>` - Tuple of references, or None
```

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

### into_inner

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Consumes the read-only view and returns the underlying DashMap, allowing modifications again.

```APIDOC
## into_inner

### Description
Consumes the read-only view and returns the underlying DashMap, allowing modifications again.

### Signature
`pub fn into_inner(self) -> DashMap<K, V, S>`

### Returns
`DashMap<K, V, S>` - The original wrapped map
```

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

### Calculate actual capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Actual capacity is aligned to shard boundaries based on the requested capacity.

```rust
actual_capacity = ((requested_capacity + shard_amount - 1) & !(shard_amount - 1))
```

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

### Pre-allocate DashMap Capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Pre-allocation reduces lock contention and memory reallocations for known workload sizes.

```rust
// Better for known workload sizes
let map = DashMap::with_capacity(10_000);

// vs. incremental growth
let map = DashMap::new();
```

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

### try_reserve

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Attempts to reserve capacity for at least shard * additional entries.

```APIDOC
## try_reserve

### Description
Attempts to reserve capacity for at least `shard * additional` entries. May allocate more to avoid frequent reallocations.

### Signature
`pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>`

### Parameters
- **additional** (usize) - Required - Minimum additional capacity per shard

### Returns
- **Result<(), TryReserveError>** - Success or error if allocation fails
```

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

### Use Entry API for atomic operations

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Provides atomic increment and conditional update logic using the Entry API.

```rust
use dashmap::DashMap;

let counters: DashMap<String, i32> = DashMap::new();

// Increment or initialize atomically
counters
    .entry("visits".to_string())
    .and_modify(|v| *v += 1)
    .or_insert(1);

// Conditional updates
let entry = counters.entry("threshold".to_string());
match entry {
    dashmap::mapref::entry::Entry::Occupied(occupied) => {
        if *occupied.get() > 100 {
            occupied.remove();
        }
    }
    dashmap::mapref::entry::Entry::Vacant(vacant) => {
        vacant.insert(1);
    }
}
```

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

### Clone Implementation for DashMap

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Clones the map, duplicating all entries and shards. Requires K, V, and S to implement Clone.

```rust
impl<K: Eq + Hash + Clone, V: Clone, S: Clone> Clone for DashMap<K, V, S>
```

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

### Share DashMap across threads

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/README.md

Demonstrates sharing a DashMap instance across threads using Arc without requiring additional Mutex wrappers.

```rust
let map = std::sync::Arc::new(DashMap::new());
let map_clone = map.clone();

std::thread::spawn(move || {
    map_clone.insert("key", "value");
});
```

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

### len

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/types.md

Returns the number of elements in the view.

```APIDOC
## len

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

### Signature
`pub fn len(&self) -> usize`

### Returns
`usize` - The number of elements
```

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

### Debug Implementation for DashSet

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Provides debug formatting for the set.

```rust
impl<K: Eq + Hash + Debug, S: BuildHasher + Clone> Debug for DashSet<K, S>
```

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

### Iterate Over Keys

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Creates an iterator over all keys in the view.

```rust
let view = map.into_read_only();
for key in view.keys() {
    println!("Key: {}", key);
}
```

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

### Insert Entry and Return OccupiedEntry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Inserts a value and returns an OccupiedEntry. Requires K: Clone.

```rust
use dashmap::DashMap;

let map = DashMap::new();
let occupied = map.entry("key".to_string()).insert_entry("value");
```

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

### iter

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Creates an iterator over all key-value pairs as raw references.

```APIDOC
## iter

### Description
Creates an iterator over all key-value pairs as raw references.

### Signature
`pub fn iter(&'a self) -> impl Iterator<Item = (&'a K, &'a V)> + 'a`

### Returns
Iterator yielding `(&'a K, &'a V)` tuples
```

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

### Calculate capacity per shard

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Total capacity is distributed evenly across all shards.

```rust
capacity_per_shard = total_capacity / shard_amount
```

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

### Try Insert Value with or_try_insert_with

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a mutable reference to the value, attempting to generate and insert a value if vacant, while propagating errors.

```rust
use dashmap::DashMap;

let map = DashMap::new();
let result = map.entry("key").or_try_insert_with(|| Ok("value"));
```

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

### hasher

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Returns a reference to the set's hash algorithm builder.

```APIDOC
## hasher

### Description
Returns a reference to the set's hash algorithm builder.

### Signature
`pub fn hasher(&self) -> &S`

### Returns
- **&S** - Reference to the BuildHasher implementation.
```

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

### Implement Read-Heavy Workloads

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Convert a DashMap to a ReadOnlyView after initialization to enable lock-free reads.

```rust
use dashmap::DashMap;

fn initialize_cache() -> dashmap::ReadOnlyView<String, Vec<i32>> {
    let map = DashMap::new();
    // Populate during initialization
    map.insert("data1".to_string(), vec![1, 2, 3]);
    map.insert("data2".to_string(), vec![4, 5, 6]);
    
    // Convert to read-only for serving
    map.into_read_only()
}

fn serve_requests(cache: &dashmap::ReadOnlyView<String, Vec<i32>>) {
    if let Some(data) = cache.get("data1") {
        // Access without locks
        println!("Data: {:?}", data);
    }
}
```

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

### Implement FromIterator for DashMap

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Enables the creation of a DashMap from an iterator of key-value pairs.

```rust
impl<K: Eq + Hash, V, S: BuildHasher + Clone + Default> FromIterator<(K, V)> for DashMap<K, V, S>
```

```rust
use dashmap::DashMap;

let pairs = vec![("a", 1), ("b", 2)];
let map: DashMap<&str, i32> = pairs.into_iter().collect();
```

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

### Access key from Ref

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Retrieves a reference to the key stored in the map entry.

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

```rust
use dashmap::DashMap;

let map = DashMap::new();
map.insert("user", 123);
let entry = map.get("user").unwrap();
println!("Key: {}", entry.key());
```

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

### insert

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Replaces the value in the entry and returns the old value.

```APIDOC
## insert

### Description
Replaces the value in the entry and returns the old value.

### Parameters
- **value** (V) - Required - New value

### Returns
- **V** - The old value
```

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

### insert_entry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Inserts a value and returns an OccupiedEntry. Requires K: Clone.

```APIDOC
## pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V>

### Description
Inserts a value and returns an OccupiedEntry. Requires K: Clone.

### Parameters
- **value** (V) - Required - Value to insert

### Returns
- **OccupiedEntry<'a, K, V>** - Occupied entry
```

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

### insert_entry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Inserts a value and returns an OccupiedEntry. Requires K: Clone.

```APIDOC
## pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V>

### Description
Inserts a value and returns an OccupiedEntry. Requires K: Clone.

### Parameters
- **value** (V) - Value to insert

### Returns
- **OccupiedEntry<'a, K, V>** - Occupied entry
```

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

### Enable Rayon parallel iteration

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Requires the 'rayon' feature to be enabled to access parallel iterator modules.

```rust
#[cfg(feature = "rayon")]
fn use_rayon() {
    use dashmap::DashMap;
    
    let map = DashMap::new();
    // Use parallel iteration features
}
```

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

### try_entry

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashmap.md

Non-blocking version of entry(). Returns None if the shard is currently locked.

```APIDOC
## try_entry

### Description
Non-blocking version of entry(). Returns None if the shard is currently locked.

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

### Parameters
- **key** (`K`) - Required - Key to access or insert
```

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

### Avoid key cloning with entry_ref

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Uses entry_ref to perform operations without cloning the key.

```rust
use dashmap::DashMap;

let map: DashMap<String, i32> = DashMap::new();
let key = "lookup_key".to_string();

// entry_ref avoids cloning the key on subsequent operations
map.entry_ref(&key).or_insert(100);
```

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

### Debug Formatting for ReadOnlyView

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Provides debug formatting for the view.

```rust
let view = map.into_read_only();
println!("{:?}", view);
```

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

### capacity

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns the total capacity of the underlying map.

```APIDOC
## capacity

### Description
Returns the total capacity of the underlying map.

### Signature
`pub fn capacity(&self) -> usize`

### Returns
`usize` - Total capacity across all shards
```

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

### Insert entry into VacantEntryRef

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Inserts a value and returns an occupied entry reference.

```rust
pub fn insert_entry(self, value: V) -> OccupiedEntryRef<'a, 'q, K, Q, V>
where
    K: From<&'q Q>,
```

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

### EntryRef::insert_entry Method

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Inserts a value and returns an OccupiedEntryRef. Requires the key type to implement Clone and From<&Q>.

```rust
pub fn insert_entry(self, value: V) -> OccupiedEntryRef<'a, 'q, K, Q, V>
where
    K: From<&'q Q> + Clone,
```

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

### FromIterator

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/dashset.md

Allows creating a DashSet from an iterator of elements.

```APIDOC
## FromIterator

### Description
Allows creating a DashSet from an iterator of elements via the FromIterator trait.
```

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

### Access key reference

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Retrieves an immutable reference to the entry key.

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

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

### Access key-value pair from Ref

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/references.md

Retrieves both the key and value as a tuple of references.

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

```rust
let map = DashMap::new();
map.insert("name", "Alice");
let entry = map.get("name").unwrap();
let (k, v) = entry.pair();
```

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

### len

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/read-only-view.md

Returns the number of key-value pairs in the view.

```APIDOC
## len

### Description
Returns the number of key-value pairs in the view.

### Signature
`pub fn len(&self) -> usize`

### Returns
`usize` - Number of entries
```

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

### or_insert_with

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Returns a mutable reference to the value. If the entry is vacant, calls the function to create and insert a value.

```APIDOC
## pub fn or_insert_with(self, value: impl FnOnce() -> V) -> RefMut<'a, K, V>

### Description
Returns a mutable reference to the value. If the entry is vacant, calls the function to create and insert a value.

### Parameters
- **value** (Closure () -> V) - Required - Function to generate value if vacant

### Returns
- **RefMut<'a, K, V>** - Mutable reference to the value
```

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

### Concurrent Iteration in DashMap

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/iterators.md

Demonstrates how other threads can modify the map while an iteration is in progress.

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

let map = Arc::new(DashMap::new());
map.insert("a", 1);

let map_clone = map.clone();
std::thread::spawn(move || {
    // This happens while iteration may be in progress
    map_clone.insert("b", 2);
});

for entry in map.iter() {
    // May or may not see "b" depending on timing
    println!("{}: {}", entry.key(), entry.value());
}
```

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

### or_try_insert_with

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/api-reference/entry-api.md

Tries to insert a value generated from a closure if the entry is vacant, returning a Result.

```APIDOC
### `or_try_insert_with`

```rust
pub fn or_try_insert_with<E>(
    self,
    value: impl FnOnce() -> Result<V, E>,
) -> Result<RefMut<'a, K, V>, E>
where
    K: From<&'q Q>,
```

Tries to insert from closure if vacant.
```

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

### Pin DashMap Version in Cargo.toml

Source: https://github.com/xacrimon/dashmap/blob/master/_autodocs/configuration.md

Use this configuration to lock the dependency to a specific minor version for MSRV stability.

```toml
[dependencies]
dashmap = "7.0.*"  # Locks to 7.0.x with stable MSRV
```
Tokens:
Raw