ContextSpecificPtr.h

Go to the documentation of this file.

#ifndef _GAUDI_CONTEXTSPECIFICPTR_H_
#define _GAUDI_CONTEXTSPECIFICPTR_H_

#include <unordered_map>
#include <mutex>
#include <numeric>
#include <functional>
#include <type_traits>

// For the definition of GAUDI_API
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/ThreadLocalContext.h"

class EventContext;

namespace Gaudi {
  namespace Hive {
    template< typename T >
    class ContextSpecificPtr {
    private:
      typedef std::unordered_map<ContextIdType, T*> StorageType;
    public:

      inline T* get() const {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        return m_ptrs[currentContextId()];
      }
      inline T*& set(T* ptr) {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        return m_ptrs[currentContextId()] = ptr;
      }

      inline T*& operator= (T* ptr) { return set(ptr); }

      inline bool isValid() const { return get(); }

      inline operator bool () const { return isValid(); }

      inline bool operator==(T* rhs) const { return get() == rhs; }

      inline T& operator* () { return *get(); }
      inline const T& operator* () const { return *get(); }
      inline T* operator-> () { return get(); }
      inline const T* operator-> () const { return get(); }


      void clear() { m_ptrs.clear(); }

      template< class Mapper >
      typename std::result_of<Mapper(const T*)>::type
      accumulate(Mapper f, typename std::result_of<Mapper(const T*)>::type init) const {
        typedef typename std::result_of<Mapper(const T*)>::type R;
        return accumulate(f, init, std::plus<R>());
      }

      template< class Mapper, class BinaryOperation >
      typename std::result_of<Mapper(const T*)>::type
      accumulate(Mapper f, typename std::result_of<Mapper(const T*)>::type init,
                 BinaryOperation op) const {
        typedef typename std::result_of<Mapper(const T*)>::type R;
        typedef typename StorageType::value_type V;
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        return std::accumulate(m_ptrs.begin(), m_ptrs.end(), init,
          [&f, &op](const R& partial, const V& p) -> R {
          return op(partial, f(p.second));
        });
      }

      template< class F >
      void for_each(F f) const {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        for(auto& i: m_ptrs) f(i.second);
      }

      template< class F >
      void for_each(F f) {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        for(auto& i: m_ptrs) f(i.second);
      }

      template< class F >
      void for_all(F f) const {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        for(auto& i: m_ptrs) f(i.first,i.second);
      }
      template< class F >
      void for_all(F f) {
        std::lock_guard<std::mutex> lock(m_ptrs_lock);
        for(auto& i: m_ptrs) f(i.first,i.second);
      }      


      void deleteAll() {
        for_each([](T*& p) {delete p; p = nullptr;});
      }


    private:
      mutable StorageType m_ptrs;
      mutable std::mutex m_ptrs_lock;
    };


    template< typename T >
    class ContextSpecificData {
    public:
      ContextSpecificData(): m_proto() {}
      ContextSpecificData(const T& proto): m_proto(proto) {}

      ~ContextSpecificData() {
        m_ptr.deleteAll();
      }

      inline operator T& () {
        if (m_ptr)
          return *m_ptr;
        else
          return *(m_ptr = new T(m_proto));
      }

      inline operator T& () const {
        if (m_ptr)
          return *m_ptr;
        else
          return *(m_ptr = new T(m_proto));
      }

      inline T& operator= (const T& other) {
        return (T&)(*this) = other;
      }

      inline T accumulate(T init) const {
        return accumulate(init, std::plus<T>());
      }

      template< class T1, class BinaryOperation >
      T1 accumulate(T1 init, BinaryOperation op) const {
        return m_ptr.accumulate([] (const T* p) -> T { return *p; },
                                init, op);
      }

      template< class F >
      void for_each(F f) const {
        m_ptr.for_each([&f] (const T* p) { f(*p); });
      }

      template< class F >
      void for_each(F f) {
        m_ptr.for_each([&f] (T* p) { f(*p); });
      }

      template< class F >
      void for_all(F f) const {
        m_ptr.for_all([&f] (size_t s, const T* p) { f(s,*p); });
      }
      template< class F >
      void for_all(F f) {
        m_ptr.for_all([&f] (size_t s, T* p) { f(s,*p); });
      }      



    private:
      // FIXME: implement a proper copy constructor
      ContextSpecificData(const ContextSpecificData&) = delete;

      T m_proto;
      mutable ContextSpecificPtr<T> m_ptr;

    };
  }
}

#endif // _GAUDI_CONTEXTSPECIFICPTR_H_