/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODTrigger/xAODTrigger/versions/ByteStreamAuxContainer_v1.h

// Dear emacs, this is -*- c++ -*-
// $Id: ByteStreamAuxContainer_v1.h 645967 2015-02-11 12:29:36Z krasznaa $
#ifndef XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H
#define XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H

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

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

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

namespace xAOD {

   class ByteStreamAuxContainer_v1
     : public SG::IAuxStore
#ifndef XAOD_STANDALONE
     , public ILockable
#endif
   {

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

      ByteStreamAuxContainer_v1();
      ByteStreamAuxContainer_v1( const ByteStreamAuxContainer_v1& parent );
      ~ByteStreamAuxContainer_v1();

      ByteStreamAuxContainer_v1&
      operator=( const ByteStreamAuxContainer_v1& rhs );


      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 );


      void reset();


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


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

   private:
      template< typename T >
      void* getData1( auxid_t auxid,
                      std::map< std::string, std::vector< T > >& pers,
                      size_t size, size_t capacity, bool quiet,
                      bool forDecor) const;

      void* getData1( auxid_t auxid,
                      size_t size, size_t capacity, bool quiet,
                      bool forDecor ) const;


      mutable std::map< std::string, std::vector< int > > m_int;
      mutable std::map< std::string, std::vector< float > > m_float;
      mutable std::map< std::string, std::vector< std::vector< int > > > m_vecInt;
      mutable std::map< std::string, std::vector< std::vector< float > > > m_vecFloat;



      mutable auxid_set_t m_auxids;
      std::vector< SG::IAuxTypeVector* > m_staticVecs;
      mutable std::vector< SG::IAuxTypeVector* > m_dynamicVecs;
      bool m_locked;
      std::vector<bool> 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_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) {}
      };
      mutable AthContainers_detail::thread_specific_ptr<TSAuxidSet> m_tsAuxids;


      std::string m_name;

   }; // class ByteStreamAuxContainer_v1

} // namespace xAOD

// Declare the inheritace of the container:
#include "xAODCore/BaseInfo.h"
SG_BASE( xAOD::ByteStreamAuxContainer_v1, SG::IAuxStore );


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

#endif // XAODTRIGGER_VERSIONS_BYTESTREAMAUXCONTAINER_V1_H

---