added files:

misc.hh, some small useful things, like ABS, MAX, etc
dlist : double linked list container
Stack : stack container based on double linked list
(did not use stl to make Dune self-contained)

[[Imported from SVN: r10]]

common/Stack.hh

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef __STACK_HH__
+#define __STACK_HH__
+
+#include "dlist.hh"
+
+namespace Dune {
+
+  template<class T>
+  class Stack : private DoubleLinkedList<T> {
+  public:
+    bool isempty () const;     // Stack leer ?
+    bool isfull () const;      // Stack voll (nur bei vorgegebener Groesse)
+    void push_front (T t);     // Einfuegen eines Elementes
+    T pop_front ();            // Entfernen eines Elementes
+    T front () const;          // Inspizieren des obersten Elementes
+    int size() const;          // get number of elements in stack
+  } ;
+
+  template<class T>
+  inline int Stack<T>::size () const
+  {
+    return DoubleLinkedList<T>::size();
+  }
+
+  template<class T>
+  inline bool Stack<T>::isempty () const
+  {
+    return size()==0;
+  }
+
+  template<class T>
+  inline bool Stack<T>::isfull () const
+  {
+    return false;
+  }
+
+  template<class T>
+  inline void Stack<T>::push_front (T t)
+  {
+    insert_after(rbegin(),t);
+  }
+
+  template<class T>
+  inline T Stack<T>::pop_front ()
+  {
+    DoubleLinkedList<T>::Iterator i=rbegin();
+    T t = *i;
+    erase(i);
+    return t;
+  }
+
+  template<class T>
+  inline T Stack<T>::front () const
+  {
+    DoubleLinkedList<T>::Iterator i=rbegin();
+    T t = *i;
+    return t;
+  }
+
+}
+
+#endif

common/dlist.cc

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef __DLIST_CC__
+#define __DLIST_CC__
+
+#include <new.h> // fuer std::nothrow
+
+namespace Dune {
+
+  // Iterator interface
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::begin () const
+  {
+    return head;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::end () const
+  {
+    Iterator tmp;     // Iterator mit 0 Zeiger !
+    return tmp;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::rbegin () const
+  {
+    return tail;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::rend () const
+  {
+    Iterator tmp;     // Iterator mit 0 Zeiger !
+    return tmp;
+  }
+
+  // Konstruktor
+  template<class T>
+  inline DoubleLinkedList<T>::DoubleLinkedList ()
+  { // ruft vorher Default_konstruktor fuer head, tail
+    numelements=0;
+  }
+
+  // Copy-Konstruktor
+  template<class T>
+  inline DoubleLinkedList<T>::DoubleLinkedList (const DoubleLinkedList<T>& l)
+  { // ruft vorher Default_konstruktor fuer head, tail
+    numelements=0;
+    // kopiere alle Elemente der Argumentliste
+    for (DoubleLinkedList<T>::Iterator i=l.begin(); i!=l.end(); i++)
+      insert_after(rbegin(),*i);
+  }
+
+  // Zuweisung
+  template<class T>
+  inline DoubleLinkedList<T>& DoubleLinkedList<T>::operator= (const DoubleLinkedList<T>& l)
+  {
+    if (this!=&l)
+    {
+      // loesche alle Elemente der Liste auf der linken Seite
+      while (begin()!=end()) erase(begin());
+
+      // kopiere alle Elemente der Liste auf der rechten Seite
+      for (DoubleLinkedList<T>::Iterator i=l.begin(); i!=l.end(); i++)
+        insert_after(rbegin(),*i);
+    }
+    return *this;
+  }
+
+  // Destruktor
+  template<class T>
+  inline DoubleLinkedList<T>::~DoubleLinkedList()
+  {
+    while (begin()!=end()) erase(begin());
+  }
+
+  template<class T>
+  inline int DoubleLinkedList<T>::size () const
+  {
+    return numelements;
+  }
+
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::insert_after (Iterator i, T t)
+  {
+    // Teste Eingabe
+    if (i.p==0 && head.p!=0) {cerr << "wo einfuegen?" << endl; return end();}
+
+    // neues Listenelement erzeugen,
+    Element* e = new(std::nothrow) Element(t);
+    if (e==0) {cerr << "Kein Platz mehr" << endl; return end();}
+
+    // einfuegen
+    if (head.p==0)
+    {
+      // einfuegen in leere Liste
+      head.p=e; tail.p=e;
+    }
+    else
+    {
+      // nach Element i.p einsetzen
+      e->prev = i.p;
+      e->next = i.p->next;
+      i.p->next = e;
+      if (e->next!=0) e->next->prev = e;
+      // tail neu ?
+      if (tail==i) tail.p=e;
+    }
+
+    // Groesse und Rueckgabeiterator
+    numelements = numelements+1;
+    Iterator tmp;
+    tmp.p = e;
+    return tmp;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator DoubleLinkedList<T>::insert_before (Iterator i, T t)
+  {
+    // Teste Eingabe
+    if (i.p==0 && head.p!=0) {cerr << "wo einfuegen?" << endl; return end();}
+
+    // neues Listenelement erzeugen,
+    Element* e = new(std::nothrow) Element(t);
+    if (e==0) {cerr << "Kein Platz mehr" << endl; return end();}
+
+    // einfuegen
+    if (head.p==0)
+    {
+      // einfuegen in leere Liste
+      head.p=e; tail.p=e;
+    }
+    else
+    {
+      // vor Element i.p einsetzen
+      e->next = i.p;
+      e->prev = i.p->prev;
+      i.p->prev = e;
+      if (e->prev!=0) e->prev->next = e;
+      // head neu ?
+      if (head==i) head.p=e;
+    }
+
+    // Groesse und Rueckgabeiterator
+    numelements = numelements+1;
+    Iterator tmp;
+    tmp.p = e;
+    return tmp;
+  }
+
+  template<class T>
+  inline void DoubleLinkedList<T>::erase (Iterator i)
+  {
+    // Teste Eingabe
+    if (i.p==0) return;
+
+    // Ausfaedeln
+    if (i.p->next!=0) i.p->next->prev = i.p->prev;
+    if (i.p->prev!=0) i.p->prev->next = i.p->next;
+
+    // head & tail
+    if (head==i) head.p=i.p->next;
+    if (tail==i) tail.p=i.p->prev;
+
+    // Loeschen
+    delete i.p;
+
+    // Groesse
+    numelements = numelements-1;
+
+    return;
+  }
+
+  template <class T>
+  inline ostream& operator<< (ostream& s, DoubleLinkedList<T>& a)
+  {
+    T t;
+    s << "dlist " << a.size() << " elements = (" << endl;
+    for (DoubleLinkedList<T>::Iterator i=a.begin(); i!=a.end(); i++)
+    {
+      t = *i;
+      s << "    " << t << endl;
+    }
+    s << ")" << endl;
+    return s;
+  }
+
+
+  template<class T>
+  inline DoubleLinkedList<T>::Element::Element (T &t) : item(t)
+  {
+    next=0; prev=0;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator::Iterator ()
+  {
+    p=0;
+  }
+
+  template<class T>
+  inline bool DoubleLinkedList<T>::Iterator::operator!=
+    (DoubleLinkedList<T>::Iterator x)
+  {
+    return p != x.p;
+  }
+
+  template<class T>
+  inline bool DoubleLinkedList<T>::Iterator::operator==
+    (DoubleLinkedList::Iterator x)
+  {
+    return p == x.p;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator
+  DoubleLinkedList<T>::Iterator::operator++ () // prefix
+  {
+    p = p->next; return *this;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator
+  DoubleLinkedList<T>::Iterator::operator++ (int) // postfix
+  {
+    Iterator tmp = *this;
+    ++*this;
+    return tmp;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator
+  DoubleLinkedList<T>::Iterator::operator-- () // prefix
+  {
+    p = p->prev; return *this;
+  }
+
+  template<class T>
+  inline DoubleLinkedList<T>::Iterator
+  DoubleLinkedList<T>::Iterator::operator-- (int) // postfix
+  {
+    Iterator tmp = *this;
+    --*this;
+    return tmp;
+  }
+
+  template<class T>
+  inline T& DoubleLinkedList<T>::Iterator::operator* () const
+  {
+    return p->item;
+  }
+
+  template<class T>
+  inline T* DoubleLinkedList<T>::Iterator::operator-> () const
+  {
+    return &(p->item);
+  }
+
+}
+
+#endif

common/dlist.hh

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef __DLIST_HH__
+#define __DLIST_HH__
+
+namespace Dune {
+
+  template <class T> class DoubleLinkedList {
+  private:
+    struct Element;       // Vorwaertsdeklaration fuer das Listenelement
+  public:
+    class Iterator {      // Iteratorklasse zum
+    private:              // Durchlaufen der Elemente des Containers
+      Element* p;             // Iterator ist ein Zeiger auf ein Listenelement
+    public:
+      Iterator();
+      bool operator!= (Iterator x);
+      bool operator== (Iterator x);
+      Iterator operator++ ();             // prefix Stroustrup p. 292
+      Iterator operator++ (int);          // postfix
+      Iterator operator-- ();             // prefix
+      Iterator operator-- (int);          // postfix
+      T& operator* () const;
+      T* operator-> () const;           // Stroustrup p. 289
+      friend class DoubleLinkedList<T>;
+    } ;
+    Iterator begin () const;
+    Iterator end () const;
+    Iterator rbegin () const;
+    Iterator rend () const;
+
+    DoubleLinkedList();
+    DoubleLinkedList (const DoubleLinkedList<T>&);
+    ~DoubleLinkedList();
+    DoubleLinkedList<T>& operator= (const DoubleLinkedList<T>&);
+    int size () const;
+    Iterator insert_after (Iterator i, T t);
+    Iterator insert_before (Iterator i, T t);
+    void erase (Iterator i);
+
+  private:
+    struct Element {          // Typ fuer das Listenelement
+      Element* next;              // Nachfolger
+      Element* prev;              // Vorgaenger
+      T item;                     // Datum
+      Element (T &t);             // setze next=prev=0
+    };
+
+    Iterator head;            // erstes Element der Liste
+    Iterator tail;            // letztes Element der Liste
+    int numelements;          // Anzahl Elemente in der Liste
+  } ;
+
+}
+
+#include "dlist.cc"
+
+#endif

common/misc.hh

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#ifndef __MISC_HH__
+#define __MISC_HH__
+
+#include <iostream>
+#include <math.h>
+
+namespace Dune {
+  /** @addtogroup Common
+
+          @{
+   */
+
+  template<class T>
+  T ABS (T t)
+  {
+    if (t<0) return -t;
+    return t;
+  }
+
+  template<class T>
+  T MAX (T t1, T t2)
+  {
+    if (t1<t2) return t2;
+    return t1;
+  }
+
+  template<class T>
+  T MIN (T t1, T t2)
+  {
+    if (t1<t2) return t1;
+    return t2;
+  }
+
+  /** @} */
+
+}
+
+
+#endif