pointer_list.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-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef CXXUTILS_POINTER_LIST_H
#define CXXUTILS_POINTER_LIST_H
 
 
#include <type_traits>
#include <iterator>
 
 
namespace CxxUtils {
 
 
class pointer_list_base
{
public:
  struct list_block
  {
  public:
    typedef unsigned long ulong;
 
    typedef void* value_type;
 
    value_type m_data[1];
 
    static size_t size (size_t nelt);
  };
 
 
  class allocator
  {
  public:
    allocator (size_t nelt,
               size_t nblock,
               unsigned long end_mask,
               unsigned long end_offs);
 
    ~allocator();
 
    list_block* allocate();
 
    size_t nelt() const;
 
    size_t nchunks() const;
 
    bool at_end (const void* p) const;
 
 
  private:
    void refill();
 
    struct chunk
    {
      chunk* m_next;
 
      list_block* m_blocks;
    };
 
    size_t m_nelt;
 
    size_t m_nblock;
 
    chunk* m_chunks;
 
    size_t m_nthis;
 
    size_t m_nchunks;
 
    unsigned long m_end_mask;
 
    unsigned long m_end_offs;
  };
 
 
  typedef allocator pool_type;
 
  typedef list_block::value_type value_type;
 
  pointer_list_base (pool_type& pool);
 
  void push_back (value_type p);
 
  size_t size() const;
 
  void clear();
 
  bool empty() const;
 
 
protected:
  list_block* m_head;
 
  value_type* m_insert;
 
  size_t m_size;
 
  allocator& m_pool;
 
  void firstblock ();
 
  void nextblock ();
 
  list_block* getblock();
};
 
 
template <size_t NELT = 15>
class pointer_list
  : public pointer_list_base
{
public:
  typedef pointer_list_base::value_type value_type;
 
 
  class allocator
    : public pointer_list_base::allocator
  {
  public:
    static_assert (((NELT+1) & NELT) == 0);
 
    static const unsigned long END_OFFS = NELT * sizeof(value_type);
    static const unsigned long END_MASK = END_OFFS | (sizeof(value_type)-1);
 
    allocator (size_t nblock = 100);
    
 
    static bool at_end_static (const void* p);
  };
 
 
  class iterator
  {
  public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = pointer_list::value_type;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type*;
    using reference = value_type&;
 
    bool operator== (const iterator& other) const;
 
    bool operator!= (const iterator& other) const;
 
    reference operator*();
 
    iterator& operator++();
 
    iterator operator++(int);
 
 
  private:
    iterator (value_type* p);
 
    value_type* m_p;
 
    friend class pointer_list;
  };
 
  typedef allocator pool_type;
 
  pointer_list (pool_type& pool);
 
  iterator begin();
 
  iterator end();
 
  void erase (iterator it);
};
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/pointer_list.icc"
 
 
#endif // not CXXUTILS_POINTER_LIST_H