ContextSpecificPtr.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#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;
    };
  } // namespace Hive
} // namespace Gaudi

#endif // _GAUDI_CONTEXTSPECIFICPTR_H_