Event.h

Go to the documentation of this file.

// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
#ifndef XAODROOTACCESS_EVENT_H
#define XAODROOTACCESS_EVENT_H
 
// Local include(s):
#include "xAODRootAccess/tools/IProxyDict.h"
 
// Project include(s):
#include "AsgMessaging/AsgMessaging.h"
#include "AsgMessaging/StatusCode.h"
#include "AthContainers/tools/threading.h"
#include "AthContainers/tools/upgrade_mutex.h"
#include "CxxUtils/checker_macros.h"
#include "xAODEventFormat/EventFormat.h"
#include "xAODRootAccessInterfaces/TVirtualEvent.h"
 
// System include(s).
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
// Forward declaration(s).
class TClass;
namespace xAODPrivate {
class HolderBucket;
class Loader;
}  // namespace xAODPrivate
 
namespace xAOD {
namespace Details {
 
using IProxyDictBase =
#ifdef XAOD_STANDALONE
    IProxyDict;
#else
    implements<IProxyDict>;
#endif
 
// Forward declaration(s).
class IObjectManager;
 
}  // namespace Details
 
// Forward declaration(s).
class TVirtualIncidentListener;
class TVirtualManager;
 
class Event : public TVirtualEvent,
              public Details::IProxyDictBase,
              public asg::AsgMessaging {
 
  // Declare the friend functions/classes.
  friend class xAODPrivate::HolderBucket;
  friend class xAODPrivate::Loader;
 
 public:
  Event(std::string_view name);
  virtual ~Event();
 
 
  void setActive() const;
 
  void setAuxItemList(const std::string& containerKey,
                      const std::string& itemList);
 
  StatusCode addListener(TVirtualIncidentListener* listener);
  StatusCode removeListener(TVirtualIncidentListener* listener);
  void clearListeners();
 
  StatusCode addNameRemap(const std::string& onfile,
                          const std::string& newName);
  void clearNameRemap();
  void printNameRemap() const;
 
  void printProxyWarnings(bool value = true);
 
 
 
  const EventFormat* inputEventFormat() const;
  const EventFormat* outputEventFormat() const;
 
 
 
  std::string dump();
 
  void printIOStats() const;
 
  template <typename T>
  bool contains(const std::string& key);
  template <typename T>
  bool transientContains(const std::string& key) const;
 
  template <typename T>
  StatusCode keys(std::vector<std::string>& vkeys, bool metadata) const;
 
  template <typename T>
  StatusCode retrieve(const T*& obj, const std::string& key);
  template <typename T>
  StatusCode retrieve(T*& obj, const std::string& key);
 
  template <typename T>
  StatusCode record(T* obj, const std::string& key);
  template <typename T>
  StatusCode record(std::unique_ptr<T> obj, const std::string& key);
 
  StatusCode copy(const std::string& pattern = ".*");
 
 
 
  template <typename T>
  bool containsMeta(const std::string& key);
  template <typename T>
  bool transientContainsMeta(const std::string& key) const;
 
  template <typename T>
  StatusCode metaKeys(std::vector<std::string>& vkeys) const;
 
  template <typename T>
  StatusCode retrieveMetaInput(const T*& obj, const std::string& key);
 
  template <typename T>
  StatusCode retrieveMetaOutput(const T*& obj, const std::string& key);
  template <typename T>
  StatusCode retrieveMetaOutput(T*& obj, const std::string& key);
 
  template <typename T>
  StatusCode recordMeta(T* obj, const std::string& key);
  template <typename T>
  StatusCode recordMeta(std::unique_ptr<T> obj, const std::string& key);
 
 
 
  SG::sgkey_t getHash(const std::string& key) const override;
  SG::sgkey_t getKey(const void* obj) const override;
  const std::string& getName(const void* obj) const override;
  const std::string& getName(SG::sgkey_t hash) const override;
 
 protected:
  void* getOutputObject(SG::sgkey_t key, const std::type_info& ti) override;
  const void* getInputObject(SG::sgkey_t key, const std::type_info& ti,
                             bool silent) override;
 
 
 
  SG::DataProxy* proxy(const void* const pTransient) const override;
 
  SG::DataProxy* proxy(const CLID& id, const std::string& key) const override;
 
  SG::DataProxy* proxy_exact(SG::sgkey_t sgkey) const override;
 
  StatusCode addToStore(CLID id, SG::DataProxy* proxy) override;
 
  std::vector<const SG::DataProxy*> proxies() const override;
 
  SG::sgkey_t stringToKey(const std::string& str, CLID clid) override;
 
  const std::string* keyToString(SG::sgkey_t key) const override;
 
  const std::string* keyToString(SG::sgkey_t key, CLID& clid) const override;
 
  void registerKey(SG::sgkey_t key, const std::string& str, CLID clid) override;
 
  SG::DataProxy* recordObject(SG::DataObjectSharedPtr<DataObject> obj,
                              const std::string& key, bool allowMods,
                              bool returnExisting) override;
 
  const std::string& name() const override;
 
 
  StatusCode recordTypeless(void* obj, const std::string& typeName,
                            const std::string& key, bool overwrite = false,
                            bool metadata = true, bool isOwner = true);
 
 
  virtual bool hasInput() const = 0;
  virtual bool hasOutput() const = 0;
 
  virtual StatusCode getNames(const std::string& targetClassName,
                              std::vector<std::string>& vkeys,
                              bool metadata = false) const = 0;
 
  virtual StatusCode connectObject(const std::string& key, bool silent) = 0;
  virtual StatusCode connectMetaObject(const std::string& key, bool silent) = 0;
  virtual StatusCode connectAux(const std::string& prefix, bool standalone) = 0;
  virtual StatusCode connectMetaAux(const std::string& prefix,
                                    bool standalone) = 0;
 
  virtual StatusCode setAuxStore(const std::string& key,
                                 Details::IObjectManager& mgr,
                                 bool metadata) = 0;
 
  virtual StatusCode record(void* obj, const std::string& typeName,
                            const std::string& key, bool overwrite,
                            bool metadata, bool isOwner) = 0;
  virtual StatusCode recordAux(TVirtualManager& mgr, const std::string& key,
                               bool metadata) = 0;
 
 
  void* getOutputObject(const std::string& key, const std::type_info& ti,
                        bool metadata) const;
  const void* getInputObject(const std::string& key, const std::type_info& ti,
                             bool silent, bool metadata);
  bool contains(const std::string& key, const std::type_info& ti,
                bool metadata);
  bool transientContains(const std::string& key, const std::type_info& ti,
                         bool metadata) const;
 
  using Object_t =
      std::unordered_map<std::string, std::unique_ptr<TVirtualManager>>;
 
  Object_t m_inputObjects;
  std::set<std::string> m_inputMissingObjects;
  Object_t m_outputObjects;
 
  Object_t m_inputMetaObjects;
  Object_t m_outputMetaObjects;
 
  EventFormat m_inputEventFormat;
  EventFormat* m_outputEventFormat = nullptr;
 
  std::unordered_map<std::string, std::set<std::string>> m_auxItemList;
 
  std::set<TVirtualIncidentListener*> m_listeners;
 
  std::unordered_map<std::string, std::string> m_nameRemapping;
 
  bool m_printEventProxyWarnings = false;
 
 
  struct BranchInfo {
    std::unique_ptr<SG::DataProxy> m_proxy;
    const ::TClass* m_class = 0;
  };  // struct BranchInfo
 
  using upgrade_mutex_t = AthContainers_detail::upgrade_mutex;
  using upgrading_lock_t =
      AthContainers_detail::upgrading_lock<upgrade_mutex_t>;
  mutable upgrade_mutex_t m_branchesMutex;
 
  mutable SG::SGKeyMap<BranchInfo> m_branches
      ATLAS_THREAD_SAFE;  // protected by mutex
 
 
 
  const xAOD::EventFormatElement* getEventFormatElement(
      SG::sgkey_t sgkey) const;
 
  const BranchInfo* getBranchInfo(SG::sgkey_t sgkey) const;
 
 
};  // class Event
 
}  // namespace xAOD
 
// Include the implementation of the template functions.
#include "xAODRootAccess/Event.icc"
 
#endif  // XAODROOTACCESS_EVENT_H