Empirical
Public Types | Public Member Functions | List of all members
emp::Cache< KEY, T, HASH, PRED, ALLOC > Class Template Reference

#include <Cache.h>

Public Types

using key_type = KEY
 Type we are using to look up values. More...
 
using mapped_type = T
 Contents of the value we look up. More...
 
using hasher = HASH
 Hash method to use. More...
 
using key_equal = PRED
 Function to test if two values are identical. More...
 
using allocator_type = ALLOC
 Function to allocate new space. More...
 

Public Member Functions

 Cache ()
 
 Cache (const Cache &)=default
 
 Cache (Cache &&)=default
 
Cacheoperator= (const Cache &)=default
 
Cacheoperator= (Cache &&)=default
 
size_t size () const
 How many entries are stored in the cache? More...
 
bool Has (const KEY &k) const
 Determine if a specific key is already in the cache. More...
 
void Clear ()
 Erase contents of cache. More...
 
void Erase (const KEY &k)
 Erase a specific entry from cache. More...
 
Get (KEY k, const std::function< T(KEY k)> &calc_fun)
 Lookup a specific key; provide a function to use if value is not in cahce. More...
 
const T & GetRef (const KEY &k, const std::function< T(const KEY &k)> &calc_fun)
 A version of Get that allows calls with const references instead of pass-by-value. More...
 

Member Typedef Documentation

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
using emp::Cache< KEY, T, HASH, PRED, ALLOC >::allocator_type = ALLOC

Function to allocate new space.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
using emp::Cache< KEY, T, HASH, PRED, ALLOC >::hasher = HASH

Hash method to use.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
using emp::Cache< KEY, T, HASH, PRED, ALLOC >::key_equal = PRED

Function to test if two values are identical.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
using emp::Cache< KEY, T, HASH, PRED, ALLOC >::key_type = KEY

Type we are using to look up values.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
using emp::Cache< KEY, T, HASH, PRED, ALLOC >::mapped_type = T

Contents of the value we look up.

Constructor & Destructor Documentation

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
emp::Cache< KEY, T, HASH, PRED, ALLOC >::Cache ( )
inline
template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
emp::Cache< KEY, T, HASH, PRED, ALLOC >::Cache ( const Cache< KEY, T, HASH, PRED, ALLOC > &  )
default
template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
emp::Cache< KEY, T, HASH, PRED, ALLOC >::Cache ( Cache< KEY, T, HASH, PRED, ALLOC > &&  )
default

Member Function Documentation

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
void emp::Cache< KEY, T, HASH, PRED, ALLOC >::Clear ( )
inline

Erase contents of cache.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
void emp::Cache< KEY, T, HASH, PRED, ALLOC >::Erase ( const KEY &  k)
inline

Erase a specific entry from cache.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
T emp::Cache< KEY, T, HASH, PRED, ALLOC >::Get ( KEY  k,
const std::function< T(KEY k)> &  calc_fun 
)
inline

Lookup a specific key; provide a function to use if value is not in cahce.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
const T& emp::Cache< KEY, T, HASH, PRED, ALLOC >::GetRef ( const KEY &  k,
const std::function< T(const KEY &k)> &  calc_fun 
)
inline

A version of Get that allows calls with const references instead of pass-by-value.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
bool emp::Cache< KEY, T, HASH, PRED, ALLOC >::Has ( const KEY &  k) const
inline

Determine if a specific key is already in the cache.

template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
Cache& emp::Cache< KEY, T, HASH, PRED, ALLOC >::operator= ( const Cache< KEY, T, HASH, PRED, ALLOC > &  )
default
template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
Cache& emp::Cache< KEY, T, HASH, PRED, ALLOC >::operator= ( Cache< KEY, T, HASH, PRED, ALLOC > &&  )
default
template<class KEY , class T , class HASH = std::hash<KEY>, class PRED = std::equal_to<KEY>, class ALLOC = std::allocator< std::pair<const KEY,T> >>
size_t emp::Cache< KEY, T, HASH, PRED, ALLOC >::size ( ) const
inline

How many entries are stored in the cache?


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