ContextSpecificPtr.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 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.                                             *
\***********************************************************************************/
#pragma once
 
#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:
      T* get() const {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        return m_ptrs[currentContextId()];
      }

      T*& set( T* ptr ) {
        auto lock                         = std::scoped_lock{ m_ptrs_lock };
        return m_ptrs[currentContextId()] = ptr;
      }

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

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

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

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

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


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

      template <class Mapper>
      auto accumulate( Mapper f, std::invoke_result_t<Mapper, const T*> init ) const -> decltype( init ) {
        return accumulate( f, init, std::plus<>() );
      }

      template <class Mapper, class BinaryOperation>
      auto accumulate( Mapper f, std::invoke_result_t<Mapper, const T*> init, BinaryOperation op ) const
          -> decltype( init ) {
        auto lock = std::scoped_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 {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.second );
      }

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

      template <class F>
      void for_all( F f ) const {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.first, i.second );
      }
      template <class F>
      void for_all( F f ) {
        auto lock = std::scoped_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(); }

      T& get() const {
        if ( !m_ptr ) m_ptr.set( new T( m_proto ) );
        return *m_ptr;
      }

      operator T&() { return get(); }
      operator const T&() const { return get(); }
 
      ContextSpecificPtr<T>& operator->() {
        get(); // ensure there is a value for this thread
        return m_ptr;
      }
      const ContextSpecificPtr<T>& operator->() const {
        get(); // ensure there is a value for this thread
        return m_ptr;
      }


      T& operator=( const T& other ) { return static_cast<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