ConstDataVector.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-2021 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_CONSTDATAVECTOR_H
#define ATHCONTAINERS_CONSTDATAVECTOR_H
 
#include "AthContainers/DataVector.h"
#include "AthLinks/ElementLink.h"
#include <initializer_list>
 
 
template <class DV>
class ConstDataVector
  : private DV
{
public:
  typedef typename DV::size_type                size_type;
  typedef typename DV::difference_type          difference_type;
  typedef typename DV::allocator_type           allocator_type;
  typedef typename DV::base_value_type          base_value_type;
  typedef typename DV::BaseContainer            BaseContainer;
  typedef typename DV::DVL_BASE                 DVL_BASE;
  typedef typename DV::const_iterator           const_iterator;
  typedef typename DV::const_reverse_iterator   const_reverse_iterator;
 
  // Not necessarily DV; DV may be an intermediate class.
  typedef DataVector<base_value_type>           base_data_vector;
 
  typedef typename DV::const_value_type         value_type;
  typedef typename DV::const_value_type         const_value_type;
  typedef typename DV::const_value_type &       reference;
  typedef typename DV::const_value_type const & const_reference;
  typedef typename DV::const_value_type *       pointer;
  typedef typename DV::const_value_type const * const_pointer;
 
  // cppcheck-suppress duplInheritedMember
  static const bool has_virtual = DV::has_virtual;
 
  typedef std::unique_ptr<const base_value_type> unique_type;
 
  typedef DataModel_detail::ElementProxy<ConstDataVector> ElementProxy;
 
  typedef typename DataModel_detail::iterator<ConstDataVector> iterator;
 
  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;
 
  typedef boost::true_type isSequence;
 
  // cppcheck-suppress duplInheritedMember
  static constexpr bool must_own = DV::must_own;
 
 
  using DV::size;
  using DV::max_size;
  using DV::resize;
  using DV::capacity;
  using DV::empty;
  using DV::reserve;
  using DV::pop_back;
  using DV::sort;
  using DV::ownPolicy;
  using DV::trackIndices;
  using DV::testInsert;
  using DV::getConstStore;
  using DV::setStore;
  using DV::setConstStore;
  using DV::setNonConstStore;
  using DV::cbegin;
  using DV::cend;
  using DV::crbegin;
  using DV::crend;
  using DV::shrink_to_fit;
 
 
  using DV::begin;
  using DV::end;
  using DV::rbegin;
  using DV::rend;
  using DV::front;
  using DV::back;
  using DV::operator[];
  using DV::at;
 
 
  //========================================================================
 
 
  explicit ConstDataVector(SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS);
 
 
  template <typename... ARGS>
  explicit ConstDataVector(SG::OwnershipPolicy ownPolicy, ARGS&&... args);
 
 
  explicit ConstDataVector(size_type n,
                           SG::OwnershipPolicy ownPolicy = SG::OWN_ELEMENTS);
 
 
  template <class InputIterator>
  ConstDataVector(InputIterator first, InputIterator last,
                  SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS);
 
 
  // 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.
  ConstDataVector (const ConstDataVector&) = default;
 
 
  ConstDataVector (ConstDataVector&& rhs);
 
 
  ConstDataVector(std::initializer_list<value_type> l,
                  SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS);
 
 
  template <class CONTAINER>
  ConstDataVector (const std::vector<ElementLink<CONTAINER> >& v);
 
 
  ConstDataVector& operator= (const ConstDataVector& rhs) ;
 
 
  ConstDataVector& operator= (ConstDataVector&& rhs);
 
 
  ConstDataVector& operator= (std::initializer_list<value_type> l);
 
 
  template <class InputIterator>
  void assign(InputIterator first, InputIterator last);
 
 
  void assign(std::initializer_list<value_type> l);
 
 
  template <class CONTAINER>
  void assign (const std::vector<ElementLink<CONTAINER> >& v);
 
 
  //========================================================================
 
 
  ElementProxy operator[] (size_type n);
 
 
  ElementProxy at (size_type n);
 
 
  ElementProxy front ();
 
 
  ElementProxy back ();
 
 
  //========================================================================
 
 
  iterator begin() noexcept;
 
 
  iterator end() noexcept;
 
 
  reverse_iterator rbegin() noexcept;
 
 
  reverse_iterator rend() noexcept;
 
 
  //========================================================================
 
 
  value_type push_back(value_type pElem);
 
 
  value_type emplace_back(value_type pElem);
 
 
  iterator insert(iterator position, value_type pElem);
 
 
  iterator emplace(iterator position, value_type pElem);
 
 
  template <class InputIterator>
  void insert(iterator position, InputIterator first, InputIterator last);
 
 
  value_type push_back(std::unique_ptr<const base_value_type> pElem);
 
 
  iterator insert(iterator position, std::unique_ptr<const base_value_type> pElem);
 
 
  void insert(iterator position, std::initializer_list<value_type> l);
 
 
  //========================================================================
 
 
  iterator erase(iterator position);
 
 
  iterator erase(iterator first, iterator last);
 
 
  // cppcheck-suppress duplInheritedMember
  void clear();
 
 
  //========================================================================
 
 
  void swap(ConstDataVector& rhs);
 
 
  static void iter_swap (iterator a, iterator b);
 
 
  //========================================================================
 
 
 
  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<const base_value_type> newElem,
                   std::unique_ptr<const base_value_type>& oldElem);
 
 
  void swapElement(iterator pos,
                   std::unique_ptr<const base_value_type> newElem,
                   std::unique_ptr<const base_value_type>& oldElem);
 
 
public:
  const DV* asDataVector() const;
 
 
  static
  const ConstDataVector* fromDataVector (const DV* dv);
 
 
  void resortAux (iterator /*beg*/, iterator /*end*/);
 
 
  // cppcheck-suppress duplInheritedMember
  void clear (SG::OwnershipPolicy ownPolicy);
 
 
  // cppcheck-suppress duplInheritedMember
  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);
 
 
  const SG::AuxVectorBase& auxbase() const;
 
 
  //========================================================================
 
 
  bool operator<  (const ConstDataVector& b) const;
 
  bool operator>  (const ConstDataVector& b) const;
 
  bool operator<= (const ConstDataVector& b) const;
 
  bool operator>= (const ConstDataVector& b) const;
 
 
  bool operator== (const ConstDataVector& b) const;
 
  bool operator!= (const ConstDataVector& b) const;
 
 
 
private:
  //========================================================================
 
 
  friend class DataModel_detail::ElementProxy<ConstDataVector>;
  friend void test2_assignelement1<ConstDataVector>();
  friend void test2_assignelement1a<ConstDataVector>();
 
 
  void assignElement (typename BaseContainer::iterator pos, value_type newElem);
 
 
  void assignElement (typename BaseContainer::iterator pos,
                      std::unique_ptr<const base_value_type> newElem);
 
 
  void
  assignBaseElement (typename BaseContainer::iterator pos,
                     typename BaseContainer::value_type newElem);
 
 
  static
  typename DV::iterator to_base_iterator (iterator it);
 
 
  iterator to_my_iterator (typename DV::iterator it);
 
 
  ElementProxy to_element_proxy (typename BaseContainer::iterator i);
 
 
};
 
 
#ifndef XAOD_STANDALONE
 
#include "AthenaKernel/ClassID_traits.h"
 
template <class DV>
struct ClassID_traits<ConstDataVector<DV> >
  : public ClassID_traits<DV>
{
public:
  BOOST_STATIC_CONSTANT(bool, s_isConst = true);
};
 
 
namespace SG {
 
 
template <class DV>
class DVLConstDataVectorBucket
  : public DVLDataBucket<DV>
{
public:
  DVLConstDataVectorBucket (ConstDataVector<DV>* data);
 
 
  DVLConstDataVectorBucket (std::unique_ptr<ConstDataVector<DV> > data);
};
 
 
template <class DV, class U>
struct DataBucketTrait<ConstDataVector<DV>, U>
{
  typedef SG::DVLConstDataVectorBucket<DV> type;
  static void init() { DV::dvlinfo(); }
};
 
 
template <class DV>
class BaseInfo<ConstDataVector<DV> >
  : public BaseInfo<DV>
{
};
 
 
} // namespace SG
 
 
#endif // not XAOD_STANDALONE
 
 
#include "AthContainers/ConstDataVector.icc"
 
 
#endif // not ATHCONTAINERS_CONSTDATAVECTOR_H