LSST Applications 24.1.6,g063fba187b+56b85ce14a,g0f08755f38+df8a265115,g12f32b3c4e+891a09f10d,g1524ad2192+7a5d7b3fbd,g1653933729+a8ce1bb630,g168dd56ebc+a8ce1bb630,g28da252d5a+07cb1400be,g2bbee38e9b+ae03bbfc84,g2bc492864f+ae03bbfc84,g3156d2b45e+6e55a43351,g347aa1857d+ae03bbfc84,g35bb328faa+a8ce1bb630,g3a166c0a6a+ae03bbfc84,g3e281a1b8c+c5dd892a6c,g414038480c+6b9177ef31,g41af890bb2+8f257c4c0b,g781aacb6e4+a8ce1bb630,g7af13505b9+7137b3b17d,g80478fca09+6df6903293,g82479be7b0+091ce1d07f,g858d7b2824+df8a265115,g89c8672015+f4add4ffd5,g9125e01d80+a8ce1bb630,g9726552aa6+414189b318,ga5288a1d22+4a2bca08d7,gacef1a1666+c9a8ff65f4,gb58c049af0+d64f4d3760,gbcfae0f0a0+de1d42d831,gc28159a63d+ae03bbfc84,gcf0d15dbbd+72117bf34e,gda6a2b7d83+72117bf34e,gdaeeff99f8+1711a396fd,ge500cccec5+c8c9c9af63,ge79ae78c31+ae03bbfc84,gf0baf85859+c1f95f4921,gfa517265be+df8a265115,gfa999e8aa5+17cd334064,gfb92a5be7c+df8a265115
LSST Data Management Base Package
Loading...
Searching...
No Matches
Public Member Functions | List of all members
lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred > Class Template Reference

Cache of most recently used values. More...

#include <Cache.h>

Public Member Functions

 Cache (std::size_t maxElements=0)
 Ctor.
 
 Cache (Cache const &)=default
 
 Cache (Cache &&)=default
 
Cacheoperator= (Cache const &)=default
 
Cacheoperator= (Cache &&)=default
 
 ~Cache ()=default
 Dtor.
 
template<typename Generator >
Value operator() (Key const &key, Generator func)
 Lookup or generate a value.
 
Value operator[] (Key const &key)
 
void add (Key const &key, Value const &value)
 Add a value to the cache.
 
std::size_t size () const
 Return the number of values in the cache.
 
std::vector< Key > keys () const
 Return all keys in the cache, most recent first.
 
bool contains (Key const &key)
 Does the cache contain the key?
 
std::optional< Value > get (Key const &key)
 Return the cached value if it exists.
 
std::size_t capacity () const
 Return the capacity of the cache.
 
void reserve (std::size_t maxElements)
 Change the capacity of the cache.
 
void flush ()
 Empty the cache.
 

Detailed Description

template<typename Key, typename Value, typename KeyHash, typename KeyPred>
class lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >

Cache of most recently used values.

This object stores the most recent maxElements values, where maxElements is set in the constructor. Objects (of type Value) are stored by a key (of type Key; hence the need to provide a KeyHash and KeyPred), and the class presents a dict-like interface. Objects may be added to (add) and retrieved from (operator[]) the cache. For ease of use, an interface (operator()) is also provided that will check the cache for an existing key, and if the key is not present, generate it with a function provided by the user.

Note
Value and Key must be copyable.
This header (Cache.h) should generally only be included in source files, not other header files, because you probably don't want all of the boost::multi_index includes in your header. We suggest you se the CacheFwd.h file in your header instead, and hold the Cache as a std::unique_ptr.
Python bindings (for pybind11) are available in lsst/cpputils/python/Cache.h.

Definition at line 75 of file Cache.h.

Constructor & Destructor Documentation

◆ Cache() [1/3]

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::Cache ( std::size_t maxElements = 0)
inline

Ctor.

The maximum number of elements may be zero (default), in which case the cache is permitted to grow without limit.

Exception Safety
Strong exception safety: exceptions will return the system to previous state.

Definition at line 85 of file Cache.h.

85 : _maxElements(maxElements) {
86 _container.template get<Hash>().reserve(maxElements);
87#ifdef LSST_CACHE_DEBUG
88 _debuggingEnabled = false;
89 _hits = 0;
90 _total = 0;
91 _requests.reserve(maxElements);
92#endif
93 }

◆ Cache() [2/3]

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::Cache ( Cache< Key, Value, KeyHash, KeyPred > const & )
default

◆ Cache() [3/3]

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::Cache ( Cache< Key, Value, KeyHash, KeyPred > && )
default

◆ ~Cache()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::~Cache ( )
default

Dtor.

Member Function Documentation

◆ add()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
void lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::add ( Key const & key,
Value const & value )

Add a value to the cache.

If the key is already in the cache, the existing value will be promoted to the most recently used value.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 318 of file Cache.h.

318 {
319 auto result = _lookup(key);
320 if (!result.second) {
321 _addNew(key, value);
322 }
323}
py::object result
Definition _schema.cc:429

◆ capacity()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
std::size_t lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::capacity ( ) const
inline

Return the capacity of the cache.

Exception Safety
No exceptions can be thrown.

Definition at line 201 of file Cache.h.

201{ return _maxElements; }

◆ contains()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
bool lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::contains ( Key const & key)
inline

Does the cache contain the key?

If the key is in the cache, it will be promoted to the most recently used value.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 178 of file Cache.h.

178{ return _lookup(key).second; }

◆ flush()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
void lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::flush ( )

Empty the cache.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 336 of file Cache.h.

336 {
337 while (size() > 0) {
338 _container.template get<Sequence>().pop_back();
339 }
340}
std::size_t size() const
Return the number of values in the cache.
Definition Cache.h:161

◆ get()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
std::optional< Value > lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::get ( Key const & key)
inline

Return the cached value if it exists.

If the key is in the cache, it will be promoted to the most recently used value.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 188 of file Cache.h.

188 {
189 auto result = _lookup(key);
190 if (result.second) {
191 return std::optional<Value>(result.first->second);
192 } else {
193 return std::optional<Value>();
194 }
195 }

◆ keys()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
std::vector< Key > lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::keys ( ) const

Return all keys in the cache, most recent first.

Exception Safety
Strong exception safety: exceptions will return the system to previous state.

Definition at line 326 of file Cache.h.

326 {
329 for (auto & keyValue : _container.template get<Sequence>()) {
330 result.push_back(keyValue.first);
331 }
332 return result;
333}
std::optional< Value > get(Key const &key)
Return the cached value if it exists.
Definition Cache.h:188
T reserve(T... args)

◆ operator()()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
template<typename Generator >
Value lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::operator() ( Key const & key,
Generator func )

Lookup or generate a value.

If the key is in the cache, the corresponding value is returned. Otherwise, a value is generated by the provided function which is cached and returned. Thus, the (expensive) Generator function only fires if the corresponding value is not already cached.

The Generator function signature should be:

Value func(Key const& key);

Given the possibility of lambdas, we could have made the required function signature so that it took no arguments. However, it's possible the user has some function that produces a value when given a key, so chose to adopt that signature; any other signature would likely require use of a lambda always.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 294 of file Cache.h.

297 {
298 auto result = _lookup(key);
299 if (result.second) {
300 return result.first->second;
301 }
302 Value value = func(key);
303 _addNew(key, value);
304 return value;
305}

◆ operator=() [1/2]

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
Cache & lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::operator= ( Cache< Key, Value, KeyHash, KeyPred > && )
default

◆ operator=() [2/2]

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
Cache & lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::operator= ( Cache< Key, Value, KeyHash, KeyPred > const & )
default

◆ operator[]()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
Value lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::operator[] ( Key const & key)

Definition at line 308 of file Cache.h.

308 {
309 auto result = _lookup(key);
310 if (result.second) {
311 return result.first->second;
312 }
313 throw LSST_EXCEPT(pex::exceptions::NotFoundError,
314 (boost::format("Unable to find key: %s") % key).str());
315}
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition Exception.h:48

◆ reserve()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
void lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::reserve ( std::size_t maxElements)
inline

Change the capacity of the cache.

Exception Safety
Basic exception safety: exceptions will leave the system in a valid but unpredictable state.

Definition at line 208 of file Cache.h.

208{ _maxElements = maxElements; _trim(); }

◆ size()

template<typename Key , typename Value , typename KeyHash , typename KeyPred >
std::size_t lsst::cpputils::Cache< Key, Value, KeyHash, KeyPred >::size ( ) const
inline

Return the number of values in the cache.

Exception Safety
Strong exception safety: exceptions will return the system to previous state.

Definition at line 161 of file Cache.h.

161{ return _container.size(); }

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