DataPool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHALLOCATORS_DATAPOOL_H
#define ATHALLOCATORS_DATAPOOL_H
 
#include "AthAllocators/ArenaCachingHandle.h"
#include "AthAllocators/ArenaPoolAllocator.h"
#include <string>
#include "boost/iterator/iterator_adaptor.hpp"
 
 
namespace SG {
 
 
template <class VALUE>
class DataPoolNullClear
{
public:
  static void clear (VALUE*) {}
};
 
 
} // namespace SG
 
 
template <typename VALUE, typename CLEAR = SG::DataPoolNullClear<VALUE> >
class DataPool
{
private:
  typedef SG::ArenaPoolAllocator alloc_t;
  typedef SG::ArenaCachingHandle<VALUE, alloc_t> handle_t;
 
public:
  typedef typename handle_t::pointer pointer;
  typedef size_t size_type;
 
  class const_iterator;
 
  class iterator
    : public boost::iterator_adaptor<
    iterator,
    typename handle_t::iterator,
    VALUE *,
    boost::forward_traversal_tag,
    VALUE *>
  {
  public:
    iterator (const typename handle_t::iterator& it)
      : iterator::iterator_adaptor_ (it)
    {
    }
 
    friend class const_iterator;
 
  private:
    friend class boost::iterator_core_access;
 
    typename iterator::reference dereference() const
    { return &*this->base_reference(); }
  };
 
  class const_iterator
    : public boost::iterator_adaptor<
    const_iterator,
    typename handle_t::const_iterator,
    VALUE const *,
    boost::forward_traversal_tag,
    VALUE const *>
  {
  public:
    const_iterator (const typename handle_t::const_iterator& it)
      : const_iterator::iterator_adaptor_ (it)
    {
    }
 
    const_iterator (const iterator& it)
      : const_iterator::iterator_adaptor_ (it.base_reference())
    {
    }
 
  private:
    friend class boost::iterator_core_access;
 
    typename const_iterator::reference dereference() const
    { return &*this->base_reference(); }
  };
 
 
 
  DataPool(size_type n = 0);
 
  DataPool(const EventContext& ctx,
           size_type n = 0);
 
  DataPool(SG::Arena* arena,
           size_type n = 0);
 
 
  void reset();
 
  void erase();
 
  void reserve(unsigned int size);
 
  void prepareToAdd(unsigned int size);
 
  unsigned int capacity();
 
  unsigned int allocated();
 
  iterator begin();
  const_iterator begin() const;
 
  iterator end();
  const_iterator end() const;
 
  pointer nextElementPtr();
 
  static const std::string& typeName();
 
//-----------------------------------------------------------//
 
 private:
 
  handle_t m_handle;
 
  const static typename alloc_t::Params s_params;
 
  static constexpr size_t s_minRefCount = 1024;
 
  static typename alloc_t::Params initParams();
  static void callClear (SG::ArenaAllocatorBase::pointer p);
};
 
 
#include "AthAllocators/DataPool.icc"
 
#endif