pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {
        let mut hash_map = HashMap {
            entry_fastbin: Fastbin::new(mem::size_of::<InternalHashEntry<K, V>>()),
            kv_fastbin: Fastbin::new(mem::size_of::<(K, V)>()),
            hash_table: hash_table::HashTable::new_with_box(),
            hash_builder,
        };
        hash_map.reserve(capacity);
        hash_map
    }
/// Creates an empty `HashMap` with the specified capacity, using `hash_builder`
/// to hash the keys.
///
/// The hash map will be able to hold at least `capacity` elements without
/// reallocating. If `capacity` is 0, the hash map will not allocate.
///
/// Warning: `hash_builder` is normally randomly generated, and
/// is designed to allow HashMaps to be resistant to attacks that
/// cause many collisions and very poor performance. Setting it
/// manually using this function can expose a DoS attack vector.
///
/// # Examples
///
/// ```
/// use hash_ord::hash_map::HashMap;
/// use std::collections::hash_map::RandomState;
///
/// let s = RandomState::new();
/// let mut map = HashMap::with_capacity_and_hasher(10, s);
/// map.insert(1, 2);
/// ```
Creates an empty `HashMap` with the specified capacity, using `hash_builder`
to hash the keys.

The hash map will be able to hold at least `capacity` elements without
reallocating. If `capacity` is 0, the hash map will not allocate.

`hash_builder` is normally randomly generated, and
is designed to allow HashMaps to be resistant to attacks that
cause many collisions and very poor performance. Setting it
manually using this function can expose a DoS attack vector.
Creates an empty ` HashMap ` with the specified capacity using ` hash_builder ` to hash the keys . The hash map will be able to hold at least ` capacity ` elements without reallocating . If ` capacity ` is 0 the hash map will not allocate . ` hash_builder ` is normally randomly generated and is designed to allow HashMaps to be resistant to attacks that cause many collisions and very poor performance . Setting it manually using this function can expose a DoS attack vector .
pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {
        let mut hash_map = HashMap {
            entry_fastbin: Fastbin::new(mem::size_of::<InternalHashEntry<K, V>>()),
            kv_fastbin: Fastbin::new(mem::size_of::<(K, V)>()),
            hash_table: hash_table::HashTable::new_with_box(),
            hash_builder,
        };
        hash_map.reserve(capacity);
        hash_map
    }
pub fn with_capacity_and_hasher ( capacity : usize , hash_builder : S ) -> HashMap < K , V , S > { let mut hash_map = HashMap { entry_fastbin : Fastbin :: new ( mem :: size_of :: < InternalHashEntry < K , V > > ( ) ) , kv_fastbin : Fastbin :: new ( mem :: size_of :: < ( K , V ) > ( ) ) , hash_table : hash_table :: HashTable :: new_with_box ( ) , hash_builder , } ; hash_map . reserve ( capacity ) ; hash_map }
Creates an empty `HashMap` with the specified capacity, using `hash_builder`
to hash the keys.
Creates an empty ` HashMap ` with the specified capacity using ` hash_builder ` to hash the keys .
capacity
usize
hash_builder
S
examples
```
use hash_ord::hash_map::HashMap;
use std::collections::hash_map::RandomState.

let s = RandomState::new();
let mut map = HashMap::with_capacity_and_hasher(10, s);
map.insert(1, 2);
```
` ` ` use hash_ord :: hash_map :: HashMap ; use std :: collections :: hash_map :: RandomState . let s = RandomState :: new () ; let mut map = HashMap :: with_capacity_and_hasher ( 10 s ) ; map . insert ( 1 2 ) ; ` ` `