Event.h

Go to the documentation of this file.

// Copyright (C) 2002-2026 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/CurrentContext.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;
class TFile;
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();


  static const char* const EVENT_TREE_NAME;
  static const char* const EVENT_RNTUPLE_NAME;
  static const char* const METADATA_OBJECT_NAME;

  static std::unique_ptr<Event> createAndReadFrom(TFile& file);

  virtual StatusCode  readFrom(TFile& inFile) = 0;

  virtual StatusCode writeTo(TFile& file) = 0;

  virtual StatusCode finishWritingTo(TFile& file) = 0;

  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);



  virtual ::Long64_t getEntries() const = 0;
  virtual ::Int_t getEntry(::Long64_t entry, ::Int_t getall = 0) = 0;

  virtual ::Int_t fill() = 0;

  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;

  const EventContext& currentContext() 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::vector<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;
 
#ifndef XAOD_STANDALONE
  EventContext m_ctx;
#endif
 
};  // class Event
 
}  // namespace xAOD
 
// Include the implementation of the template functions.
#include "xAODRootAccess/Event.icc"
 
#endif  // XAODROOTACCESS_EVENT_H