Control/xAODRootAccess/xAODRootAccess/TEvent.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TEVENT_H
#define XAODROOTACCESS_TEVENT_H
 
// Local include(s).
#include "xAODRootAccess/Event.h"
 
// Project include(s).
#include "AthContainersInterfaces/IAuxStoreHolder.h"
 
// ROOT include(s).
#include <Rtypes.h>
 
// System include(s).
#include <memory>
#include <string_view>
 
// Forward declaration(s).
class TFile;
class TChain;
class TTree;
namespace CP {
class xAODWriterAlg;
}
class xAODTEventBranch;
class xAODTMetaBranch;
namespace SG {
class IAuxStore;
}
 
namespace xAOD {
 
// Forward declaration(s).
class TAuxStore;
class TObjectManager;
class TChainStateTracker;
class TFileMerger;
class TEvent;
class TTreeMgr;
::TTree* MakeTransientTree ATLAS_NOT_THREAD_SAFE(TEvent&, const char*);
 
class TEvent : public Event {
 
  // Declare the friend functions/classes:
  friend ::TTree* MakeTransientTree(TEvent&, const char*);
  friend class ::xAODTEventBranch;
  friend class ::xAODTMetaBranch;
  friend class xAOD::TFileMerger;
  friend class xAOD::TTreeMgr;
  friend class CP::xAODWriterAlg;
 
 public:
  enum EAuxMode {
    kBranchAccess = 0,  
    kClassAccess = 1,   
    kAthenaAccess = 2   
  };
 
  TEvent(EAuxMode mode = kClassAccess);
  TEvent(::TFile* file, EAuxMode mode = kClassAccess);
  TEvent(::TTree* tree, EAuxMode mode = kClassAccess);
  virtual ~TEvent();
 
  EAuxMode auxMode() const;
 
 
  static const char* const EVENT_TREE_NAME;
 
  StatusCode readFrom(::TFile* file, bool useTreeCache = true,
                      std::string_view treeName = EVENT_TREE_NAME);
  StatusCode readFrom(::TTree* tree, bool useTreeCache = true);
  StatusCode writeTo(::TFile* file, int autoFlush = 200,
                     std::string_view treeName = EVENT_TREE_NAME);
  StatusCode finishWritingTo(::TFile* file);
 
 
 
  // Bring the definition of Event::record into scope
  using Event::record;
 
  SG::IAuxStore* recordAux(const std::string& key,
                           SG::IAuxStoreHolder::AuxStoreType type =
                               SG::IAuxStoreHolder::AST_ContainerStore);
 
 
 
  ::Long64_t getEntries() const;
  ::Int_t getEntry(::Long64_t entry, ::Int_t getall = 0);
 
  ::Long64_t getFiles() const;
  ::Int_t getFile(::Long64_t file, ::Int_t getall = 0);
 
  ::Int_t fill();
 
 
 protected:
 
  bool hasInput() const override;
  bool hasOutput() const override;
 
  StatusCode getNames(const std::string& targetClassName,
                      std::vector<std::string>& vkeys,
                      bool metadata) const override;
 
  StatusCode connectObject(const std::string& key, bool silent) override;
  StatusCode connectMetaObject(const std::string& key, bool silent) override;
  StatusCode connectAux(const std::string& prefix, bool standalone) override;
  StatusCode connectMetaAux(const std::string& prefix,
                            bool standalone) override;
 
  StatusCode setAuxStore(const std::string& key, Details::IObjectManager& mgr,
                         bool metadata) override;
 
  StatusCode record(void* obj, const std::string& typeName,
                    const std::string& key, bool overwrite, bool metadata,
                    bool isOwner) override;
  StatusCode recordAux(TVirtualManager& mgr, const std::string& key,
                       bool metadata) override;
 
 
  StatusCode initStats();
 
  StatusCode record(std::unique_ptr<TAuxStore> store, const std::string& key);
  StatusCode setUpDynamicStore(TObjectManager& mgr, ::TTree* tree);
  StatusCode putAux(::TTree& outTree, TVirtualManager& mgr, bool metadata);
  StatusCode recordAux(TAuxStore* store, const std::string& key);
 
  EAuxMode m_auxMode;
 
  ::TTree* m_inTree = nullptr;
  bool m_inTreeMissing = false;
  ::TChain* m_inChain = nullptr;
  std::unique_ptr<TChainStateTracker> m_inChainTracker;
  ::Int_t m_inTreeNumber = -1;
  ::TTree* m_inMetaTree = nullptr;
  ::Long64_t m_entry = -1;
 
  std::unique_ptr<::TTree> m_outTree;
 
};  // class TEvent
 
}  // namespace xAOD
 
#endif  // XAODROOTACCESS_TEVENT_H