ArenaHeapSTLAllocator.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_ARENAHEAPSTLALLOCATOR
#define ATLALLOCATORS_ARENAHEAPSTLALLOCATOR
 
 
#include "AthAllocators/ArenaHeapAllocator.h"
#include "CxxUtils/checker_macros.h"
#include <string>
#include <cstddef>
 
 
namespace SG {
 

template <class T>
class ArenaHeapSTLAllocator_initParams
  : public ArenaHeapAllocator::initParams<T, false, true, true>
{
public:
  typedef ArenaHeapAllocator::initParams<T, false, true, true> Base;

    ArenaHeapSTLAllocator_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 ArenaHeapSTLAllocator
{
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 ArenaHeapSTLAllocator<U, VETO> other;
  };
 

  ArenaHeapSTLAllocator (size_t nblock = 1000, const std::string& name = "");
 

  ArenaHeapSTLAllocator (const ArenaHeapSTLAllocator& a);
 

  template <class U, class V>
  ArenaHeapSTLAllocator (const ArenaHeapSTLAllocator<U, V>& a);
 

  ArenaHeapSTLAllocator (ArenaHeapSTLAllocator&& a);
 

  ArenaHeapSTLAllocator& operator= (ArenaHeapSTLAllocator&& a);
 

  void swap (ArenaHeapSTLAllocator& a);
 

  ArenaHeapSTLAllocator select_on_container_copy_construction() const;
 

  bool operator== (const ArenaHeapSTLAllocator& other) const;
 

  bool operator!= (const ArenaHeapSTLAllocator& 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);
  template <bool = true>
  requires (!std::same_as<reference,const_reference>)
  void
  deallocate (const_pointer p, size_type n) const
  {
    pointer p_nc ATLAS_THREAD_SAFE = const_cast<pointer>(p);
    deallocate (p_nc, 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:
  ArenaHeapAllocator m_pool;
};
 
 

template <class T>
class ArenaNonConstHeapSTLAllocator;
 

template <class T>
class ArenaHeapSTLAllocator<T, T>
  : 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 ArenaHeapSTLAllocator<U, T> other;
  };
 

  ArenaHeapSTLAllocator (size_t nblock = 1000, const std::string& name = "");
 

  template <class U, class V>
  ArenaHeapSTLAllocator (const ArenaHeapSTLAllocator<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
  ArenaNonConstHeapSTLAllocator<T> get_allocator (CONT& c);
 
 
private:
  size_t m_nblock;

  std::string m_name;

  const ArenaBlockAllocatorBase* m_poolptr;
};
 

template <class T>
class ArenaNonConstHeapSTLAllocator
  : public ArenaHeapSTLAllocator<T, T>
{
public:
  template <class U, class V>
  ArenaNonConstHeapSTLAllocator (const ArenaHeapSTLAllocator<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 (ArenaHeapSTLAllocator<T, VETO>& a);
 
 
} // namespace SG
 
 
#include "AthAllocators/ArenaHeapSTLAllocator.icc"
 
 
#endif // ATLALLOCATORS_ARENAHEAPSTLALLOCATOR