Files
externals/linux/include/ActivMiddleware/Misc/SharedObjectCache.h
T
2023-12-15 13:15:08 -05:00

121 lines
3.2 KiB
C++

/**
* @file include/ActivMiddleware/Misc/SharedObjectCache.h
*
* @brief Shared object cache template.
*/
#if (!defined ACTIV_MIDDLEWARE_MISC_SHARED_OBJECT_CACHE_H)
#define ACTIV_MIDDLEWARE_MISC_SHARED_OBJECT_CACHE_H
#include "ActivMiddleware/Misc/StlHelper.h"
#include ACTIV_BOOST_INCLUDE(smart_ptr/intrusive_ptr.hpp)
#include ACTIV_BOOST_INCLUDE(smart_ptr/intrusive_ref_counter.hpp)
#include <set>
//! Activ namespace.
namespace Activ
{
/**
* @brief Helper class to order a container of pointers by the pointed-to value rather than virtual address.
*/
template<typename T>
class SharedObjectPointerOrder
{
public:
bool operator()(const T * const pLhs, const T * const pRhs) const
{
return (*pLhs < *pRhs);
}
};
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Cache of objects that can be shared.
*
* T the type of object to cache. Must be copy-constructible.
* ORDER ordering for the underlying set of T*.
*/
template<typename T, typename ORDER = SharedObjectPointerOrder<T> >
class SharedObjectCache
{
public:
/**
* @brief The cached object. Essentially just T with the addition of a reference count.
*/
class CachedObject : public T,
public Boost::intrusive_ref_counter<CachedObject, Boost::intrusive_ref_counter::thread_unsafe_counter>
{
public:
/**
* @brief Destructor. Invoked when all instrusive pointer references to this value are released,
* and causes the value to be removed from the cache.
*/
~CachedObject()
{
m_sharedObjectCache.m_cache.erase(this);
}
private:
/**
* @brief Constructor.
*
* @param sharedObjectCache the cache this object is going to be a member of.
* @param value
*/
CachedObject(SharedObjectCache &sharedObjectCache, const T &value) :
T(value),
m_sharedObjectCache(sharedObjectCache)
{
}
SharedObjectCache &m_sharedObjectCache;
friend class SharedObjectCache;
};
typedef Boost::intrusive_ptr<const CachedObject> Pointer;
/**
* @brief Get an object from the cache.
*
* @param value the value to get from the cache, or new value to be added.
*
* @return Intrusive const-pointer to the value. When all intrusive pointers to the value have been destroyed,
* the value is removed from the cache.
*/
const Pointer Get(const T &value)
{
const CachedObject *pCachedObject;
Cache::iterator iter;
// Lookup an existing member of the cache with value "value", or find where we can insert it.
if (SetFind(m_cache, &value, iter))
{
// Value is in the cache. We know it must be a CachedObject since we created it, so cast is OK.
pCachedObject = static_cast<const CachedObject *>(*iter);
}
else
{
// Create a new value and insert in to the cache.
pCachedObject = new CachedObject(*this, value);
iter = m_cache.insert(iter, pCachedObject);
}
return Pointer(pCachedObject);
}
private:
typedef std::set<const T *, ORDER> Cache;
Cache m_cache;
};
} // namespace Activ
#endif // (!defined ACTIV_MIDDLEWARE_MISC_SHARED_OBJECT_CACHE_H)