/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthContainers/AthContainers/AuxVectorBase.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: AuxVectorBase.h 602407 2014-06-18 14:17:46Z ssnyder $
#ifndef ATHCONTAINERS_AUXVECTORBASE_H
#define ATHCONTAINERS_AUXVECTORBASE_H


#include "AthContainers/AuxVectorData.h"
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/IndexTrackingPolicy.h"
#include "AthContainers/AuxElement.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/ATHCONTAINERS_ASSERT.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/AuxStore_traits.h"
#include <vector>


namespace SG {


class AuxVectorBase
  : public AuxVectorData
{
public:
  AuxVectorBase();


#if __cplusplus > 201100

  AuxVectorBase (AuxVectorBase&& rhs);


  AuxVectorBase& operator= (AuxVectorBase&& rhs);
#endif


  virtual ~AuxVectorBase();


  bool trackIndices() const;


  void setStore (const SG::IConstAuxStore* store);


  void setStore (SG::IAuxStore* store);


  void setStore (const DataLink< SG::IConstAuxStore >& store);


  void setConstStore (const SG::IConstAuxStore* store);


  void setNonConstStore (SG::IAuxStore* store);


protected:
  template <class DVL>
  void initAuxVectorBase (SG::OwnershipPolicy ownPolicy,
                          SG::IndexTrackingPolicy indexTrackingPolicy);


  void swap (AuxVectorBase& other);


  template <class ForwardIterator>
  void setIndices (ForwardIterator beg,
                   ForwardIterator end,
                   size_t first = 0);


  template <class ForwardIterator>
  void clearIndex (ForwardIterator elt);


  template <class ForwardIterator>
  void clearIndices (ForwardIterator beg, ForwardIterator end);


  template <class DVL>
  void resize (size_t size);


  template <class DVL>
  void reserve (size_t size);


  template <class DVL>
  void shift (DVL& cont, size_t pos, ptrdiff_t offs);


  void moveAux (size_t index, SG::AuxElement* p, bool clear = false);


  void moveAux (size_t index, const void* p, bool clear = false);


  template <class ForwardIterator>
  void moveAux (size_t index, ForwardIterator beg, ForwardIterator end);


  void swapElementsAux (size_t aindex,
                        size_t bindex,
                        SG::AuxElement* a,
                        SG::AuxElement* b,
                        AuxVectorBase* bcont);


  void swapElementsAux (size_t aindex,
                        size_t bindex,
                        const void* a,
                        const void* b,
                        AuxVectorBase* bcont);


  template <class ForwardIterator>
  void resortAux (size_t index,
                  ForwardIterator beg,
                  ForwardIterator end);


private:
  void initAuxVectorBase1 (const SG_STD_OR_BOOST::false_type&,
                           SG::OwnershipPolicy /*ownPolicy*/,
                           SG::IndexTrackingPolicy /*indexTrackingPolicy*/);


  void initAuxVectorBase1 (const SG_STD_OR_BOOST::true_type&,
                           SG::OwnershipPolicy ownPolicy,
                           SG::IndexTrackingPolicy indexTrackingPolicy);


  template <class ForwardIterator>
  void setIndices1 (const SG_STD_OR_BOOST::false_type&,
                    ForwardIterator beg,
                    ForwardIterator end,
                    size_t first);


  template <class ForwardIterator>
  void setIndices1 (const SG_STD_OR_BOOST::true_type&,
                    ForwardIterator beg,
                    ForwardIterator end,
                    size_t first);


  template <class ForwardIterator> 
  void clearIndex1 (const SG_STD_OR_BOOST::false_type&, ForwardIterator elt);


  template <class ForwardIterator>
  void clearIndex1 (const SG_STD_OR_BOOST::true_type&, ForwardIterator elt);


  template <class ForwardIterator>
  void clearIndices1 (const SG_STD_OR_BOOST::false_type&,
                      ForwardIterator,
                      ForwardIterator);


  template <class ForwardIterator>
  void clearIndices1 (const SG_STD_OR_BOOST::true_type&,
                      ForwardIterator beg,
                      ForwardIterator end);



  void resize1 (const SG_STD_OR_BOOST::false_type&, size_t size);


  void resize1 (const SG_STD_OR_BOOST::true_type&, size_t size);


  void reserve1 (const SG_STD_OR_BOOST::false_type&, size_t size);


  void reserve1 (const SG_STD_OR_BOOST::true_type&, size_t size);


  template <class DVL>
  void shift1 (const SG_STD_OR_BOOST::false_type&,
               DVL& cont, size_t pos, ptrdiff_t offs);


  template <class DVL>
  void shift1 (const SG_STD_OR_BOOST::true_type&,
               DVL& cont, size_t pos, ptrdiff_t offs);


  template <class ForwardIterator>
  void moveAux1 (const SG_STD_OR_BOOST::false_type&,
                 size_t index,
                 ForwardIterator beg,
                 ForwardIterator end);


  template <class ForwardIterator>
  void moveAux1 (const SG_STD_OR_BOOST::true_type&,
                 size_t index,
                 ForwardIterator beg,
                 ForwardIterator end);


  template <class ForwardIterator>
  void resortAux1 (const SG_STD_OR_BOOST::false_type&,
                   size_t index,
                   ForwardIterator beg,
                   ForwardIterator end);


  template <class ForwardIterator>
  void resortAux1 (const SG_STD_OR_BOOST::true_type&,
                   size_t index,
                   ForwardIterator a,
                   ForwardIterator b);


private:
  class ResortAuxHelper
  {
  public:
    ResortAuxHelper (size_t sz, size_t index, AuxVectorBase& vec);
    void resortElement (size_t idx, SG::AuxElement* elt);

  private:
    AuxVectorBase& m_vec;
    size_t m_index;
    std::vector<size_t> m_imap;
    std::vector<size_t> m_rmap;
    std::vector<void*> m_auxdata;
    std::vector<SG::auxid_t> m_auxids;
    SG::AuxTypeRegistry::lock_t m_lock;

    ResortAuxHelper();
  };
  void* getDataArrayForResort (SG::auxid_t auxid);
  void setIndexForResort (SG::AuxElement* elt, size_t idx);
  friend class ResortAuxHelper;


  bool m_trackIndices;
};


} // namespace SG


#include "AthContainers/AuxVectorBase.icc"


#endif // not DATAMODEL_AUXVECTORBASE_H

---