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