ContextSpecificPtr.h

Go to the documentation of this file.

#ifndef _GAUDI_CONTEXTSPECIFICPTR_H_
#define _GAUDI_CONTEXTSPECIFICPTR_H_

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

// 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_