/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/CxxUtils/CxxUtils/pointer_list.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id$
#ifndef CXXUTILS_POINTER_LIST_H
#define CXXUTILS_POINTER_LIST_H


#include "boost/static_assert.hpp"
#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:
    BOOST_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 std::iterator<std::forward_iterator_tag, value_type>
  {
  public:
    typedef typename std::iterator<std::forward_iterator_tag, value_type>
      base;
    typedef typename base::iterator_category iterator_category;
    typedef typename base::difference_type   difference_type;
    typedef typename base::pointer            pointer;
    typedef typename base::reference          reference;

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

    bool operator!= (const iterator& other) const;

    reference operator*() const;

    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

---