---

kettec.h

Go to the documentation of this file.

/*
Copyright (C) 1999  Carsten Winkelholz

Address:  FGAN Forschungsgesellschaft f�r Angewandte Naturwissenschaften e. V.
      Neuenahrer Str. 20
      D - 53343 Wachtberg
      
Email:    winkelholz@fgan.de

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/


#ifndef KETTE_HC
#define KETTE_HC

#include <assert.h>

#include "../oawconfig.h"

OAW_BEGIN_NAMESPACE

template <class Typ> class KetteC;

template <class Typ>
class KettenElementC
{
  friend class KetteC<Typ>;
public:
  KettenElementC(const Typ& t){v=0;r=0;element=t;}
  inline KettenElementC* forward(){return v;}
  inline KettenElementC* back(){return r;}
public:
  Typ element;
protected:
  KettenElementC* v;
  KettenElementC* r;
};


template <class Typ>
class KetteC
{
public:
                        
        class Iter{
                public:
                        Iter(){p=0;}
                        Iter(KettenElementC<Typ>*pp){p=pp;}
                        const Iter& operator ++(int){if(p) p=p->forward(); return *this;}
                        const Iter& operator --(int){if(p) p=p->back(); return *this;}
                        int operator != (const Iter& i) const{
                                return p!=i.p;
                        }
                        int operator == (const Iter& i) const{
                                return p==i.p;
                        }
                        const Typ& operator * (){
                                return p->element;
                        }
                protected:
                        KettenElementC<Typ>* p;
        };
public:
  long size(){return m_laenge;}
        Iter begin(){return m_zanfang;}
        Iter end(){return 0;}
  KettenElementC<Typ>* pBegin() const {return m_zanfang;};
  KettenElementC<Typ>* pEnd(){return m_zende;}
  KetteC(){m_zanfang=m_zende=0;m_laenge=0;m_loop=0;}
  KetteC<Typ>(const KetteC<Typ>& k)
  {
    m_zanfang=m_zende=0;
    m_laenge=0;
    m_loop=0;
    KettenElementC<Typ> *z;
    z=k.m_zanfang;
    if(z==0) return;
    while(z!=k.m_zende)
      {
        push_back(z->element);
        z=z->v;
      }   
    push_back(z->element);
    if(k.m_loop){CloseLoop();}
  }

  ~KetteC()
  {
    if(m_laenge==0) {return;}
    m_zanfang->r=0;  m_zende->v=0;
    KettenElementC<Typ> *z=m_zanfang;
    while ((z!=m_zende)&&(z!=0)){z=z->v;delete (z->r);}
    if(z!=0){delete z;}
  }

  void RemoveAll(const Typ& t)
  {  
    if(m_zanfang==0) return;
    KettenElementC<Typ> *z,*tmpz;
    z=m_zanfang;
    if ((z==0)||(m_laenge==0)){return;}
    while(z!=0){
      if(z->element==t){
        tmpz =z;
        z=z->v;
        Remove(tmpz);
      }else{
        z=z->v;
      }
    }
  }

  void RemoveSingle(const Typ& t)
  {
    if(m_zanfang==0) return;
    KettenElementC<Typ> *z;
    z=m_zanfang;
    if ((z==0)||(m_laenge==0)){return;}
    while(z!=0){
      if(z->element==t){Remove(z);return;}
      z=z->v;
    }
  }

  void Remove(KettenElementC<Typ>* z)
  {
    assert(m_zanfang!=0);
    if(m_laenge==1){
      assert(z==m_zanfang);delete z;m_laenge=0;m_zanfang=0;m_zende=0;return;}
    if(z==m_zanfang){m_zanfang=z->v;m_zanfang->r=0;m_laenge--; delete z;return;}
    if(z==m_zende){m_zende=z->r;m_zende->v=0;m_laenge--; delete z;return;}
    z->r->v=z->v;
    z->v->r=z->r;
    delete z;
    m_laenge--;
  }

  short RemoveFirst()
  {
     KettenElementC<Typ> *z;
     z=m_zanfang;
     if(z==0) return 0;
     if(m_loop){CutLoop();m_loop=1;}
     m_zanfang=z->v;
     delete z;
     m_laenge--;
     if(m_laenge==0){
                         m_zanfang=m_zende=0;
                 }else{
                        m_zanfang->r=0;
                 }
     if(m_loop){CloseLoop();}
     return 1;
  }

  short RemoveLast()
  {
     KettenElementC<Typ> *z;
     z=m_zende;
     if(z==0) return 0;
     if(m_loop){CutLoop();m_loop=1;}
     m_zende=z->r;
     delete z;
     m_laenge--;
     if(m_laenge==0){
                         m_zanfang=m_zende=0;
                 }else{
                         m_zende->v=0;
                 }
     if(m_loop){CloseLoop();}
     return 1;
  }

  short RemoveFirst(Typ& t)
  {
    if(m_zanfang==0){return 0;}
    t=m_zanfang->element;
    return RemoveFirst();
  }

  short RemoveLast(Typ& t)
  {
    if(m_zende==0){return 0;}
    t=m_zende->element;
    return removeLast();
  }

  void push_back(const Typ& t)
  {
     KettenElementC<Typ> *z = new KettenElementC<Typ>(t);
     if(z==0) return;
     if(m_loop){CutLoop();m_loop=1;}   
     if(m_zanfang==0){m_zanfang=m_zende=z;}
         else{z->r=m_zende;m_zende->v=z;m_zende=z;}
     if(m_loop){CloseLoop();}
     m_laenge++;
  }

  void Empty()
  {
    KettenElementC<Typ> *z;
    if(m_zanfang==0){return;}
    if(m_zanfang!=0){m_zanfang->r=0;m_zende->v=0;}
    CutLoop();
    z=m_zanfang;
    while (z!=m_zende){z=z->v;delete(z->r);}
    if(z!=0){delete z;}
    m_zanfang=0; m_zende=0;
    m_laenge=0;
  }


  KetteC<Typ>& operator = (const KetteC<Typ>& k)
  {
    KettenElementC<Typ> *z;
    Empty();
    z=k.m_zanfang;
    if(z==0) return *this;
    while(z!=k.m_zende)
      {
        push_back(z->element);
        z=z->v;
      }   
    push_back(z->element);
    if(k.m_loop){CloseLoop();}
    return *this;
  }

  KettenElementC<Typ>* GetElement(const Typ& t){
    KettenElementC<Typ> *z=m_zanfang;
    if(m_zanfang==0){return 0;}
    while(z!=m_zende){
      if(z->element == t){return 1;}
      z=z->v;
    }
    if(z->element == t){return z;}
    return 0;
  }

  short Contain(const Typ& t)
  {
    KettenElementC<Typ> *z=m_zanfang;
    if(m_zanfang==0){return 0;}
    while(z!=m_zende){
      if(z->element == t){return 1;}
      z=z->v;
    }
    if(z->element == t){return 1;}
    return 0;
  }

  long Count(const Typ& t)
  {
    long i=0;
    KettenElementC<Typ> *z=m_zanfang;
    if(m_zanfang==0){return 0;}
    while(z!=0){
      if(z->element == t){i++;}
      z=z->v;
    }
    return i;
  }

protected:
  void CloseLoop()
  {
    if(m_zanfang==0){return;}
    m_loop=1;
    m_zende->v=m_zanfang;
    m_zanfang->r=m_zende;
  }

  void CutLoop()
  {
    if(m_zanfang==0){return;}
    m_loop=0;
    m_zende->v=0;
    m_zanfang->r=0;
  }


protected:
  long m_laenge;
  int m_loop;
  KettenElementC<Typ> *m_zanfang;
  KettenElementC<Typ> *m_zende;
};

OAW_END_NAMESPACE

#endif

---