/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODCore/xAODCore/AuxContainerBase.h

// Dear emacs, this is -*- c++ -*-
// $Id: AuxContainerBase.h 633391 2014-12-03 15:58:38Z ssnyder $
#ifndef XAODCORE_AUXCONTAINERBASE_H
#define XAODCORE_AUXCONTAINERBASE_H

// STL include(s):
#include <vector>
#include <string>

// EDM include(s):
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/IAuxStoreIO.h"
#include "AthContainersInterfaces/IAuxStoreHolder.h"
#include "AthContainers/tools/threading.h"
#include "AthContainers/PackedContainer.h"
#ifndef XAOD_STANDALONE
#   include "AthenaKernel/ILockable.h"
#endif // not XAOD_STANDALONE

// Local include(s):
#include "xAODCore/AuxSelection.h"

// Forward declaration(s):
namespace SG {
   class IAuxTypeVector;
}

namespace xAOD {

   class AuxContainerBase : public SG::IAuxStore,
                            public SG::IAuxStoreIO,
                            public SG::IAuxStoreHolder
#ifndef XAOD_STANDALONE
                          , public ILockable
#endif // not XAOD_STANDALONE
   {

   public:
      typedef SG::auxid_t auxid_t;
      typedef SG::auxid_set_t auxid_set_t;

      AuxContainerBase( bool allowDynamicVars = true );
      AuxContainerBase( const AuxContainerBase& parent );
      AuxContainerBase( const SG::IAuxStore* store );
      ~AuxContainerBase();

      AuxContainerBase& operator=( const AuxContainerBase& rhs );


      virtual SG::IAuxStore* getStore() const;
      virtual void setStore( SG::IAuxStore* store );
      virtual AuxStoreType getStoreType() const { return AST_ContainerStore; }



      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 bool setOption( auxid_t id, const SG::AuxDataOption& option );



      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 SG::auxid_set_t& getSelectedAuxIDs() const;



      const char* name() const;
      void setName( const char* name );


   protected:
      template< typename T >
      void regAuxVar( const std::string& name,
                      std::vector< T >& vec );

      template< typename T >
      void regAuxVar( const std::string& name,
                      SG::PackedContainer< T >& vec );

   private:
      template< typename ELT, typename CONT >
      void regAuxVar1( const std::string& name,
                       CONT& vec );

      AuxSelection  m_selection;
      mutable auxid_set_t m_auxids;
      std::vector< SG::IAuxTypeVector* > m_vecs;

      SG::IAuxStore* m_store;
      SG::IAuxStoreIO* m_storeIO;
      bool m_ownsStore;
      bool m_locked;

      mutable size_t m_tick;

      typedef AthContainers_detail::mutex mutex_t;
      typedef AthContainers_detail::lock_guard< mutex_t > guard_t;
      mutable mutex_t m_mutex;

      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 ) { }
      }; // struct TSAuxidSet
      mutable AthContainers_detail::thread_specific_ptr< TSAuxidSet > m_tsAuxids;

      std::string m_name;

   }; // class AuxContainerBase

} // namespace xAOD

// Declare a class ID for the class:
#include "xAODCore/CLASS_DEF.h"
CLASS_DEF( xAOD::AuxContainerBase, 1225080690, 1 )

// Describe the inheritance of the class:
#include "xAODCore/BaseInfo.h"
SG_BASES3( xAOD::AuxContainerBase, SG::IAuxStore, SG::IAuxStoreIO,
           SG::IAuxStoreHolder );

// Include the template implementation:
#include "AuxContainerBase.icc"

#endif // XAODCORE_AUXCONTAINERBASE_H

---