mutable
A Database System for Research and Fast Prototyping
Loading...
Searching...
No Matches
Data Structures | Public Types | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Friends
m::RefCountingHashMap< Key, Value, Hash, KeyEqual > Struct Template Reference

#include <RefCountingHashMap.hpp>

Collaboration diagram for m::RefCountingHashMap< Key, Value, Hash, KeyEqual >:
[legend]

Data Structures

struct  entry_type
 
struct  the_bucket_iterator
 
struct  the_iterator
 

Public Types

using key_type = Key
 
using mapped_type = Value
 
using value_type = std::pair< const Key, Value >
 
using hasher = Hash
 
using key_equal = KeyEqual
 
using pointer = value_type *
 
using const_pointer = const value_type *
 
using reference = value_type &
 
using const_reference = const value_type &
 
using size_type = std::size_t
 
using difference_type = std::ptrdiff_t
 
using iterator = the_iterator< false >
 
using const_iterator = the_iterator< true >
 
using bucket_iterator = the_bucket_iterator< false >
 
using const_bucket_iterator = the_bucket_iterator< true >
 

Public Member Functions

 RefCountingHashMap (size_type bucket_count, const hasher &hash=hasher(), const key_equal &equal=key_equal())
 
 ~RefCountingHashMap ()
 
size_type capacity () const
 
size_type size () const
 
size_type mask () const
 
size_type masked (size_type index) const
 
float max_load_factor () const
 
void max_load_factor (float ml)
 
size_type watermark_high () const
 
iterator begin ()
 
iterator end ()
 
const_iterator begin () const
 
const_iterator end () const
 
const_iterator cbegin () const
 
const_iterator cend () const
 
iterator insert_with_duplicates (key_type key, mapped_type value)
 
std::pair< iterator, bool > insert_without_duplicates (key_type key, mapped_type value)
 
iterator find (const key_type &key)
 
const_iterator find (const key_type &key) const
 
bucket_iterator bucket (const key_type &key)
 
const_bucket_iterator bucket (const key_type &key) const
 
void for_all (const key_type &key, std::function< void(value_type &)> callback)
 
void for_all (const key_type &key, std::function< void(const value_type &)> callback) const
 
size_type count (const key_type &key) const
 
void rehash ()
 
void resize (std::size_t new_capacity)
 
void shrink_to_fit ()
 
void dump (std::ostream &out) const
 
void dump () const
 

Private Member Functions

void rehash (std::size_t new_capacity)
 Rehash all elements.
 
void initialize ()
 

Static Private Member Functions

static entry_typeallocate (size_type n, entry_type *hint=nullptr)
 

Private Attributes

const hasher h_
 
const key_equal eq_
 
entry_typetable_ = nullptr
 A pointer to the beginning of the table.
 
size_type capacity_ = 0
 The total number of entries allocated in the table.
 
size_type size_ = 0
 The number of occupied entries in the table.
 
size_type watermark_high_
 The maximum size before resizing.
 
float max_load_factor_ = .85
 The maximum load factor before resizing.
 

Friends

M_LCOV_EXCL_START friend std::ostream & operator<< (std::ostream &out, const RefCountingHashMap &map)
 

Detailed Description

template<typename Key, typename Value, typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
struct m::RefCountingHashMap< Key, Value, Hash, KeyEqual >

Definition at line 31 of file RefCountingHashMap.hpp.

Member Typedef Documentation

◆ bucket_iterator

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::bucket_iterator = the_bucket_iterator<false>

Definition at line 150 of file RefCountingHashMap.hpp.

◆ const_bucket_iterator

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::const_bucket_iterator = the_bucket_iterator<true>

Definition at line 151 of file RefCountingHashMap.hpp.

◆ const_iterator

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::const_iterator = the_iterator<true>

Definition at line 148 of file RefCountingHashMap.hpp.

◆ const_pointer

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::const_pointer = const value_type*

Definition at line 39 of file RefCountingHashMap.hpp.

◆ const_reference

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::const_reference = const value_type&

Definition at line 41 of file RefCountingHashMap.hpp.

◆ difference_type

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::difference_type = std::ptrdiff_t

Definition at line 43 of file RefCountingHashMap.hpp.

◆ hasher

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::hasher = Hash

Definition at line 36 of file RefCountingHashMap.hpp.

◆ iterator

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::iterator = the_iterator<false>

Definition at line 147 of file RefCountingHashMap.hpp.

◆ key_equal

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::key_equal = KeyEqual

Definition at line 37 of file RefCountingHashMap.hpp.

◆ key_type

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::key_type = Key

Definition at line 33 of file RefCountingHashMap.hpp.

◆ mapped_type

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::mapped_type = Value

Definition at line 34 of file RefCountingHashMap.hpp.

◆ pointer

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::pointer = value_type*

Definition at line 38 of file RefCountingHashMap.hpp.

◆ reference

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::reference = value_type&

Definition at line 40 of file RefCountingHashMap.hpp.

◆ size_type

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::size_type = std::size_t

Definition at line 42 of file RefCountingHashMap.hpp.

◆ value_type

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
using m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::value_type = std::pair<const Key, Value>

Definition at line 35 of file RefCountingHashMap.hpp.

Constructor & Destructor Documentation

◆ RefCountingHashMap()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::RefCountingHashMap ( size_type  bucket_count,
const hasher hash = hasher(),
const key_equal equal = key_equal() 
)
inline

◆ ~RefCountingHashMap()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::~RefCountingHashMap ( )
inline

Member Function Documentation

◆ allocate()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
static entry_type * m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::allocate ( size_type  n,
entry_type hint = nullptr 
)
inlinestaticprivate

◆ begin() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::begin ( )
inline

◆ begin() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::begin ( ) const
inline

◆ bucket() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
bucket_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::bucket ( const key_type key)
inline

◆ bucket() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_bucket_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::bucket ( const key_type key) const
inline

◆ capacity()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::capacity ( ) const
inline

◆ cbegin()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::cbegin ( ) const
inline

◆ cend()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::cend ( ) const
inline

◆ count()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::count ( const key_type key) const
inline

◆ dump() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::dump ( ) const
inline

◆ dump() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::dump ( std::ostream &  out) const
inline

Definition at line 393 of file RefCountingHashMap.hpp.

◆ end() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::end ( )
inline

◆ end() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::end ( ) const
inline

◆ find() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::find ( const key_type key)
inline

◆ find() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const_iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::find ( const key_type key) const
inline

◆ for_all() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::for_all ( const key_type key,
std::function< void(const value_type &)>  callback 
) const
inline

◆ for_all() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::for_all ( const key_type key,
std::function< void(value_type &)>  callback 
)
inline

◆ initialize()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::initialize ( )
inlineprivate

◆ insert_with_duplicates()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
iterator m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::insert_with_duplicates ( key_type  key,
mapped_type  value 
)
inline

◆ insert_without_duplicates()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
std::pair< iterator, bool > m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::insert_without_duplicates ( key_type  key,
mapped_type  value 
)
inline

◆ mask()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::mask ( ) const
inline

◆ masked()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::masked ( size_type  index) const
inline

◆ max_load_factor() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
float m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::max_load_factor ( ) const
inline

◆ max_load_factor() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::max_load_factor ( float  ml)
inline

◆ rehash() [1/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::rehash ( )
inline

◆ rehash() [2/2]

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::rehash ( std::size_t  new_capacity)
inlineprivate

◆ resize()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::resize ( std::size_t  new_capacity)
inline

◆ shrink_to_fit()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
void m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::shrink_to_fit ( )
inline

◆ size()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::size ( ) const
inline

◆ watermark_high()

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::watermark_high ( ) const
inline

Friends And Related Function Documentation

◆ operator<<

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
M_LCOV_EXCL_START friend std::ostream & operator<< ( std::ostream &  out,
const RefCountingHashMap< Key, Value, Hash, KeyEqual > &  map 
)
friend

Definition at line 379 of file RefCountingHashMap.hpp.

Field Documentation

◆ capacity_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::capacity_ = 0
private

◆ eq_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const key_equal m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::eq_
private

◆ h_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
const hasher m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::h_
private

◆ max_load_factor_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
float m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::max_load_factor_ = .85
private

◆ size_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::size_ = 0
private

◆ table_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
entry_type* m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::table_ = nullptr
private

◆ watermark_high_

template<typename Key , typename Value , typename Hash = std::hash<Key>, typename KeyEqual = std::equal_to<Key>>
size_type m::RefCountingHashMap< Key, Value, Hash, KeyEqual >::watermark_high_
private

The documentation for this struct was generated from the following file: