List.h

Go to the documentation of this file.

// Copyright (C) 2003 Johan Hoffman and Anders Logg.
// Licensed under the GNU GPL Version 2.

#ifndef __LIST_H
#define __LIST_H

#include <list>
#include <iterator>
#include <dolfin/dolfin_log.h>

namespace dolfin {



  template <class T> class List {
  public:

    List();
    
    ~List();
    
    void clear();

    void add(const T& element);
    
    int size() const;

    bool empty() const;

    bool contains(const T& element);

    void remove(const T& element);

    T pop();
    
    
    class Iterator {
    public:
      
      Iterator(List<T>& list);

      Iterator(const Iterator& it);

      int index() const;
                
      Iterator& operator++();
                
      bool end() const;
        
      bool last() const;

      T& operator*() const;

      T* operator->() const;

      operator T*() const;
                
      T* pointer() const;
      
      void operator=(const Iterator& it);

      bool operator==(const Iterator& it) const;
                
      bool operator!=(const Iterator& it) const;

    private:

      typename std::list<T>::iterator it;
      std::list<T>& l;
      int _index;

    };

    // Friends
    friend class Iterator;

  private:

    std::list<T> l;

  };

  //---------------------------------------------------------------------------
  // Implementation of List
  //---------------------------------------------------------------------------
  template <class T> List<T>::List()
  {
    // Do nothing
  }
  //---------------------------------------------------------------------------
  template <class T> List<T>::~List()
  {
    // Do nothing
  }
  //---------------------------------------------------------------------------
  template <class T> void List<T>::clear()
  {
    l.clear();    
  }
  //---------------------------------------------------------------------------
  template <class T> void List<T>::add(const T& element)
  {
    l.push_back(element);
  }
  //---------------------------------------------------------------------------
  template <class T> int List<T>::size() const
  {
    // Note the following from the stl manual: You should not assume
    // that this function is constant time. It is permitted to be
    // O(N), where N is the number of elements in the list.
    
    return l.size();
  }
  //---------------------------------------------------------------------------
  template <class T> bool List<T>::empty() const
  {
    return l.empty();
  }
  //---------------------------------------------------------------------------
  template <class T> bool List<T>::contains(const T& element)
  {
    for (typename std::list<T>::iterator it = l.begin(); it != l.end(); ++it)
      if ( *it == element )
        return true;

    return false;
  }
  //---------------------------------------------------------------------------
  template <class T> void List<T>::remove(const T& element)
  {
    for (typename std::list<T>::iterator it = l.begin(); it != l.end(); ++it)
      if ( *it == element ) {
        l.erase(it);
        return;
      }
    dolfin_error("Element is not in the list.");
  }
  //---------------------------------------------------------------------------
  template <class T> T List<T>::pop()
  {
    T first = l.front();
    l.pop_front();
    return first;
  }
  //---------------------------------------------------------------------------
  // Implementation of List::Iterator
  //---------------------------------------------------------------------------
  template <class T> List<T>::Iterator::Iterator (List<T>& list) : l(list.l)
  {
    it = l.begin();
    _index = 0;
  }
  //---------------------------------------------------------------------------
  template <class T> List<T>::Iterator::Iterator(const Iterator& it) : l(it.l)
  {
    this->it = it.it;
    this->_index = it._index;
  }
  //---------------------------------------------------------------------------
  template <class T> int List<T>::Iterator::index() const
  {
    return _index;
  }
  //---------------------------------------------------------------------------
  template <class T> typename List<T>::Iterator& List<T>::Iterator::operator++()
  {
    ++it;
    ++_index;
    return *this;
  }
  //---------------------------------------------------------------------------
  template <class T> bool List<T>::Iterator::end() const
  {
    return it == l.end();
  }
  //---------------------------------------------------------------------------
  template <class T> bool List<T>::Iterator::last() const
  {
    // FIXME: This is probably not the correct way to make the check
    typename std::list<T>::iterator new_it = it;
    ++new_it;
    return new_it == l.end();
  }
  //---------------------------------------------------------------------------
  template <class T> T& List<T>::Iterator::operator*() const
  {
    return *it;
  }
  //---------------------------------------------------------------------------
  template <class T> T* List<T>::Iterator::operator->() const
  {
    return &(*it);
  }
  //---------------------------------------------------------------------------
  template <class T> List<T>::Iterator::operator T*() const
  {
    return &(*it);
  }
  //---------------------------------------------------------------------------
  template <class T> T* List<T>::Iterator::pointer() const
  {
    return &(*it);
  }
  //---------------------------------------------------------------------------
  template <class T> void List<T>::Iterator::operator=(const Iterator& it)
  {
    this->it = it;
  }
  //---------------------------------------------------------------------------
  template <class T>  bool List<T>::Iterator::operator==
  (const Iterator& it) const
  {
    return this->it == it;
  }
  //---------------------------------------------------------------------------
  template <class T>bool List<T>::Iterator::operator!=
  (const Iterator& it) const
  {
    return this->it != it;
  }
  //---------------------------------------------------------------------------
  
}

#endif

Documentation automatically generated with Doxygen on 10 Sep 2004.