TAuxStore.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
//
// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
//
#ifndef XAODROOTACCESS_TAUXSTORE_H
#define XAODROOTACCESS_TAUXSTORE_H
 
// STL include(s):
#include <vector>
#include <string>
 
// EDM include(s):
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/IAuxStoreIO.h"
#include "AthContainers/tools/threading.h"
#include "xAODCore/AuxSelection.h"
 
// Local include(s):
#include "AsgMessaging/StatusCode.h"
 
#include "Rtypes.h"
 
// Forward declaration(s):
class TTree;
class TBranch;
namespace SG {
   class IAuxTypeVector;
   class AuxStoreInternal;
}
 
namespace xAOD {
 
   // Forward declaration(s):
   class TEvent;
 
   class TAuxStore : public SG::IAuxStore,
                     public SG::IAuxStoreIO {
 
      friend class TEvent;
 
   public:
      enum EStructMode {
         kUndefinedStore = 0, 
         kContainerStore = 1, 
         kObjectStore    = 2  
      };
      typedef SG::auxid_t auxid_t;
      typedef SG::auxid_set_t auxid_set_t;
 
      TAuxStore( const char* prefix = "", Bool_t topStore = kTRUE,
                 EStructMode mode = kUndefinedStore,
                 Int_t basketSize = 2048, Int_t splitLevel = 0 );
      ~TAuxStore();
 
      EStructMode structMode() const;
      StatusCode setStructMode( EStructMode mode );
 
      const char* prefix() const;
      void setPrefix( const char* prefix );
 
      Bool_t isTopStore() const;
      void setTopStore( Bool_t value = kTRUE );
 
      Int_t basketSize() const;
      void setBasketSize( Int_t value );
 
      Int_t splitLevel() const;
      void setSplitLevel( Int_t value );
 
      StatusCode readFrom( ::TTree* tree, ::Bool_t printWarnings = kTRUE );
      StatusCode writeTo( ::TTree* tree );
 
      Int_t getEntry( Int_t getall = 0 );
 
      void reset();
 
 
      virtual const void* getData( auxid_t auxid ) const override;
 
      virtual const auxid_set_t& getAuxIDs() const override;
 
      virtual void* getDecoration( auxid_t auxid, size_t size,
                                   size_t capacity ) override;
 
      virtual bool isDecoration (auxid_t auxid) const override;
 
      virtual void lock() override;
      virtual bool clearDecorations() override;
 
      virtual void lockDecoration (SG::auxid_t auxid) override;
 
      virtual size_t size() const override;
 
      virtual const SG::IAuxTypeVector* linkedVector( SG::auxid_t auxid ) const override;
      virtual SG::IAuxTypeVector* linkedVector( SG::auxid_t auxid ) override;
 
 
      virtual void* getData( auxid_t auxid, size_t size,
                             size_t capacity ) override;
 
      virtual const auxid_set_t& getWritableAuxIDs() const override;
 
      virtual bool resize( size_t size ) override;
      virtual void reserve( size_t size ) override;
      virtual void shift( size_t pos, ptrdiff_t offs ) override;
      virtual bool insertMove (size_t pos,
                               IAuxStore& other,
                               const SG::auxid_set_t& ignore) override;
 
 
 
      virtual const void* getIOData( auxid_t auxid ) const override;
 
      virtual const std::type_info* getIOType( auxid_t auxid ) const override;
 
      virtual const auxid_set_t& getDynamicAuxIDs() const override;
 
      virtual void
      selectAux( const std::set< std::string >& attributes );
 
      virtual auxid_set_t getSelectedAuxIDs() const override;
 
 
   private:
      StatusCode initStats( ::TTree* tree );
      StatusCode setupInputData( auxid_t auxid );
      StatusCode setupOutputData( auxid_t auxid );
      StatusCode scanInputTree();
      const std::type_info* auxBranchType( ::TBranch* br, const char* auxName,
                                           ::Bool_t staticBranch,
                                           std::string* expectedClassName = nullptr );
      StatusCode setupAuxBranch( ::TBranch* br, const char* auxName,
                                  ::Bool_t staticBranch );
      ::Bool_t isAuxIDSelected( auxid_t auxid ) const;
      static ::Bool_t isPrimitiveBranch( TBranch* br );
      static ::Bool_t isContainerBranch( TBranch* br, auxid_t auxid );
      static ::Bool_t isRegisteredType( auxid_t auxid );
      std::string m_prefix;
      std::string m_dynPrefix;
 
      ::Bool_t m_topStore;
 
      EStructMode m_structMode;
      ::Int_t m_basketSize;
      ::Int_t m_splitLevel;
 
      ::TTree* m_inTree;
      ::TTree* m_outTree;
 
      ::Bool_t m_inputScanned;
 
      AuxSelection m_selection;
      SG::AuxStoreInternal* m_transientStore;
 
      auxid_set_t m_auxIDs;
      std::vector< SG::IAuxTypeVector* > m_vecs;
      std::size_t m_size;
 
      ::Bool_t m_locked;
      std::vector< ::Bool_t > m_isDecoration;
 
      typedef AthContainers_detail::mutex mutex_t;
      typedef AthContainers_detail::lock_guard< mutex_t > guard_t;
      mutable mutex_t m_mutex1, m_mutex2;
 
      class TBranchHandle {
 
      public:
         TBranchHandle( ::Bool_t staticBranch, ::Bool_t primitiveBranch,
                        const std::type_info* ti, void* obj,
                        SG::auxid_t auxid, const std::string* prefix );
 
         ::Int_t getEntry();
         ::TBranch** branchPtr();
         void* objectPtr();
         void* inputObjectPtr();
         void* outputObjectPtr();
         const std::type_info* typeInfo() const;
         void reset();
 
      private:
         ::TBranch* m_branch;
         ::Long64_t m_entry;
         void* m_object;
         ::Bool_t m_static;
         ::Bool_t m_primitive;
         const std::type_info* m_typeInfo;
         ::Bool_t m_needsRead;
         SG::auxid_t m_auxid;
         const std::string* m_prefix;
 
      }; // class TBranchHandle
 
      std::vector< TBranchHandle* > m_branches;
      std::vector< bool > m_branchesWritten;
      std::vector< bool > m_missingBranches;
 
   }; // class TAuxStore
 
} // namespace xAOD
 
#endif // XAODROOTACCESS_TAUXSTORE_H