REvent.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_REVENT_H
#define XAODROOTACCESS_REVENT_H
 
// STL include(s):
#include <unordered_map>
#include <set>
#include <string>
#include <vector>
#include <memory>
#include <unordered_map>
 
// ROOT include(s):
#include <Rtypes.h>
#include <ROOT/REntry.hxx>
#include <ROOT/RNTupleModel.hxx>
#include <ROOT/RNTupleReader.hxx>
#include <ROOT/RNTupleWriter.hxx>
#include <ROOT/RError.hxx>
 
// EDM include(s):
#include "xAODEventFormat/EventFormat.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "CxxUtils/checker_macros.h"
#include "AthContainers/tools/threading.h"
#include "AthContainers/tools/upgrade_mutex.h"
#include "CxxUtils/sgkey_t.h"
 
// Interface include(s):
#include "xAODRootAccessInterfaces/TVirtualEvent.h"
 
// Local include(s):
#include "AsgMessaging/StatusCode.h"
#include "CxxUtils/checker_macros.h"
#include "xAODRootAccess/tools/IProxyDict.h"
 
// Make the RNTuple types available in the ROOT namespace
// with all versions of ROOT.
#if ROOT_VERSION_CODE < ROOT_VERSION(6, 35, 1)
namespace ROOT {
using Experimental::RNTupleReader;
using Experimental::RNTupleWriter;
using Experimental::REntry;
using Experimental::RException;
using Experimental::kInvalidDescriptorId;
}  // namespace ROOT
#endif  // ROOT_VERSION_CODE < ROOT_VERSION(6, 36, 0)
 
 
// Forward declaration(s):
class TFile;
class TChain;
class TTree;
namespace std {
   class type_info;
}
namespace SG {
   class IAuxStore;
}
namespace xAODPrivate {
   class RHolderBucket;
   class RLoader;
}
// namespace CP {
//    class xAODWriterAlg;
// }
// class xAODTEventBranch;
// class xAODTMetaBranch;
 
namespace xAOD {
 
   // Forward declaration(s):
   class TVirtualManager;
   class TVirtualIncidentListener;
   class TObjectManager;
   // class TAuxStore;
   class THolder;
   // ::TTree* MakeTransientTree ATLAS_NOT_THREAD_SAFE ( REvent&, const char* );
 
   namespace Experimental {
 
   // Forward declaration(s):
   class RObjectManager;
   class REvent;
 
 
#ifdef XAOD_STANDALONE
   class REvent : public TVirtualEvent, IProxyDict {
#else
   class REvent : public TVirtualEvent, public implements<IProxyDict> {
#endif
      // Declare the friend functions/classes:
      // friend ::TTree* MakeTransientTree( REvent&, const char* );
      // friend class ::xAODTEventBranch;
      // friend class ::xAODTMetaBranch;
      friend class xAODPrivate::RHolderBucket;
      friend class xAODPrivate::RLoader;
      // friend class CP::xAODWriterAlg;
 
   public:
 
      enum EAuxMode {
         kBranchAccess = 0, 
         kClassAccess  = 1, 
         kAthenaAccess = 2, 
         kUndefinedAccess = 3 
      };
 
      REvent( EAuxMode mode = kUndefinedAccess );
 
      virtual ~REvent();
 
      REvent( const REvent& parent ) = delete;
 
      REvent& operator=( const REvent& rhs ) = delete;
 
      EAuxMode auxMode() const;
 
      std::string dump();
 
      void printIOStats() const;
 
      void setPrintEventProxyWarnings(bool);
 
 
      StatusCode readFrom( const std::string& fileName );
 
      // /// Connect the object to an output file
      // StatusCode writeTo( ::TFile* file, Int_t autoFlush = 200,
      //                      const char* treeName = EVENT_RNTUPLE_NAME );
      // /// Finish writing to an output file
      // StatusCode finishWritingTo( ::TFile* file );
 
      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;
 
 
 
      template< typename T >
      ::Bool_t contains( const std::string& key );
      template< typename T >
      ::Bool_t transientContains( const std::string& key ) const;
 
      template< typename T >
      StatusCode retrieve( const T*& obj, const std::string& key );
      template< typename T >
      StatusCode retrieve( T*& obj, const std::string& key );
 
      // /// Add an output object to the event
      // template< typename T >
      // StatusCode record( T* obj, const std::string& key,
      //                     ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
      // /// Add an output object to the event, explicitly taking ownership of it
      // template< typename T >
      // StatusCode record( std::unique_ptr< T > obj, const std::string& key,
      //                     ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
 
      // /// Add an auxiliary store object to the output
      // SG::IAuxStore* recordAux( const std::string& key,
      //                           SG::IAuxStoreHolder::AuxStoreType type =
      //                           SG::IAuxStoreHolder::AST_ContainerStore,
      //                           Int_t basketSize = 32000,
      //                           Int_t splitLevel = 0 );
 
      // /// Copy an object directly from the input to the output
      // StatusCode copy( const std::string& key,
      //                   ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
      // /// Copy all (ROOT readable) objects directly from the input to the output
      // StatusCode copy( ::Int_t basketSize = 32000, ::Int_t splitLevel = 0 );
 
 
 
      template< typename T >
      ::Bool_t containsMeta( const std::string& key );
      template< typename T >
      ::Bool_t transientContainsMeta( const std::string& key ) 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 );
      // /// Retrieve an output metadata object
      // template< typename T >
      // StatusCode retrieveMetaOutput( T*& obj, const std::string& key );
 
      template< typename T >
      StatusCode recordMeta( T* obj, const std::string& key,
                              ::Int_t basketSize = 32000,
                              ::Int_t splitLevel = 1 );
      template< typename T >
      StatusCode recordMeta( std::unique_ptr< T > obj, const std::string& key,
                              ::Int_t basketSize = 32000,
                              ::Int_t splitLevel = 1 );
 
 
 
      ::Long64_t getEntries() const;
      ::Int_t getEntry( ::Long64_t entry, ::Int_t getall = 0 );
 
      // /// Get how many files are available on the currently defined input
      // ::Long64_t getFiles() const;
      // /// Load the first event for a given file from the input TChain
      // ::Int_t getFile( ::Long64_t file, ::Int_t getall = 0 );
 
      // /// Function filling one event into the output tree
      // ::Int_t fill();
 
      const EventFormat* inputEventFormat() const;
      // /// Get information about the output objects
      // const EventFormat* outputEventFormat() const;
 
 
 
      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;
 
      // Declared public so we can call it from python.
      StatusCode record( void* obj, const std::string& typeName,
                          const std::string& key);
                        //   const std::string& key,
                        //   ::Int_t basketSize, ::Int_t splitLevel,
                        //   ::Bool_t overwrite = kFALSE,
                        //   ::Bool_t metadata = kFALSE,
                        //   ::Bool_t isOwner = kTRUE );
 
      // RDS: TEvent version:
      // /// Internal function for recording an object into the output
      // // Declared public so we can call it from python.
      // StatusCode record( void* obj, const std::string& typeName,
      //                     const std::string& key,
      //                     ::Int_t basketSize, ::Int_t splitLevel,
      //                     ::Bool_t overwrite = kFALSE,
      //                     ::Bool_t metadata = kFALSE,
      //                     ::Bool_t isOwner = kTRUE );
 
   protected:
      // /// Function for retrieving an output object in a non-template way
      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 = false ) override;
 
      void getNames(const std::string& targetClassName,
                    std::vector<std::string>& vkeys,
                    bool metadata = false) const 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 initStats();
      // /// Function for retrieving an output object in a non-template way
      void* getOutputObject( const std::string& key,
                             const std::type_info& ti,
                             ::Bool_t metadata = kFALSE ) const;
      const void* getInputObject( const std::string& key,
                                  const std::type_info& ti,
                                  ::Bool_t silent = kFALSE,
                                  ::Bool_t metadata = kFALSE );
      // /// Internal function for adding an auxiliary store object to the output
      // StatusCode record( TAuxStore* store, const std::string& key,
      //                     ::Int_t basketSize, ::Int_t splitLevel,
      //                     ::Bool_t ownsStore = kFALSE );
      StatusCode connectBranch( const std::string& key,
                                 ::Bool_t silent = kFALSE );
      StatusCode connectMetaBranch( const std::string& key,
                                     ::Bool_t silent = kFALSE );
      StatusCode connectAux( const std::string& prefix, ::Bool_t standalone );
      StatusCode connectMetaAux( const std::string& prefix,
                                  ::Bool_t standalone );
 
 
      StatusCode setUpDynamicStore( TObjectManager& mgr, ::TTree* tree );
      StatusCode setUpDynamicStore( RObjectManager& mgr, ROOT::RNTupleReader* ntupleReader );
 
 
      StatusCode setAuxStore( RObjectManager& mgr,
                               ::Bool_t metadata = kFALSE );
      StatusCode setAuxStore( TObjectManager& mgr);
     
      // /// Function saving the dynamically created auxiliary properties
      // StatusCode putAux( ::TTree& outTree, TVirtualManager& mgr,
      //                     ::Int_t basketSize = 32000, ::Int_t splitLevel = 0,
      //                     ::Bool_t metadata = kFALSE );
     
 
      static ::Bool_t hasAuxStore( const THolder& holder );
 
      static ::Bool_t isAuxStore( const THolder& holder );
 
      static ::Bool_t isStandalone( const THolder& holder );
 
      ::Bool_t contains( const std::string& key,
                         const std::type_info& ti,
                         ::Bool_t metadata = kFALSE );
      ::Bool_t transientContains( const std::string& key,
                                  const std::type_info& ti,
                                  ::Bool_t metadata = kFALSE ) const;
 
      typedef std::unordered_map< std::string,
                                  TVirtualManager* > Object_t;
      typedef std::vector< TVirtualIncidentListener* > Listener_t;
 
      static const ::Int_t CACHE_SIZE;
      static const char* const EVENT_RNTUPLE_NAME;
      static const char* const METADATA_TREE_NAME;
 
      EAuxMode m_auxMode;
 
      std::unique_ptr<ROOT::RNTupleReader> m_inNtupleReader;
 
      ::TTree* m_inMetaTree;
 
      ::Bool_t m_inMetaTreeIsTTree;
 
      ::Long64_t m_entry;
 
      ::TTree* m_outTree;
 
      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;
 
      std::unordered_map< std::string, std::set< std::string > > m_auxItemList;
 
      Listener_t m_listeners;
 
      std::unordered_map< std::string, std::string > m_nameRemapping;
 
      Bool_t m_printEventProxyWarnings = true;
 
 
      struct BranchInfo {
         std::unique_ptr< SG::DataProxy > m_proxy;
         const ::TClass* m_class = 0;
      }; // struct BranchInfo
 
      typedef AthContainers_detail::upgrade_mutex upgrade_mutex_t;
      typedef AthContainers_detail::upgrading_lock< upgrade_mutex_t > upgrading_lock_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 REvent
 
   } // namepace Experimental
 
} // namespace xAOD
 
// Include the template implementation(s).
#include "REvent.icc"
 
#endif // XAODROOTACCESS_REVENT_H