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

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: ConstDataVector.h 610620 2014-08-06 21:15:52Z ssnyder $
#ifndef ATHCONTAINERS_CONSTDATAVECTOR_H
#define ATHCONTAINERS_CONSTDATAVECTOR_H

#include "AthContainers/DataVector.h"
#if __cplusplus > 201100
#include <initializer_list>
#endif


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;

  static const bool has_virtual = DV::has_virtual;

  typedef DataModel_detail::ElementProxy<ConstDataVector> ElementProxy;

  typedef typename DataModel_detail::iterator<ConstDataVector> iterator;

  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;

  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;
#if __cplusplus > 201100
  using DV::shrink_to_fit;
#endif


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


  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.
#if __cplusplus > 201100
  // Need this to get the default copy ctor defined when a move
  // ctor is also present.
  ConstDataVector (const ConstDataVector&) = default;
#endif


#if __cplusplus > 201100

  ConstDataVector (ConstDataVector&& rhs);


  ConstDataVector(std::initializer_list<value_type> l,
                  SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS);
#endif


  ConstDataVector& operator= (const ConstDataVector& rhs) ;


#if __cplusplus > 201100

  ConstDataVector& operator= (ConstDataVector&& rhs);


  ConstDataVector& operator= (std::initializer_list<value_type> l);
#endif


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


#if __cplusplus > 201100

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


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


  ElementProxy operator[] (size_type n);


  ElementProxy at (size_type n);


  ElementProxy front ();


  ElementProxy back ();


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


  iterator begin();


  iterator end();


  reverse_iterator rbegin();


  reverse_iterator rend();


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


  void push_back(value_type pElem);


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


#if __cplusplus > 201100
#ifndef __REFLEX__

  void push_back(std::unique_ptr<const base_value_type> pElem);


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


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


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


  iterator erase(iterator position);


  iterator erase(iterator first, iterator last);


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


#if __cplusplus > 201100
#ifndef __REFLEX__

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


public:
  const DV* asDataVector() const;


  void resortAux (iterator /*beg*/, iterator /*end*/);


  void clear (SG::OwnershipPolicy ownPolicy);


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


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


#if __cplusplus > 201100
#ifndef __REFLEX__

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


  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 "SGTools/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);


#if __cplusplus > 201100

  DVLConstDataVectorBucket (std::unique_ptr<ConstDataVector<DV> > data);
#endif
};


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

---