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>
      auto accumulate( Mapper f, std::result_of_t<Mapper( const T* )> init ) const -> decltype( init )
      {
        return accumulate( f, init, std::plus<>() );
      }

      template <class Mapper, class BinaryOperation>
      auto accumulate( Mapper f, std::result_of_t<Mapper( const T* )> init, BinaryOperation op ) const
          -> decltype( init )
      {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        return std::accumulate( m_ptrs.begin(), m_ptrs.end(), init, [&f, &op]( const auto& partial, const auto& p ) {
          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( T proto = {} ) : m_proto( std::move( proto ) ) {}

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

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

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

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

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

      template <class T1, class BinaryOperation>
      T1 accumulate( T1 init, BinaryOperation op ) const
      {
        return m_ptr.accumulate( []( const T* p ) { 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_