ReusableObjectHolder.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_ReusableObjectHolder_h
#define FWCore_Utilities_ReusableObjectHolder_h

// -*- C++ -*-
//
// Package:     FWCore/Utilities
// Class  :     ReusableObjectHolder
//
//
// Original Author:  Chris Jones
//         Created:  Fri, 31 July 2014 14:29:41 GMT
//

#include <memory>
#include <cassert>
#include <atomic>
#include "tbb/task.h"
#include "tbb/concurrent_queue.h"


namespace edm {
  template<class T>
  class ReusableObjectHolder {
  public:
    ReusableObjectHolder():m_outstandingObjects(0){}
    ReusableObjectHolder(ReusableObjectHolder&& iOther):
    m_availableQueue(std::move(iOther.m_availableQueue)),
    m_outstandingObjects(0) {
      assert(0== iOther.m_outstandingObjects);
    }
    ~ReusableObjectHolder() {
      assert(0==m_outstandingObjects);
        T* item = 0;
      while(  m_availableQueue.try_pop(item)) {
        delete item;
      }
    }
    
    void add(std::unique_ptr<T> iItem){
        if(0!=iItem) {
            m_availableQueue.push(iItem.release());
        }
    }
    
    std::shared_ptr<T> tryToGet() {
        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);} };
    }
    
    template< typename F>
    std::shared_ptr<T> makeOrGet( F iFunc) {
        std::shared_ptr<T> returnValue;
        while ( ! ( returnValue = tryToGet()) ) {
            add( std::unique_ptr<T>(iFunc()) );
        }
        return returnValue;
    }
    
    template< typename FM, typename FC>
    std::shared_ptr<T> makeOrGetAndClear( FM iMakeFunc, FC iClearFunc) {
        std::shared_ptr<T> returnValue;
        while ( ! ( returnValue = tryToGet()) ) {
            add( std::unique_ptr<T>(iMakeFunc()) );
        }
        iClearFunc(returnValue.get());
        return returnValue;
    }
    
  private:
    void addBack(T* iItem){
        m_availableQueue.push(iItem);
      --m_outstandingObjects;
    }
    
    tbb::concurrent_queue<T*> m_availableQueue;
    std::atomic<size_t> m_outstandingObjects;
  };
  
}



#endif /* end of include guard: FWCore_Utilities_ReusableObjectHolder_h */