ArenaPoolSTLAllocator.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-2025 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATLALLOCATORS_ARENAPOOLSTLALLOCATOR
#define ATLALLOCATORS_ARENAPOOLSTLALLOCATOR
 
 
#include "AthAllocators/ArenaPoolAllocator.h"
#include "CxxUtils/checker_macros.h"
#include <string>
#include <type_traits>
#include <concepts>
 
 
namespace SG {
 
 
template <class T>
class ArenaPoolSTLAllocator_initParams
  : public ArenaAllocatorBase::initParams<T, false, true, true>
{
public:
  typedef ArenaAllocatorBase::initParams<T, false, true, true> Base;
 
    ArenaPoolSTLAllocator_initParams (size_t nblock = 1000,
                                      const std::string& name = "");
 
    ArenaAllocatorBase::Params params() const;
 
    // Note: gcc 3.2.3 doesn't allow defining this out-of-line.
    operator ArenaAllocatorBase::Params() const { return params(); }
};
 
 
template <class T, class VETO=T>
class ArenaPoolSTLAllocator
{
public:
  typedef T*        pointer;
  typedef const T*  const_pointer;
  typedef T&        reference;
  typedef const T&  const_reference;
  typedef T         value_type;
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
 
  typedef std::false_type propagate_on_container_copy_assignment;
 
  typedef std::true_type propagate_on_container_move_assignment;
  typedef std::true_type propagate_on_container_swap;
 
 
  template <class U> struct rebind {
    typedef ArenaPoolSTLAllocator<U, VETO> other;
  };
 
 
  ArenaPoolSTLAllocator (size_t nblock = 1000, const std::string& name = "");
 
 
  ArenaPoolSTLAllocator (const ArenaPoolSTLAllocator& a);
 
 
  template <class U, class V>
  ArenaPoolSTLAllocator (const ArenaPoolSTLAllocator<U, V>& a);
 
 
 
  ArenaPoolSTLAllocator (ArenaPoolSTLAllocator&& a);
 
 
  ArenaPoolSTLAllocator& operator= (ArenaPoolSTLAllocator&& a);
 
 
  void swap (ArenaPoolSTLAllocator& a);
 
 
  ArenaPoolSTLAllocator select_on_container_copy_construction() const;
 
 
  bool operator== (const ArenaPoolSTLAllocator& other) const;
 
 
  bool operator!= (const ArenaPoolSTLAllocator& other) const;
 
 
  // We don't bother to supply a more general constructor --- shouldn't
  // be needed.
 
 
  pointer address (reference x) const;
  template <bool = true>
  requires (!std::same_as<reference,const_reference>)
  const_pointer
  address (const_reference x) const { return &x; }
 
 
  pointer allocate (size_type n, const void* hint = 0);
 
 
  void deallocate (pointer, size_type n);
 
 
  size_type max_size() const throw();
 
 
  template <class... Args>
  void construct (pointer p, Args&&... args);
 
 
  void destroy (pointer p);
 
 
  size_t nblock() const;
 
 
  const std::string& name() const;
 
 
  void reset();
 
 
  void erase();
 
 
  void reserve (size_t size);
 
 
  ArenaAllocatorBase::Stats stats() const;
 
 
  const ArenaBlockAllocatorBase* poolptr() const;
 
 
  void protect();
 
 
  void unprotect();
 
 
private:
  ArenaPoolAllocator m_pool;
};
 
 
 
template <class T, class VETO>
class ArenaPoolSTLAllocator<T*, VETO>
  : public std::allocator<T*>
{
public:
  typedef std::allocator<T*> base;
 
  typedef typename base::value_type      value_type;
  typedef typename base::size_type       size_type;
  typedef typename base::difference_type difference_type;
 
 
  template <class U> struct rebind {
    typedef ArenaPoolSTLAllocator<U, VETO> other;
  };
 
 
  ArenaPoolSTLAllocator(size_t nblock = 1000, const std::string& name = "");
 
 
  template <class U, class V>
  ArenaPoolSTLAllocator (const ArenaPoolSTLAllocator<U, V>& a);
 
 
  // We don't bother to supply a more general constructor --- shouldn't
  // be needed.
 
 
  size_t nblock() const;
 
 
  const std::string& name() const;
 
 
private:
  size_t m_nblock = 0;
  std::string m_name;
};
 
 
template <class T>
class ArenaNonConstPoolSTLAllocator;
 
 
template <class T>
class ArenaPoolSTLAllocator<T,
                            typename std::enable_if<!std::is_pointer_v<T>, T>::type>
  : public std::allocator<T>
{
public:
  typedef std::allocator<T> base;
 
  typedef typename base::value_type      value_type;
  typedef typename base::size_type       size_type;
  typedef typename base::difference_type difference_type;
 
 
  template <class U> struct rebind {
    typedef ArenaPoolSTLAllocator<U, T> other;
  };
 
 
  ArenaPoolSTLAllocator (size_t nblock = 1000, const std::string& name = "");
 
 
  template <class U, class V>
  ArenaPoolSTLAllocator (const ArenaPoolSTLAllocator<U, V>& a);
 
 
  // We don't bother to supply a more general constructor --- shouldn't
  // be needed.
 
 
  size_t nblock() const;
 
 
  const std::string& name() const;
 
 
  ArenaAllocatorBase::Stats stats() const;
 
 
  const ArenaBlockAllocatorBase* poolptr() const;
 
 
  template <class CONT>
  static
  ArenaNonConstPoolSTLAllocator<T> get_allocator (CONT& c);
 
 
private:
  size_t m_nblock = 0;
 
  std::string m_name;
 
  const ArenaBlockAllocatorBase* m_poolptr = nullptr;
};
 
 
 
template <class T>
class ArenaNonConstPoolSTLAllocator
  : public ArenaPoolSTLAllocator<T, T>
{
public:
  template <class U, class V>
  ArenaNonConstPoolSTLAllocator (const ArenaPoolSTLAllocator<U, V>& a,
                                 ArenaBlockAllocatorBase* poolptr_nc);
 
 
  void reset();
 
 
  void erase();
 
 
  void reserve (size_t size);
 
 
  void protect();
 
 
  void unprotect();
 
 
private:
  ArenaBlockAllocatorBase* m_poolptr_nc;
};
 
 
template <class T, class VETO>
void maybeUnprotect (ArenaPoolSTLAllocator<T, VETO>& a);
 
 
} // namespace SG
 
 
#include "AthAllocators/ArenaPoolSTLAllocator.icc"
 
 
#endif // ATLALLOCATORS_ARENAPOOLSTLALLOCATOR