/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODRootAccess/xAODRootAccess/TAuxStore.h

// Dear emacs, this is -*- c++ -*-
// $Id: TAuxStore.h 718392 2016-01-19 10:41:32Z krasznaa $
#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 "xAODRootAccess/tools/TReturnCode.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;
      TReturnCode 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 );

      TReturnCode readFrom( ::TTree* tree, ::Bool_t printWarnings = kTRUE );
      TReturnCode writeTo( ::TTree* tree );

      Int_t getEntry( Long64_t entry, Int_t getall = 0 );

      void reset();


      virtual const void* getData( auxid_t auxid ) const;

      virtual const auxid_set_t& getAuxIDs() const;

      virtual void* getDecoration( auxid_t auxid, size_t size,
                                   size_t capacity );

      virtual void lock(); 
      virtual void clearDecorations(); 

      virtual size_t size() const;



      virtual void* getData( auxid_t auxid, size_t size,
                             size_t capacity );

      virtual const auxid_set_t& getWritableAuxIDs() const;

      virtual void resize( size_t size );
      virtual void reserve( size_t size );
      virtual void shift( size_t pos, ptrdiff_t offs );



      virtual const void* getIOData( auxid_t auxid ) const;

      virtual const std::type_info* getIOType( auxid_t auxid ) const;

      virtual const auxid_set_t& getDynamicAuxIDs() const;

      virtual void selectAux( const std::set< std::string >& attributes );

      virtual const auxid_set_t& getSelectedAuxIDs() const;


   private:
      TReturnCode initStats( ::TTree* tree );
      TReturnCode setupInputData( auxid_t auxid ) const;
      TReturnCode setupOutputData( auxid_t auxid ) const;
      TReturnCode scanInputTree();
      TReturnCode 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;

      mutable EStructMode m_structMode;
      ::Int_t m_basketSize;
      ::Int_t m_splitLevel;

      ::Long64_t m_entry;

      ::TTree* m_inTree;
      ::TTree* m_outTree;

      ::Bool_t m_inputScanned;

      AuxSelection m_selection;
      SG::AuxStoreInternal* m_transientStore;

      mutable auxid_set_t m_auxIDs;
      mutable std::vector< SG::IAuxTypeVector* > m_vecs;
      mutable std::size_t m_size;

      ::Bool_t m_locked;
      mutable std::vector< ::Bool_t > m_isDecoration;

      mutable size_t m_tick;

      typedef AthContainers_detail::mutex mutex_t;
      typedef AthContainers_detail::lock_guard< mutex_t > guard_t;
      mutable mutex_t m_mutex1, m_mutex2;

      struct TSAuxidSet {
         size_t m_tick; 
         auxid_set_t m_set; 

         TSAuxidSet( size_t tick, const auxid_set_t& set )
         : m_tick( tick ), m_set( set ) {}
      };

      mutable AthContainers_detail::thread_specific_ptr< TSAuxidSet >
         m_tsAuxids;

      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( ::Long64_t entry );
         ::TBranch** branchPtr();
         void* objectPtr();
         void* inputObjectPtr();
         void* outputObjectPtr();
         const std::type_info* typeInfo() const;
         void reset();

      private:
         ::TBranch* m_branch;
         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

      mutable std::vector< TBranchHandle* > m_branches;
      mutable std::vector< bool > m_branchesWritten;
      mutable std::vector< bool > m_missingBranches;

   }; // class TAuxStore

} // namespace xAOD

#endif // XAODROOTACCESS_TAUXSTORE_H

---