DataVector.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_DATAVECTOR_H
#define ATHCONTAINERS_DATAVECTOR_H
 
 
// For feature tests.
#define HAVE_CONSTDATAVECTOR
 
 
#include "AthContainers/exceptions.h"
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/IndexTrackingPolicy.h"
#include "AthContainers/AuxVectorBase.h"
#include "AthContainers/tools/DVLNoBase.h"
#include "AthContainers/tools/DVLInfo.h"
#include "AthContainers/tools/DVLCast.h"
#include "AthContainers/tools/DVLIterator.h"
#include "AthContainers/tools/DVL_iter_swap.h"
#include "AthContainers/tools/DVL_algorithms.h"
#include "AthContainers/tools/ElementProxy.h"
#include "AthContainers/tools/IsMostDerivedFlag.h"
#include "AthContainers/DataVectorWithAllocFwd.h"
#include "CxxUtils/concepts.h"
#include <type_traits>
#include <vector>
#include <typeinfo>
#include <functional>
#include <iostream>
#include <algorithm>
#include <stdexcept>
#include <iterator>
#include <initializer_list>
#include <RootMetaSelection.h>
 
 
 
#ifdef XAOD_STANDALONE
# ifndef SG_BASE
#  define SG_BASE(A, B) class ATHCONTAINERS_DUMMY
# endif // not SG_BASE
# ifndef SG_BASES1
#  define SG_BASES1(A, B) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES1
# ifndef SG_BASES2
#  define SG_BASES2(A, B, C) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES2
# ifndef SG_BASES3
#  define SG_BASES3(A, B, C, D) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES3
# ifndef SG_BASES4
#  define SG_BASES4(A, B, C, D, E) class ATHCONTAINERS_DUMMY
# endif // not SG_BASES4
# ifndef SG_VIRTUAL
#  define SG_VIRTUAL(X) X
# endif // not SG_VIRTUAL
namespace SG {
template <class T> struct bi_destroy {};
}
#else
# include "AthenaKernel/BaseInfo.h"
#endif
 
 
// Forward declarations.
namespace ROOT { namespace Meta { namespace Selection {
  template <class T, class BASE> class DataVector;
}}}
 
 
namespace DataVector_detail {
 
 
// These are the intermediate classes from which @c DataVector derives
// in the case of multiple or virtual derivation.  The actual
// definitions are in the @c icc file.  They have the following
// properties:
//   - They derive from those of @c B1, @c B2, and @c B3 that are not
//     @c NoBase.
//   - They perform (static) checking to ensure that there's a unique
//     base class in the hierarchy.
//   - They make the following types available from the base classes:
//     - @c PtrVector
//     - @c BaseContainer
//     - @c size_type
//     - @c difference_type
//     - @c allocator_type
//   - @c has_virtual is defined as @c true.
//   - An override of @c dvlinfo_v is defined, to prevent ambiguities.
template <class B1,
          class B2=DataModel_detail::NoBase,
          class B3=DataModel_detail::NoBase> struct VirtBases;
 

template <class ITERATOR, class T>
using enable_if_ptr_itr =
  std::enable_if_t<std::is_convertible_v<typename std::iterator_traits<ITERATOR>::value_type, T*>, bool>;
 
template <class ITERATOR, class T>
using enable_if_up_itr =
  std::enable_if_t<std::is_convertible_v<typename std::iterator_traits<ITERATOR>::value_type, std::unique_ptr<T> >, bool>;
 
 
} // namespace DataVector_detail
 
 

template <class T>
struct DataVectorBase
{
  typedef DataModel_detail::NoBase Base;
};
 

#define DATAVECTOR_BASE(T, BASE)          \
DATAVECTOR_BASE_FWD(T, BASE);             \
DATAVECTOR_BASE_FIN(T, BASE);
 

#define DATAVECTOR_BASE_FWD(T, BASE)      \
template <> struct DataVectorBase<T>      \
{ typedef DataVector<BASE> Base; };       \
namespace SG { template<> struct bi_destroy<DataVector<T> > { static void destroy(void*); }; } \
SG_BASE(DataVector<T>, DataVector<BASE>)
 

#define DATAVECTOR_VIRTBASES1(T, B1)                  \
DATAVECTOR_VIRTBASES1_FWD(T, B1);                     \
DATAVECTOR_BASE_FIN(T, B1);
 
 

#define DATAVECTOR_VIRTBASES1_FWD(T, B1)              \
template <> struct DataVectorBase<T>                  \
{ typedef DataVector_detail::VirtBases<B1> Base; };   \
namespace SG { template<> struct bi_destroy<DataVector<T> > { static void destroy(void*); }; } \
SG_BASES1(DataVector<T>, SG_VIRTUAL(DataVector<B1>))
 
 

#define DATAVECTOR_VIRTBASES2(T, B1, B2)                \
DATAVECTOR_VIRTBASES2_FWD(T, B1, B2);                   \
DATAVECTOR_BASE_FIN(T, B1);
 

#define DATAVECTOR_VIRTBASES2_FWD(T, B1, B2)            \
template <> struct DataVectorBase<T>                    \
{ typedef DataVector_detail::VirtBases<B1, B2> Base; }; \
namespace SG { template<> struct bi_destroy<DataVector<T> > { static void destroy(void*); }; } \
SG_BASES2(DataVector<T>, SG_VIRTUAL(DataVector<B1>),    \
                         SG_VIRTUAL(DataVector<B2>))
 

#define DATAVECTOR_VIRTBASES3(T, B1, B2, B3)            \
DATAVECTOR_VIRTBASES3_FWD(T, B1, B2, B3);               \
DATAVECTOR_BASE_FIN(T, B1);
 

#define DATAVECTOR_VIRTBASES3_FWD(T, B1, B2, B3)            \
template <> struct DataVectorBase<T>                        \
{ typedef DataVector_detail::VirtBases<B1, B2, B3> Base; }; \
namespace SG { template<> struct bi_destroy<DataVector<T> > { static void destroy(void*); }; } \
SG_BASES3(DataVector<T>, SG_VIRTUAL(DataVector<B1>),        \
                         SG_VIRTUAL(DataVector<B2>),        \
                         SG_VIRTUAL(DataVector<B3>))
 

#define DATAVECTOR_VIRTBASES4(T, B1, B2, B3, B4)            \
DATAVECTOR_VIRTBASES4_FWD(T, B1, B2, B3, B4);               \
DATAVECTOR_BASE_FIN(T, B1);
 

#define DATAVECTOR_VIRTBASES4_FWD(T, B1, B2, B3, B4)            \
template <> struct DataVectorBase<T>                            \
{ typedef DataVector_detail::VirtBases<B1, B2, B3, B4> Base; }; \
namespace SG { template<> struct bi_destroy<DataVector<T> > { static void destroy(void*); }; } \
SG_BASES4(DataVector<T>, SG_VIRTUAL(DataVector<B1>),            \
                         SG_VIRTUAL(DataVector<B2>),            \
                         SG_VIRTUAL(DataVector<B3>),            \
                         SG_VIRTUAL(DataVector<B4>))
 

#define DATAVECTOR_BASE_FIN(T, B) \
  namespace SG { inline void bi_destroy<DataVector<T> >::destroy(void* p) { delete (DataVector<T>*)p; } } \
template struct DataVector_detail::DVLEltBaseInit<T>
 
 
template <class DV> class ConstDataVector;
template <class DV> void test2_assignelement1();
template <class DV> void test2_assignelement1a();
template <class DV> void test2_assignelement2();
 

template <class T, class BASE = typename DataVectorBase<T>::Base>
class DataVector : public BASE
{
public:
  typedef BASE DataVector_BASE;
  typedef BASE DVL_BASE;

  static const bool has_virtual = BASE::has_virtual;

  typedef typename BASE::PtrVector PtrVector;
  typedef typename BASE::PtrVector BaseContainer;
 
 
public:
  // Standard types required for the container interface.
  typedef T*& reference;
  typedef T* const & const_reference;
  typedef typename BASE::size_type size_type;
  typedef typename BASE::difference_type difference_type;
  typedef T* value_type;
  typedef typename BASE::allocator_type allocator_type;
  typedef T** pointer;
  typedef T* const * const_pointer;
 
  typedef const T* const_value_type;

  typedef T base_value_type;

  typedef std::unique_ptr<base_value_type> unique_type;

  typedef DataModel_detail::ElementProxy<DataVector> ElementProxy;
 

  typedef typename DataModel_detail::const_iterator<DataVector>
    const_iterator;

  typedef typename DataModel_detail::iterator<DataVector> iterator;
 

  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;
 
  typedef DataVector base_data_vector;
 
 
  using Deleter = typename BASE::Deleter;

  static constexpr bool must_own = BASE::must_own;
 
 
  //========================================================================
 

  explicit DataVector(SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);
 

  explicit DataVector(size_type n, /* value_type pElem = 0,*/
              SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);
 

  // The copy constructor for derived classes is deliberately omitted,
  // as otherwise we get warnings about not calling the copy constructors
  // for base classes, which are problematic when we have virtual
  // inheritance.  Most of what needs doing is done in the base class anyway,
  // except for setting @c m_isMostDerived.  We arrange for these flags
  // to all get set to false; they'll get set correctly when
  // @c testInsert is called.
  // Need this to get the default copy ctor defined when a move
  // ctor is also present.
  DataVector (const DataVector&) = default;
 

  DataVector (DataVector&& rhs) noexcept;
 

  template <class InputIterator>
  DataVector(InputIterator first,
             InputIterator last,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
 

  DataVector(std::initializer_list<value_type> l,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
 

  DataVector& operator= (const DataVector& rhs);
 

  DataVector& operator= (DataVector&& rhs);
 

  DataVector& operator= (std::initializer_list<value_type> l);
 

  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);
 

  void assign(std::initializer_list<value_type> l);
 
 
  // Destructor is inherited.
 

  //========================================================================
 

  size_type size() const noexcept;
 

  // This is inherited from the base class.
 

  void resize(size_type sz);
  

  // This is inherited from the base class.
 

  // This is inherited from the base class.
 

  void reserve (size_type n);
 

  // This is inherited from the base class.
 

  //========================================================================
 

  const T* operator[] (size_type n) const;
 

  const T* get (size_type n) const;
 

  ElementProxy operator[] (size_type n);
 

  const T* at (size_type n) const;
 

  ElementProxy at (size_type n);
 

  const T* front() const;
 

  const T* back() const;
 

  ElementProxy front ();
 

  ElementProxy back ();
 

  //========================================================================
 

  const_iterator begin() const noexcept;
 

  const_iterator end() const noexcept;
 

  iterator begin() noexcept;
 

  iterator end() noexcept;
 

  const_reverse_iterator rbegin() const noexcept;
 

  const_reverse_iterator rend() const noexcept;
 

  reverse_iterator rbegin() noexcept;
 

  reverse_iterator rend() noexcept;
 

  const_iterator cbegin() const noexcept;
 

  const_iterator cend() const noexcept;
 

  const_reverse_iterator crbegin() const noexcept;
 

  const_reverse_iterator crend() const noexcept;
 

  //========================================================================
 

  value_type push_back(value_type pElem);
 

  value_type push_back(std::unique_ptr<base_value_type> pElem);
 

  template <CxxUtils::detail::AllocationFunction<T> F>
  size_type push_new (size_type n, F alloc);
 

  value_type emplace_back(value_type pElem);
 

  iterator insert(iterator position, value_type pElem);
 

  iterator insert(iterator position, std::unique_ptr<base_value_type> pElem);
 

  iterator emplace(iterator position, value_type pElem);
 

  template <class InputIterator,
            DataVector_detail::enable_if_ptr_itr<InputIterator, T> = true>
  void insert(iterator position, InputIterator first, InputIterator last);
 

  template <class InputIterator,
            DataVector_detail::enable_if_up_itr<InputIterator, T> = true>
  void insert(iterator position, InputIterator first, InputIterator last);
 

  void insert(iterator position, std::initializer_list<value_type> l);
 

  void insertMove (iterator position, DataVector& other);
 

  //========================================================================
 

  iterator erase(iterator position);
 

  iterator erase(iterator first, iterator last);
 

  void pop_back();
 

  void clear();
 

  //========================================================================
 

  void swap(DataVector& rhs);
 

  static void iter_swap (iterator a, iterator b);
 

  void sort();
 

  template <class COMPARE>
  void sort(COMPARE comp);
 
 

  //========================================================================
  

  void swapElement(size_type index, value_type newElem, reference oldElem);
 

  void swapElement(iterator pos, value_type newElem, reference oldElem);
 

  void swapElement(size_type index,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
 

  void swapElement(iterator pos,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
 
 
public:
  // This is inherited from the base class.
 

  // This is inherited from the base class.
 

  void clear (SG::OwnershipPolicy ownPolicy);
 

  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);
 

  void clear (std::unique_ptr<Deleter> deleter);
 

  static const DataModel_detail::DVLInfoBase& dvlinfo();
 

  virtual const DataModel_detail::DVLInfoBase& dvlinfo_v() const override;
 

  static
  int baseOffset (const std::type_info& ti);
 

  const SG::AuxVectorBase& auxbase() const;
 

  //========================================================================
 
 
  // Doxygen trick.  We want DataVector<T> to show the complete interface,
  // including inherited methods.  Normally, doxygen would do this.
  // But it's not smart enough to figure out our inheritance relationships.
  // We can add a function with `fn', but doxygen won't actually
  // generate the documentation unless it also sees the declaration.
  // So here are declarations which should be visible to doxygen
  // but not to C++.
#ifndef __cplusplus
  size_type max_size() const noexcept;
  void resize(size_type sz);
  size_type capacity() const noexcept;
  [[nodiscard]] bool empty() const noexcept;
  void shrink_to_fit();
  void pop_back();
  void clear();
  const PtrVector& stdcont() const;
  SG::OwnershipPolicy ownPolicy() const;
  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);
#endif // not __cplusplus
 

 

  static
  int baseOffset1 (const char* p, const DataVector& dv,
                   const std::type_info& ti);
 

  void resortAux (iterator beg, iterator end);
 

  void testInsert (const char* op);
 

  void testInsertOol (const char* op);
 
 
private:
  friend class DataModel_detail::ElementProxy<DataVector>;
  template <class DV>
  friend class ConstDataVector;
  template <class DV, class ALLOC>
  friend class DataVectorWithAlloc;
  friend void test2_assignelement1a<DataVector>();
  friend void test2_assignelement1<DataVector>();
  friend void test2_assignelement2<DataVector>();
 

  void assignElement (typename BaseContainer::iterator pos, value_type newElem);
 

  void assignElement (typename BaseContainer::iterator pos,
                      std::unique_ptr<base_value_type> newElem);
 

  void assignBaseElement (typename BaseContainer::iterator pos,
                          typename BaseContainer::value_type newElem);
 

  void shift (size_t pos, ptrdiff_t offs);
 
 
public:
  // Make this public so we can call it from DVCollectionProxy.
  static
  const T* do_cast (const typename PtrVector::value_type p);
 

  static
  T* do_cast_nc (typename PtrVector::value_type p);
 
 
private:
  virtual const std::type_info& dv_typeid() const override;
 
 
protected:
  void clearMostDerived();
 

  virtual void setMostDerived() override;
 
 
private:
 

  SG::IsMostDerivedFlag m_isMostDerived;
 
 
  typedef typename
    ROOT::Meta::Selection::DataVector<T, DataVector_BASE>::self self;
};
 
 
template <class T, class BASE>
const bool DataVector<T, BASE>::has_virtual;

template <class T>
class DataVector<T, DataModel_detail::NoBase>
  : public SG::AuxVectorBase
{
public:
  typedef DataModel_detail::NoBase DataVector_BASE;
  typedef DataModel_detail::NoBase DVL_BASE;

  typedef std::true_type isSequence;

  typedef std::vector<T*> PtrVector;
  typedef std::vector<T*> BaseContainer;

  static const bool has_virtual = false;
 
  // Standard types required for the container interface.
  typedef T*& reference;
  typedef T* const & const_reference;
  typedef typename PtrVector::size_type size_type;
  typedef typename PtrVector::difference_type difference_type;
  typedef T* value_type;
  typedef typename PtrVector::allocator_type allocator_type;
  typedef T** pointer;
  typedef T* const * const_pointer;
 
  typedef const T* const_value_type;

  typedef T base_value_type;

  typedef std::unique_ptr<base_value_type> unique_type;

  typedef DataModel_detail::ElementProxy<DataVector> ElementProxy;
 

 typedef typename DataModel_detail::const_iterator<DataVector>
    const_iterator;

  typedef typename DataModel_detail::iterator<DataVector> iterator;

  // Note: we can't just use the underlying PtrVector::const_reverse_iterator
  // here; otherwise, const_reverse_iterator won't be convertable to
  // reverse_iterator.
  typedef typename std::reverse_iterator<const_iterator>
    const_reverse_iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;
 
  typedef DataVector base_data_vector;
 

  class Deleter
  {
  public:
    using value_type = DataVector::value_type;
    using PtrVector = DataVector::PtrVector;
    virtual ~Deleter() = default;
    virtual void doDelete (value_type p) = 0;
    virtual void doDelete (typename PtrVector::iterator first,
                           typename PtrVector::iterator last) = 0;
  };
 

  static constexpr bool must_own = false;
 
 
  //========================================================================
 

  explicit DataVector(SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
                      SG::IndexTrackingPolicy trackIndices =
                        SG::DEFAULT_TRACK_INDICES);
 

  explicit DataVector
    (size_type n, /* value_type pElem = 0,*/
     SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS,
     SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES);
 

  DataVector(const DataVector& rhs);
 

  DataVector (DataVector&& rhs) noexcept;
 

  template <class InputIterator>
  DataVector(InputIterator first, InputIterator last,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
 

  DataVector(std::initializer_list<value_type> l,
         SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS,
             SG::IndexTrackingPolicy trackIndices = SG::DEFAULT_TRACK_INDICES,
             SG::IAuxStore* store = 0);
 

  DataVector& operator= (const DataVector& rhs);
 

  DataVector& operator= (DataVector&& rhs);
 

  DataVector& operator= (std::initializer_list<value_type> l);
 

  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);
 

  void assign(std::initializer_list<value_type> l);
 

  virtual ~DataVector();
 

  //========================================================================
 

  size_type size() const noexcept;
 

  virtual size_type size_v() const override;
 

  size_type max_size() const noexcept;
 

  void resize(size_type sz);
 

  size_type capacity() const noexcept;
 

  virtual size_type capacity_v() const override;
 

  [[nodiscard]] bool empty() const noexcept;
 

  void reserve (size_type n);
 

  void shrink_to_fit();
 

  //========================================================================
 

  const T* operator[] (size_type n) const;
 

  const T* get (size_type n) const;
 

  ElementProxy operator[] (size_type n);
 

  const T* at (size_type n) const;
 

  ElementProxy at (size_type n);
 

  const T* front() const;
 

  const T* back() const;
 

  ElementProxy front ();
 

  ElementProxy back ();
 

  //========================================================================
 

  const_iterator begin() const noexcept;
 

  const_iterator end() const noexcept;
 

  iterator begin() noexcept;
 

  iterator end() noexcept;
 

  const_reverse_iterator rbegin() const noexcept;
 

  const_reverse_iterator rend() const noexcept;
 

  reverse_iterator rbegin() noexcept;
 

  reverse_iterator rend() noexcept;

  const_iterator cbegin() const noexcept;
 

  const_iterator cend() const noexcept;
 

  const_reverse_iterator crbegin() const noexcept;
 

  const_reverse_iterator crend() const noexcept;
 

  //========================================================================
 

  value_type push_back(value_type pElem);
 

  value_type push_back(std::unique_ptr<base_value_type> pElem);
 

  template <CxxUtils::detail::AllocationFunction<T> F>
  size_type push_new (size_type n, F alloc);
 

  value_type emplace_back(value_type pElem);
 

  iterator insert(iterator position, value_type pElem);
 

  iterator insert(iterator position, std::unique_ptr<base_value_type> pElem);
 

  iterator emplace(iterator position, value_type pElem);
 

  template <class InputIterator,
            DataVector_detail::enable_if_ptr_itr<InputIterator, T> = true>
  void insert(iterator position, InputIterator first, InputIterator last);
 

  template <class InputIterator,
            DataVector_detail::enable_if_up_itr<InputIterator, T> = true>
  void insert(iterator position, InputIterator first, InputIterator last);
 

  void insert(iterator position, std::initializer_list<value_type> l);
 

  void insertMove (iterator position, DataVector& other);
 

  //========================================================================
 

  iterator erase(iterator position);
 

  iterator erase(iterator first, iterator last);
 

  void pop_back();
 

  void clear();
 

  //========================================================================
 

  void swap(DataVector& rhs);
 

  static void iter_swap (iterator a, iterator b);
 

  void sort();
 

  template <class COMPARE>
  void sort(COMPARE comp);
 

  //========================================================================
 

  void swapElement(size_type index, value_type newElem, reference oldElem);
 

  void swapElement(iterator pos, value_type newElem, reference oldElem);
 

  void swapElement(size_type index,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
 

  void swapElement(iterator pos,
                   std::unique_ptr<base_value_type> newElem,
                   std::unique_ptr<base_value_type>& oldElem);
 
 
public:
  const PtrVector& stdcont() const;
 

  SG::OwnershipPolicy ownPolicy() const;
 

  void clear (SG::OwnershipPolicy ownPolicy);
 

  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);
 

  void clear (std::unique_ptr<Deleter> deleter);
 

  static const DataModel_detail::DVLInfoBase& dvlinfo();
 

  virtual const DataModel_detail::DVLInfoBase& dvlinfo_v() const;
 

  static
  int baseOffset (const std::type_info& ti);
 

  const SG::AuxVectorBase& auxbase() const;
 

  //========================================================================
 

  static
  int baseOffset1 (const char* p, const DataVector& dv,
                   const std::type_info& ti);
 

  void resortAux (iterator beg, iterator end);
 

  void testInsert (const char* op);
 

  void testInsertOol (const char* op);
 
 
private:
  friend class DataModel_detail::ElementProxy<DataVector>;
  template <class DV>
  friend class ConstDataVector;
  template <class DV, class ALLOC>
  friend class DataVectorWithAlloc;
  friend void test2_assignelement1a<DataVector>();
  friend void test2_assignelement1<DataVector>();
  friend void test2_assignelement2<DataVector>();
 

  void assignElement (typename BaseContainer::iterator pos, value_type newElem);
 

  void assignElement (typename BaseContainer::iterator pos,
                      std::unique_ptr<base_value_type> newElem);
 

  void assignBaseElement (typename BaseContainer::iterator pos,
                          typename BaseContainer::value_type newElem);
 

  void shift (size_t pos, ptrdiff_t offs);
 
 
public:
  // Make this public so we can call it from DVCollectionProxy.
  static
  const T* do_cast (const typename PtrVector::value_type p);
 

  static
  T* do_cast_nc (typename PtrVector::value_type p);
 
 
private:
  virtual const std::type_info& dv_typeid() const;
 
 
protected:
  typename PtrVector::iterator
  erase_base(typename PtrVector::iterator position);
 

  typename PtrVector::iterator
  erase_base(typename PtrVector::iterator first,
             typename PtrVector::iterator last);
 

  void doDelete (value_type p);
 

  void doDelete (typename PtrVector::iterator first,
                 typename PtrVector::iterator last);
 
 
protected:
  SG::OwnershipPolicy m_ownPolicy;

  PtrVector m_pCont;

  // This should really be a unique_ptr --- but that causes problems
  // with ROOT persistency (even though this is tagged as transient).
  Deleter* m_deleter = nullptr;
 

  void clearMostDerived();
 

  virtual void setMostDerived();
 
 
private:
 

  SG::IsMostDerivedFlag m_isMostDerived;
 
 
  typedef typename
    ROOT::Meta::Selection::DataVector<T, DataVector_BASE>::self self;
};
 
template <class T>
const bool DataVector<T, DataModel_detail::NoBase>::has_virtual;
 

template <class T>
bool operator== (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
bool operator!= (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
bool operator< (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
bool operator> (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
bool operator<= (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
bool operator>= (const DataVector<T>& a, const DataVector<T>& b);
 

template <class T>
void swap (DataVector<T>& a, DataVector<T>& b);
 
 
namespace ROOT { namespace Meta { namespace Selection {
 
template< class T, class BASE >
class DataVector : KeepFirstTemplateArguments< 1 >, SelectNoInstance
{
 
public:
   typedef DataVector< T, BASE > self;
#ifndef XAOD_STANDALONE
    //MN: this causes massive dictionary duplication.  Disabling for now.
   // ROOT::Meta::Selection::MemberAttributes< kAutoSelected > m_pCont;
#endif  
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_isMostDerived;
   ROOT::Meta::Selection::MemberAttributes< kTransient > m_deleter;

   ROOT::Meta::Selection::MemberAttributes< kTransient > m_ownPolicy;
 
};
 
}}} // namespace
 
 
#include "AthContainers/ClassName.h"
 

template <class T>
class ClassName<DataVector<T> >
{
public:
  static std::string name();
};
 
 
#ifndef XAOD_STANDALONE
 
 
#include "AthContainers/tools/DVLDataBucket.h"
#include "AthenaKernel/DataBucketTraitFwd.h"
#include "AthenaKernel/TopBase.h"
 
 
namespace SG {
 

template <class T, class U>
struct DataBucketTrait<DataVector<T>, U>
{
  typedef SG::DVLDataBucket<U> type;
  static void init() { DataVector<T>::dvlinfo(); }
};
 

template <class T>
struct Bases<DataVector<T, DataModel_detail::NoBase> > {
  using bases = BaseList<SG::AuxVectorBase>;
};                               
template <class T>
struct TopBase<DataVector<T, DataModel_detail::NoBase> > {
  typedef DataVector<T, DataModel_detail::NoBase> type;
};                               
 
 
} // namespace SG
 
 
#endif
 
 
#include "AthContainers/DataVector.icc"
#endif // not ATHCONTAINERS_DATAVECTOR_H