ThreadSpecificUserAction.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef G4ATLASTOOLS_THREADSPECIFICUSERACTION_H
#define G4ATLASTOOLS_THREADSPECIFICUSERACTION_H
 
// System includes
#include <thread>
#include <memory>
#include <utility>
 
// Other includes
#include "tbb/concurrent_unordered_map.h"
 
namespace G4UA
{
 
  template<class ActionType>
  class ThreadSpecificUserAction
  {
 
    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;
 
      ~ThreadSpecificUserAction() {
        for(auto& mapPair : m_threadMap){
          delete mapPair.second;
        }
        m_threadMap.clear();
      }
 
      ActionType* get() {
        auto mapItr = m_threadMap.find( std::this_thread::get_id() );
        if(mapItr == m_threadMap.end()) return nullptr;
        return mapItr->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();
      }
 
      template< class ResultType, class Mapper, class Reducer >
      void accumulate( ResultType& result, Mapper mapOp, Reducer reduceOp )
      {
        // Wrapping the ops in std::function allows for some constrained
        // flexibility and avoids difficult template determination in the args.
        std::function<const ResultType&(const ActionType&)> mapper = mapOp;
        std::function<void(ResultType&, const ResultType&)> reducer = reduceOp;
        // Loop over user actions and apply the functions
        for(const auto& keyVal : m_threadMap) {
          reducer( result, mapper(*keyVal.second) );
        }
      }
 
    private:
 
      ThreadMap_t m_threadMap;
 
  }; // class ThreadSpecificUserAction
 
} // namespace G4UA
 
#endif // G4ATLASTOOLS_THREADSPECIFICUSERACTION_H