edm::ReusableObjectHolder< T > Class Template Reference

#include <ReusableObjectHolder.h>

Public Member Functions
void	add (std::unique_ptr< T > iItem)
template<typename F >
std::shared_ptr< T >	makeOrGet (F iFunc)
	If there isn't an object already available, creates a new one using iFunc. More...
template<typename FM , typename FC >
std::shared_ptr< T >	makeOrGetAndClear (FM iMakeFunc, FC iClearFunc)
	ReusableObjectHolder ()
	ReusableObjectHolder (ReusableObjectHolder &&iOther)
std::shared_ptr< T >	tryToGet ()
	~ReusableObjectHolder ()

Private Member Functions
void	addBack (T *iItem)

Private Attributes
tbb::concurrent_queue< T * >	m_availableQueue
std::atomic< size_t >	m_outstandingObjects

Detailed Description

template<class T>
class edm::ReusableObjectHolder< T >

Description: Thread safe way to do create and reuse a group of the same object type.

Usage: This class can be used to safely reuse a series of objects created on demand. The reuse of the objects is safe even across different threads since one can safely call all member functions of this class on the same instance of this class from multiple threads.

This class manages the cache of reusable objects and therefore an instance of this class must live as long as you want the cache to live.

The primary way of using the class it to call makeOrGetAndClear An example use would be

auto objectToUse = holder.makeOrGetAndClear(
                            []() { return new MyObject(10); }, //makes new one
                            [](MyObject* old) {old->reset(); } //resets old one
                   );

If you always want to set the values you can use makeOrGet

auto objectToUse = holder.makeOrGet(
                        []() { return new MyObject(); });
objectToUse->setValue(3);

NOTE: If you hold onto the std::shared_ptr<> until another call to the ReusableObjectHolder, make sure to release the shared_ptr before the call. That way the object you were just using can go back into the cache and be reused for the call you are going to make. An example

std::shared_ptr<MyObject> obj;
while(someCondition()) {
  //release object so it can re-enter the cache
  obj.release();
  obj = holder.makeOrGet([]{ return new MyObject();} );
  obj->setValue(someNewValue());
  useTheObject(obj);
}

The above example is very contrived, since the better way to do the above is

while(someCondition()) {
  auto obj = holder.makeOrGet([]{ return new MyObject();} );
  obj->setValue(someNewValue());
  useTheObject(obj);
  //obj goes out of scope and returns the object to the cache
}

Definition at line 77 of file ReusableObjectHolder.h.

Constructor & Destructor Documentation

template<class T>

edm::ReusableObjectHolder< T >::ReusableObjectHolder ( )

inline

Definition at line 79 of file ReusableObjectHolder.h.

:m_outstandingObjects(0){}

template<class T>

edm::ReusableObjectHolder< T >::ReusableObjectHolder ( ReusableObjectHolder< T > &&  iOther )

inline

Definition at line 80 of file ReusableObjectHolder.h.

                                                       :
    m_availableQueue(std::move(iOther.m_availableQueue)),
    m_outstandingObjects(0) {
      assert(0== iOther.m_outstandingObjects);
    }

template<class T>

edm::ReusableObjectHolder< T >::~ReusableObjectHolder ( )

inline

Definition at line 85 of file ReusableObjectHolder.h.

                            {
      assert(0==m_outstandingObjects);
        T* item = 0;
      while(  m_availableQueue.try_pop(item)) {
        delete item;
      }
    }

Member Function Documentation

template<class T>

void edm::ReusableObjectHolder< T >::add ( std::unique_ptr< T >  iItem )

inline

Adds the item to the cache. Use this function if you know ahead of time how many cached items you will need.

Definition at line 96 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGet(), edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGetAndClear(), and counter.Counter::register().

                                    {
        if(0!=iItem) {
            m_availableQueue.push(iItem.release());
        }
    }

template<class T>

void edm::ReusableObjectHolder< T >::addBack ( T *  iItem )

inlineprivate

Definition at line 141 of file ReusableObjectHolder.h.

                          {
        m_availableQueue.push(iItem);
      --m_outstandingObjects;
    }

template<class T>

template<typename F >

std::shared_ptr<T> edm::ReusableObjectHolder< T >::makeOrGet ( F  iFunc )

inline

If there isn't an object already available, creates a new one using iFunc.

Definition at line 119 of file ReusableObjectHolder.h.

                                         {
        std::shared_ptr<T> returnValue;
        while ( ! ( returnValue = tryToGet()) ) {
            add( std::unique_ptr<T>(iFunc()) );
        }
        return returnValue;
    }

template<class T>

template<typename FM , typename FC >

std::shared_ptr<T> edm::ReusableObjectHolder< T >::makeOrGetAndClear ( FM  iMakeFunc, FC  iClearFunc  )

inline

If there is an object already available, passes the object to iClearFunc and then returns the object. If there is not an object already available, creates a new one using iMakeFunc

Definition at line 131 of file ReusableObjectHolder.h.

                                                                     {
        std::shared_ptr<T> returnValue;
        while ( ! ( returnValue = tryToGet()) ) {
            add( std::unique_ptr<T>(iMakeFunc()) );
        }
        iClearFunc(returnValue.get());
        return returnValue;
    }

template<class T>

std::shared_ptr<T> edm::ReusableObjectHolder< T >::tryToGet ( )

inline

Tries to get an already created object, if none are available, returns an empty shared_ptr. Use this function in conjunction with add()

Definition at line 105 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGet(), and edm::ReusableObjectHolder< edm::ESProductHost >::makeOrGetAndClear().

                                {
        T* item = 0;
        m_availableQueue.try_pop(item);
        if (0==item) {
            return std::shared_ptr<T>{};
        }
        //instead of deleting, hand back to queue
      auto pHolder = this;
      ++m_outstandingObjects;
        return std::shared_ptr<T>{item, [pHolder](T* iItem) {pHolder->addBack(iItem);} };
    }

Member Data Documentation

template<class T>

tbb::concurrent_queue<T*> edm::ReusableObjectHolder< T >::m_availableQueue

private

Definition at line 146 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::add(), edm::ReusableObjectHolder< edm::ESProductHost >::addBack(), edm::ReusableObjectHolder< edm::ESProductHost >::tryToGet(), and edm::ReusableObjectHolder< edm::ESProductHost >::~ReusableObjectHolder().

template<class T>

std::atomic<size_t> edm::ReusableObjectHolder< T >::m_outstandingObjects

private

Definition at line 147 of file ReusableObjectHolder.h.

Referenced by edm::ReusableObjectHolder< edm::ESProductHost >::addBack(), edm::ReusableObjectHolder< edm::ESProductHost >::tryToGet(), and edm::ReusableObjectHolder< edm::ESProductHost >::~ReusableObjectHolder().