ThreadActionHolder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef G4ATLASTOOLS__G4UA_THREADACTIONHOLDER_H
#define G4ATLASTOOLS__G4UA_THREADACTIONHOLDER_H
 
// System includes
#include <thread>
#include <memory>
#include <utility>
 
// Other includes
#include "tbb/concurrent_unordered_map.h"
 
namespace G4UA
{
 
  template<class ActionType>
  class ThreadActionHolder
  {
 
    public:
 
      using ThreadMapKey_t = std::thread::id;
      using ThreadMapVal_t = ActionType*;
      //using ThreadMapVal_t = std::unique_ptr<ActionType>; // not supported
      using ThreadMapHash_t = std::hash<ThreadMapKey_t>;
 
      using ThreadMap_t = tbb::concurrent_unordered_map
                          < ThreadMapKey_t, ThreadMapVal_t, ThreadMapHash_t >;
 
      using const_iterator = typename ThreadMap_t::const_iterator;
 
      ~ThreadActionHolder() {
        for(auto mapPair : m_threadMap){
          delete mapPair.second;
        }
        m_threadMap.clear();
      }
 
      ActionType* get() {
        auto mapPair = m_threadMap.find( std::this_thread::get_id() );
        if(mapPair == m_threadMap.end()) return nullptr;
        return mapPair->second;
      }
 
      void set(std::unique_ptr<ActionType> action) {
        const auto tid = std::this_thread::get_id();
        m_threadMap.insert( std::make_pair(tid, action.release()) );
      }
 
      const_iterator begin() const {
        return m_threadMap.begin();
      }
 
      const_iterator end() const {
        return m_threadMap.end();
      }
 
    private:
 
      ThreadMap_t m_threadMap;
 
  }; // class ThreadActionHolder
 
}
 
#endif