base/reflist

Go to the documentation of this file.

#ifndef __REFLIST__
#define __REFLIST__

#include <list>
#include <base/ref>

namespace base {

template <class _Tp, class _Alloc = std::allocator<_Tp> >
class reflist 
{
protected:
  typedef std::list< ref<_Tp>, _Alloc >                   reflist_type;
  typedef std::list< ref<const _Tp>, _Alloc >             reflist_const_type;
  typedef const std::list< ref<_Tp>, _Alloc >       const_reflist_type;
  typedef const std::list< ref<const _Tp>, _Alloc > const_reflist_const_type;
  reflist_type l;
  reflist_const_type& l_const() { return reinterpret_cast<reflist_const_type&>(l); }
  const_reflist_type& const_l() const { return reinterpret_cast<const_reflist_type&>(l); }
  const_reflist_const_type& const_l_const() const { return reinterpret_cast<const_reflist_const_type&>(l); }

public:      
  typedef ref<_Tp> value_type;
  typedef value_type* pointer;
  typedef const value_type* const_pointer;
  typedef value_type& reference;
  typedef const value_type& const_reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Alloc allocator_type;

  typedef typename reflist_type::iterator                   iterator;
  typedef typename reflist_const_type::iterator             iterator_const;
  typedef typename const_reflist_type::const_iterator       const_iterator;
  typedef typename const_reflist_const_type::const_iterator const_iterator_const;

  typedef std::reverse_iterator<iterator>                   reverse_iterator;
  typedef std::reverse_iterator<iterator_const>             reverse_iterator_const;
  typedef std::reverse_iterator<const_iterator>       const_reverse_iterator;
  typedef std::reverse_iterator<const_iterator_const> const_reverse_iterator_const;


public:
  iterator begin()                         { return l.begin(); }
  const_iterator begin() const             { return const_l().begin(); }
  const_iterator_const const_begin() const { return const_l_const().begin(); }

  iterator end()             { return l.end(); }
  const_iterator end() const { return const_l().end(); }
  const_iterator_const const_end() const { return const_l_const().end(); }

  reverse_iterator rbegin() 
    { return reverse_iterator(end()); }
  const_reverse_iterator rbegin() const 
    { return const_reverse_iterator(end()); }
  const_reverse_iterator_const const_rbegin() const
    { return const_reverse_iterator(const_end()); }

  reverse_iterator rend()
    { return reverse_iterator(begin()); }
  const_reverse_iterator rend() const
    { return const_reverse_iterator(begin()); }
  const_reverse_iterator_const const_rend() const
    { return const_reverse_iterator(const_begin()); }

  bool empty() const { return l.empty(); }
  size_type size() const {
    return l.size();
  }
  size_type max_size() const { return l.max_size(); }

  reference front() { return *begin(); }
  const_reference front() const { return *begin(); }
  reference back() { return *(--end()); }
  const_reference back() const { return *(--end()); }

  void swap(reflist<_Tp, _Alloc>& __x) { l.swap(__x); }

  iterator insert(iterator __position, ref<_Tp> __x) {
    return l.insert(__position,__x);
  }
  iterator insert(iterator __position) { return insert(__position, ref<_Tp>()); }


  template <class _InputIterator>
  void insert(iterator __pos, _InputIterator __first, _InputIterator __last) {
    l.insert(__pos, __first, __list);
  }

  void insert(iterator __pos, size_type __n, ref<_Tp> __x) 
  { l.insert(__pos, __n, __x); }
 
  void push_front(ref<_Tp> __x) { insert(begin(), __x); }
  void push_front() {insert(begin());}
  void push_back(ref<_Tp> __x) { insert(end(), __x); }
  void push_back() {insert(end());}

  iterator erase(iterator __position) {
    return l.erase(__position);
  }
  iterator erase(iterator __first, iterator __last) { return l.erase(__first, __last); }
  void clear() { l.clear(); }

  void resize(size_type __new_size, ref<const _Tp> __x) { l_const().resize(__new_size, __x); }
  void resize(size_type __new_size, ref<_Tp> __x) { l.resize(__new_size, __x); }
  void resize(size_type __new_size) { resize(__new_size, ref<_Tp>()); }

  void pop_front() { erase(begin()); }
  void pop_back() { 
    l.pop_back();
  }

  reflist() {}
  reflist(size_type __n, ref<_Tp> __value)
    : l(__n, __value) {}

  explicit reflist(size_type __n)
    : l(__n) {}


  template <class _InputIterator>
  reflist(_InputIterator __first, _InputIterator __last)
    : l(__first, __last) {}

  reflist(const reflist<_Tp, _Alloc>& __x) : l(__x.l) {}

  ~reflist() { }

  reflist<_Tp, _Alloc>& operator=(const reflist<_Tp, _Alloc>& __x) { l = __x.l; return *this; }

public:
  // assign(), a generalized assignment member function.  Two
  // versions: one that takes a count, and one that takes a range.
  // The range version is a member template, so we dispatch on whether
  // or not the type is an integer.

  void assign(size_type __n, ref<_Tp> __val) { l.assign(__n, __val); }


  template <class _InputIterator>
  void assign(_InputIterator __first, _InputIterator __last) {
    l.assign(__first, __last);
  }


  void splice(iterator __position, reflist& __x) {
    l.splice(__position, __x);
  }
  void splice(iterator __position, reflist& __x, iterator __i) {
    l.splice(__position, __x, __i);
  }
  void splice(iterator __position, reflist& __x, iterator __first, iterator __last) {
    l.splice(__position, __x, __first, __last);
  }
  //void remove(ref<_Tp> __value) { l.remove(__value); }
  void remove(ref<const _Tp> __value) { l_const().remove(__value); }
  void unique() { l.unique(); }
  void merge(reflist& __x) { l.merge(__x); }
  void reverse() { l.reverse(); }
  void sort() { l.sort(); }

  template <class _Predicate> void remove_if(_Predicate p) { l.remove_if(p); }
  template <class _BinaryPredicate> void unique(_BinaryPredicate bp) { l.unique(bp); }
  template <class _StrictWeakOrdering> void merge(reflist& __x, _StrictWeakOrdering swo) { l.merge(__x, swo); }
  template <class _StrictWeakOrdering> void sort(_StrictWeakOrdering swo) { l.sort(swo); }

};


} // base

#endif 

---