ExtendedEventContext.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_EXTENDEDEVENTCONTEXT_H
#define ATHENAKERNEL_EXTENDEDEVENTCONTEXT_H
 
#include "AthenaKernel/IProxyDict.h"
#include "GaudiKernel/EventIDBase.h"
#include "GaudiKernel/EventContext.h"
#include "CxxUtils/checker_macros.h"
 
class TrigRoiDescriptor; 
namespace SG {
class ThinningCache;
}
namespace std { namespace pmr {
class memory_resource;
}}
 
namespace Atlas {
 
  class ExtendedEventContext {
  public:
    ExtendedEventContext(){};
 
    ExtendedEventContext(IProxyDict* p,
                         EventIDBase::number_type conditionsRun = EventIDBase::UNDEFNUM,
                         const TrigRoiDescriptor* roi = nullptr)
      : m_proxy (p), m_conditionsRun (conditionsRun), m_roi (roi)
    {}
 
    void setProxy(IProxyDict* proxy) { m_proxy = proxy; }
    IProxyDict* proxy ATLAS_NOT_CONST_THREAD_SAFE () const { return m_proxy; }
 
    void setConditionsRun (EventIDBase::number_type conditionsRun)
    { m_conditionsRun = conditionsRun; }
    EventIDBase::number_type conditionsRun() const
    { return m_conditionsRun;  }

    const TrigRoiDescriptor* roiDescriptor() const { return m_roi; }
 

    void setThinningCache (const SG::ThinningCache* cache) { m_thinningCache = cache; }
    const SG::ThinningCache* thinningCache() const { return m_thinningCache; }
 

    void setMemResource (std::pmr::memory_resource* memResource) { m_memResource = memResource; }
    std::pmr::memory_resource* memResource ATLAS_NOT_CONST_THREAD_SAFE () const { return m_memResource; }
 
 
  private:
    IProxyDict* m_proxy {nullptr};
    EventIDBase::number_type m_conditionsRun {EventIDBase::UNDEFNUM};
    const TrigRoiDescriptor* m_roi {nullptr};
    const SG::ThinningCache* m_thinningCache {nullptr};
    std::pmr::memory_resource* m_memResource{nullptr};
  };
 
 
  //**********************************************************************
  // Out-of-line routines for setting and getting the event context.
  // Under some circumstances, the dynamic loader can bind the same
  // symbol to different addresses in different libraries.  Among
  // other effects, this can cause std::any to malfunction; std::any
  // is used inside EventContext to hold the extended context.
  // To try to avoid this, we provide out-of-line functions
  // to manipulate the extended context.

  bool hasExtendedEventContext (const EventContext& ctx);
 

  const ExtendedEventContext& getExtendedEventContext (const EventContext& ctx);
 

  const ExtendedEventContext* tryGetExtendedEventContext (const EventContext& ctx);
 

  ExtendedEventContext& getExtendedEventContext (EventContext& ctx);
 

  ExtendedEventContext* tryGetExtendedEventContext (EventContext& ctx);
 

  void setExtendedEventContext (EventContext& ctx,
                                ExtendedEventContext&& ectx);
} // namespace Atlas
 
#endif