DataVectorWithAlloc.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_DATAVECTORWITHALLOC_H
#define ATHCONTAINERS_DATAVECTORWITHALLOC_H
 
 
#include "AthAllocators/ArenaHeapSTLAllocator.h"
#include "AthAllocators/maybeUnprotect.h"
#include "AthContainers/DataVector.h"
#include "AthContainers/DataVectorWithAllocFwd.h"
 
 
template <class DV, class ALLOC>
class DataVectorWithAlloc
  : 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;
  typedef typename DV::value_type               value_type;
  typedef typename DV::const_value_type         const_value_type;
  typedef typename DV::reference                reference;
  typedef typename DV::const_reference          const_reference;
  typedef typename DV::pointer                  pointer;
  typedef typename DV::const_pointer            const_pointer;
 
  typedef ALLOC elt_allocator_type;
 
  // Not necessarily DV; DV may be an intermediate class.
  typedef DataVector<base_value_type>           base_data_vector;
 
  // cppcheck-suppress duplInheritedMember
  static const bool has_virtual = DV::has_virtual;
 
  typedef DataModel_detail::ElementProxy<DataVectorWithAlloc> ElementProxy;
 
  typedef typename DataModel_detail::iterator<DataVectorWithAlloc> iterator;
 
  typedef typename std::reverse_iterator<iterator>
    reverse_iterator;
 
  typedef boost::true_type isSequence;
 
  static constexpr bool must_own = true;
 
  using DV::size;
  using DV::max_size;
  using DV::resize;
  using DV::capacity;
  using DV::empty;
  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::hasNonConstStore;
  using DV::cbegin;
  using DV::cend;
  using DV::crbegin;
  using DV::crend;
  using DV::do_cast;
 
 
  using DV::begin;
  using DV::end;
  using DV::rbegin;
  using DV::rend;
  using DV::front;
  using DV::back;
  using DV::operator[];
  using DV::at;
 
 
  //========================================================================
 
private:
  class UPDeleter
  {
  public:
    UPDeleter() noexcept;
    UPDeleter (elt_allocator_type& heap) noexcept;
    void operator() (value_type p);
    const elt_allocator_type* heap() const noexcept;
  private:
    elt_allocator_type* m_heap;
  };
 
  
public:
  class Ptr
  {
    using base_ptr = std::unique_ptr<base_value_type, UPDeleter>;
  public:
    using pointer = typename base_ptr::pointer;
    using element_type = typename base_ptr::element_type;
 
    Ptr() = default;
    Ptr(std::nullptr_t) noexcept;
    Ptr(Ptr&&) = default;
    operator bool() const noexcept;
    Ptr& operator= (Ptr&&) noexcept = default;
    Ptr& operator= (std::nullptr_t) noexcept;
    void swap (Ptr& other) noexcept;
    pointer get() const noexcept;
    typename std::add_lvalue_reference<base_value_type>::type operator*() const;
    pointer operator->() const noexcept;
    bool operator== (const Ptr& other) const noexcept;
    bool operator< (const Ptr& other) const noexcept;
    bool operator== (std::nullptr_t) const noexcept;
    bool operator!= (std::nullptr_t) const noexcept;
 
 
 private:
    // Methods to build a Ptr from a bare pointer or to release a Ptr
    // to a bare pointer can only be called by the container itself.
    friend class DataVectorWithAlloc;
    Ptr (pointer p, UPDeleter&& d) noexcept;
    pointer release() noexcept;
    // We're trying to insert this pointer into a container using
    // heap other_heap.  Ensure that that's the same heap we're using;
    // raise an exception if not.
    void checkHeap (const elt_allocator_type* other_heap) const;
 
    base_ptr m_ptr;
  };
 
 
  using unique_type = Ptr;
 
 
  class ContainerUniquePtr
    : public std::unique_ptr<DataVectorWithAlloc>
  {
  public:
    using Base = std::unique_ptr<DataVectorWithAlloc>;
    using Base::Base;
    operator std::unique_ptr<const DV> () && noexcept
    {
      return std::unique_ptr<const DV>(this->release()->asDataVector());
    }
  };
 
 
  static ContainerUniquePtr make_unique()
  {
    return ContainerUniquePtr (new DataVectorWithAlloc);
  }
 
 
  //========================================================================
 
 
  explicit DataVectorWithAlloc (elt_allocator_type&& eltAlloc = elt_allocator_type());
 
 
  explicit DataVectorWithAlloc(size_type n,
                               elt_allocator_type&& eltAlloc = elt_allocator_type());
 
 
  // Don't allow copying.
  DataVectorWithAlloc (const DataVectorWithAlloc&) = delete;
  DataVectorWithAlloc& operator= (const DataVectorWithAlloc& rhs) = delete;
 
 
  DataVectorWithAlloc (DataVectorWithAlloc&& rhs);
 
 
  DataVectorWithAlloc& operator= (DataVectorWithAlloc&& rhs);
 
 
  virtual ~DataVectorWithAlloc();
 
 
  const elt_allocator_type& elt_allocator() const;
 
 
  elt_allocator_type& elt_allocator();
 
 
  //========================================================================
 
 
  void reserve (size_type n);
 
 
  void shrink_to_fit();
 
 
  //========================================================================
 
 
  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 (Ptr pElem);
 
 
  value_type emplace_back (Ptr pElem);
 
 
  iterator insert(iterator position, Ptr pElem);
 
 
  iterator emplace(iterator position, Ptr pElem);
 
 
  //========================================================================
 
 
  iterator erase(iterator position);
 
 
  iterator erase(iterator first, iterator last);
 
 
  // cppcheck-suppress duplInheritedMember
  void clear();
 
 
  //========================================================================
 
 
  void swap (DataVectorWithAlloc& rhs);
 
 
  static void iter_swap (iterator a, iterator b);
 
 
  //========================================================================
 
 
 
  void swapElement (size_type index, Ptr newElem, Ptr& oldElem);
 
 
  void swapElement (iterator pos, Ptr newElem, Ptr& oldElem);
 
 
  const DV* asDataVector() const;
 
 
  static
  const DataVectorWithAlloc* fromDataVector (const DV* dv);
 
 
  void resortAux (iterator beg, iterator end);
 
 
  const SG::AuxVectorBase& auxbase() const;
 
 
  template <class... Args>
  Ptr allocate (Args&&... args);
 
 
  //========================================================================
 
 
  bool operator<  (const DataVectorWithAlloc& b) const;
 
  bool operator>  (const DataVectorWithAlloc& b) const;
 
  bool operator<= (const DataVectorWithAlloc& b) const;
 
  bool operator>= (const DataVectorWithAlloc& b) const;
 
 
  bool operator== (const DataVectorWithAlloc& b) const;
 
  bool operator!= (const DataVectorWithAlloc& b) const;
 
 
 
private:
  //========================================================================
 
 
  friend class DataModel_detail::ElementProxy<DataVectorWithAlloc>;
  friend void test2_assignelement1a<DataVectorWithAlloc>();
 
 
  void assignElement (typename BaseContainer::iterator pos, Ptr 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);
 
 
  class HeapDeleter
    : public DV::Deleter
  {
  public:
    using Base = typename DV::Deleter;
    using value_type = typename Base::value_type;
    using PtrVector = typename Base::PtrVector;
    HeapDeleter (elt_allocator_type&& heap);
    elt_allocator_type& heap() noexcept;
    virtual void doDelete (value_type p) override;
    virtual void doDelete (typename PtrVector::iterator first,
                           typename PtrVector::iterator last) override;
 
 
  private:
    elt_allocator_type m_heap;
  };
 
 
  elt_allocator_type* m_heap;
};
 
 
template <class DV, class ALLOC>
void swap (DataVectorWithAlloc<DV, ALLOC>& a, DataVectorWithAlloc<DV, ALLOC>& b)
{
  a.swap (b);
}
 
 
 
#ifndef XAOD_STANDALONE
 
#include "AthenaKernel/ClassID_traits.h"
 
template <class DV, class ALLOC>
struct ClassID_traits<DataVectorWithAlloc<DV, ALLOC> >
  : public ClassID_traits<DV>
{
public:
  BOOST_STATIC_CONSTANT(bool, s_isConst = true);
};
 
 
namespace SG {
 
 
template <class DV, class ALLOC>
class DVLDataVectorWithAllocBucket
  : public DVLDataBucket<DV>
{
public:
  DVLDataVectorWithAllocBucket (DataVectorWithAlloc<DV, ALLOC>* data);
 
 
  DVLDataVectorWithAllocBucket (std::unique_ptr<DataVectorWithAlloc<DV, ALLOC> > data);
};
 
 
template <class DV, class ALLOC, class U>
struct DataBucketTrait<DataVectorWithAlloc<DV, ALLOC>, U>
{
  typedef SG::DVLDataVectorWithAllocBucket<DV, ALLOC> type;
  static void init() { DV::dvlinfo(); }
};
 
 
template <class DV, class ALLOC>
class BaseInfo<DataVectorWithAlloc<DV, ALLOC> >
  : public BaseInfo<DV>
{
};
 
 
} // namespace SG
 
 
#endif // not XAOD_STANDALONE
 
 
#include "AthContainers/DataVectorWithAlloc.icc"
 
 
#endif // not ATHCONTAINERS_DATAVECTORWITHALLOC_H