AuxVectorBase.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#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/AuxDataTraits.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:
  template <class T> using span = typename AuxDataTraits<T>::span;
  template <class T> using const_span = typename AuxDataTraits<T>::const_span;
 

  AuxVectorBase();
 

  AuxVectorBase (AuxVectorBase&& rhs);
 

  AuxVectorBase& operator= (AuxVectorBase&& rhs);
 

  virtual ~AuxVectorBase();
 

  bool trackIndices() const;
 

  void setStore (SG::IAuxStore* store);
 

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

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

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

  void setNonConstStore (SG::IAuxStore* store);
 
 
  // Templated versions of isAvailable, etc.
  // We put them here rather than in AuxVectorData so that AuxVectorData.h
  // doesn't need to include AuxTypeRegistry.h.  Otherwise we get a
  // a cyclic header dependency:
  //  AuxTypeRegistry -> AuxTypeVectorFactory -> AuxVectorData -> AuxTypeRegistry
 
  using AuxVectorData::isAvailable;
  using AuxVectorData::isAvailableWritable;
  using AuxVectorData::isAvailableWritableAsDecoration;
 

  template <class T>
  bool isAvailable (const std::string& name,
                    const std::string& clsname = "") const;
 

  template <class T>
  bool isAvailableWritable (const std::string& name,
                            const std::string& clsname = "");
 

  template <class T>
  bool isAvailableWritableAsDecoration (const std::string& name,
                                        const std::string& clsname = "") const;
 

  template <class T>
  span<T> getDataSpan (const std::string& name);
 

  template <class T>
  const_span<T> getDataSpan (const std::string& name) const;
 

  template <class T>
  const_span<T> getConstDataSpan (const std::string& name) const;
 

  template <class T>
  span<T> getDecorationSpan (const std::string& name) const;
 

  static constexpr bool supportsThinning = true;
 
 
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,
                bool skipDestClear = false);
 

  void moveAuxNoClear (size_t index, SG::AuxElement* p);
 

  void moveAuxNoClear (size_t /*index*/, const void* /*p*/);
 

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

  template <class ForwardIterator>
  void moveAux (size_t index, ForwardIterator beg, ForwardIterator end,
                bool clear = false,
                bool skipDestClear = false);
 

  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 std::false_type&,
                           SG::OwnershipPolicy /*ownPolicy*/,
                           SG::IndexTrackingPolicy /*indexTrackingPolicy*/);
 

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

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

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

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

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

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

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

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

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

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

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

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

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

  template <class ForwardIterator>
  void moveAux1 (const std::false_type&,
                 size_t index,
                 ForwardIterator beg,
                 ForwardIterator end,
                 bool clear = false,
                 bool skipDestClear = false);
 

  template <class ForwardIterator>
  void moveAux1 (const std::true_type&,
                 size_t index,
                 ForwardIterator beg,
                 ForwardIterator end,
                 bool clear = false,
                 bool skipDestClear = false);
 

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

  template <class ForwardIterator>
  void resortAux1 (const std::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;
 
    ResortAuxHelper();
  };
  void* getDataArrayForResort (SG::auxid_t auxid);
  void setIndexForResort (SG::AuxElement* elt, size_t idx);
  friend class ResortAuxHelper;
 

  bool m_trackIndices;
};
 
 
} // namespace SG
 
 
#ifndef XAOD_STANDALONE
#include "AthenaKernel/CLASS_DEF.h"
CLASS_DEF( SG::AuxVectorBase, 33347479, 1 )
#endif
 
 
#include "AthContainers/AuxVectorBase.icc"
 
 
#endif // not DATAMODEL_AUXVECTORBASE_H