---

arrayc.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 ARRAYC_H
#define ARRAYC_H


#include <assert.h>

#include "../oawconfig.h"

OAW_BEGIN_NAMESPACE

template <class Typ> 
class OAW_DLLMAPPING ArrayC
{
protected:

   Typ m_blank;
   long m_blocklen;
   long m_buflen;
   long m_anzahlelemente;
   Typ *m_array;

public:
  ArrayC(){
    m_buflen= 1;
    m_anzahlelemente = 0;
    m_blocklen = 0;
    m_array = new Typ[1];
  }

  ArrayC(const ArrayC<Typ>& A){
    long i;
    m_blocklen=A.m_blocklen;
    m_buflen=A.m_buflen;
    m_anzahlelemente=A.m_anzahlelemente;
    m_array=new Typ[m_buflen];
    for(i=0;i<m_buflen;i++){m_array[i]=A.m_array[i];}
  }

  ArrayC(const Typ* data, long datalen){
    m_buflen= datalen;
    m_anzahlelemente = datalen;
    m_blocklen = 0;
    m_array = new Typ[datalen];
    for(long i=0;i<datalen;i++){
      m_array[i] = data[i]; 
    }
  }

  ArrayC(long l,long b, const Typ& bl){
     m_buflen= l;
     m_anzahlelemente = 0;
     m_blocklen = b;
     m_array = new Typ[l];
     SetBlankAndClear(bl);
  }

  ArrayC(long datalen){
    m_buflen= datalen;
    m_anzahlelemente = 0;
    m_blocklen = 0;
    m_array = new Typ[datalen];
  }

  ~ArrayC(){
    delete [] m_array;
  }

  const ArrayC<Typ>& operator = (const ArrayC<Typ>& A){
    if (this == &A) return *this;
    long i;
    delete [] m_array;
    m_blocklen=A.m_blocklen;
    m_buflen=A.m_buflen;
    m_anzahlelemente=A.m_anzahlelemente;
    m_array=new Typ[m_buflen];
    for(i=0;i<m_buflen;i++){m_array[i]=A.m_array[i];}
    return *this;
  }


  short operator == (const ArrayC<Typ>& a){
    for(long i=0;i<m_buflen;i++){
      if(m_array[i]!=a.m_array[i]) return 0;
    }
    return 1;
  }


  short operator != (const ArrayC<Typ>& a){
    for(long i=0;i<m_buflen;i++){
      if(m_array[i]!=a.m_array[i]) return 1;
    }
    return 0;
  }

  const Typ& get(long l) const {
     assert(l<m_anzahlelemente);
     return m_array[l];
  }

  inline long capacity() const{return m_buflen;}

  inline long size() const{return m_anzahlelemente;}

  inline Typ& operator [](long i) {return m_array[i];}

  inline Typ& back(){
    assert(m_anzahlelemente>0);
    return m_array[m_anzahlelemente-1];
  }

  short put(long l,const Typ& t){
     if(l>=m_anzahlelemente) return 0;
     m_array[l]=t;
     return 1;
  }

  void set(long l, const Typ& t){
    if(l>=m_anzahlelemente){SetLength(l+1);}
    m_array[l] = t;
  }

  void push_back(const Typ& t){
     if ( m_anzahlelemente >= m_buflen){MakeLonger(m_blocklen+1);}
     m_array[m_anzahlelemente++]=t;   
  }

  short pop_back(Typ& t)
  {
    short erg = m_anzahlelemente>0;
    if(m_anzahlelemente>0){
      m_anzahlelemente--;
      t = m_array[m_anzahlelemente];
    }
    return erg;
  }

  short pop_front(Typ& t)
  {
    short erg = m_anzahlelemente>0;
    if(erg){
      t = m_array[0];
      RemoveElementAtPos(0);
    }
    return erg;
  }

  void push(){
    assert(m_anzahlelemente>0);
    if ( m_anzahlelemente >= m_buflen){MakeLonger(m_blocklen+1);}
    push_back(m_array[m_anzahlelemente-1]);
  }

  void Erase(long a, long e){
    if(a<0){a=0;}
    if(e>=m_anzahlelemente){e=m_anzahlelemente-1;}
    if(a>e){return;}
    long i; 
    m_anzahlelemente-=e-a+1;
    for(i=a;i<m_anzahlelemente;i++){
      m_array[i]=m_array[i+(e-a)+1];
    }
  }

  Typ* GetBuffer(){return m_array;}

  void SetBlockSize(long i){m_blocklen=i;}

  void SetBuffer(Typ* data, long n){ // aufeigene Verantwortung
    delete m_array;
    m_array = data;
    m_anzahlelemente = n;
    m_buflen = m_anzahlelemente;
  }

  void SetLength(long l){
    SetBufferLength(l);
    m_anzahlelemente=l;
  }

  short SetBufferLength(long l){
    if(l>m_buflen){
      return MakeLonger((l-m_buflen)+m_blocklen);
    }
    return 0;
    //  if(l>m_anzahlelemente){m_anzahlelemente=l;}
  }

  short InsertAtPos(long l,const Typ& t){
     long i;
     if(l>=m_anzahlelemente) return 0;
     if (m_anzahlelemente >= m_buflen){MakeLonger(m_blocklen+1);}
     for(i=m_anzahlelemente;i>l;i--){m_array[i]=m_array[i-1];}
     m_array[l]=t;  
     m_anzahlelemente++;
     return 1;
  }


  void RemoveElementAtPos(long l)
  {
    assert(l<m_buflen);
    long i; 
    m_anzahlelemente--;
    //kein memcpy um, damit das ganze auch für arrays von Klassen funktioniert.
    //memcpy(&m_array[i],&m_array[i+1],(m_anzahlelemente-l)*sizeof(Typ));
    for(i=l;i<m_anzahlelemente;i++){
      m_array[i]=m_array[i+1];
    }
  }


  short RemoveElement(Typ& t){
    long i; 
    for(i=0;i<m_anzahlelemente;i++){
      if(m_array[i]==t){
        RemoveElementAtPos(i);
        return true;
      }
    }
    return false;
  }

  void Empty(){
    m_anzahlelemente=0;
  }

  void OptimizeMemory(){
    long i;
    Typ* tmparray=new Typ[m_anzahlelemente];
    m_buflen=m_anzahlelemente;
    for(i=0;i<m_anzahlelemente;i++){tmparray[i]=m_array[i];}
    delete [] m_array;
    m_array=tmparray;
  }

  long GetIndexOf(const Typ& t) const{ 
    for(long i=0;i<m_anzahlelemente;i++){if(m_array[i]==t){return long(i);}}
    return -1;
  }



  short Contain(const Typ& t)
  {
    for(long i=0;i<m_anzahlelemente;i++){
      if(m_array[i]==t){return 1;}
    }
    return 0;
  }


  long Count(const Typ& t)
  {
    long j=0;
    for(long i=0;i<m_anzahlelemente;i++){
      if(m_array[i]==t){j++;}
    }
    return j;
  }

  void SetBlankAndClear(const Typ& bl)
  {
    m_blank=bl;
    long i;
    for(i=0;i<m_buflen;i++){m_array[i]=m_blank;}
  }

  void SetBlankAndClear(const Typ& bl,long l){
    m_blank=bl;
    if(l>m_anzahlelemente) m_anzahlelemente=l;
    SetBufferLength(l);
    long i;
    for(i=0;i<m_buflen;i++){m_array[i]=m_blank;}
  }

protected:
  int MakeLonger(unsigned int b){
     Typ *Ablage;
     long i,lAlt;
     Ablage = m_array;
     lAlt=m_buflen;
     m_buflen+=b;
     m_array = new Typ[m_buflen]; assert(m_array);
     if(m_array==0) return 0;
     for(i=0;i<lAlt;i++){m_array[i]=Ablage[i];}
     for(i=lAlt;i<m_buflen;i++){m_array[i]=m_blank;}
     delete [] Ablage;
     return 1;
  }

};


template <class Typ>
class GridC
{
public:
  GridC()
  {
     int i,j;
     m_left=0;
     m_right=0;
     m_top=0;
     m_bottom=0;
     m_width=1;
     m_height=1;
     m_array=new Typ* [m_width];
     for(i=0;i<m_width;i++){
        m_array[i]=new Typ[m_height];
        for(j=0;j<m_height;j++){m_array[i][j]=m_blank;}
     }
  }


  GridC(long l, long b, long r, long t,const Typ& bl)
  {
     int i,j;
     m_left=l;
     m_right=r;
     m_top=t;
     m_bottom=b;
     m_width=r-l+1;assert(m_width>0);
     m_height=t-b+1;assert(m_height>0);
     m_blank=bl;
     m_array=new Typ* [m_width];
     for(i=0;i<m_width;i++){
        m_array[i]=new Typ[m_height];
        for(j=0;j<m_height;j++){m_array[i][j]=m_blank;}
     }
  }

  ~GridC(){
     int i;
     for(i=0;i<m_width;i++){delete [] m_array[i];}
     delete m_array;
  }


  const Typ& get(long i,long j) const{
     if((i>m_right)||(i<m_left)||(j>m_top)||(j<m_bottom)) return m_blank; 
     return m_array[i-m_left][j-m_bottom];
  }


  void set(long n,long m,const Typ& t){
    int i,j;
    if( ((n<m_left)||(n>m_right))&&(m<=m_top)&&(m>=m_bottom) ){
      Typ **ablage;
      long leftOld=m_left;
      //long rightOld=m_right;
      long widthOld=m_width;
      long s1,s2;
      ablage=m_array;
      if(n<m_left){m_left=n;s1=leftOld-n;s2=widthOld;}else{m_right=n;s1=0;s2=0;}
      m_width=m_right-m_left+1;
      m_array = new Typ* [m_width]; 
      for(i=0;i<widthOld;i++){m_array[i+s1]=ablage[i];}
      for(i=widthOld;i<m_width;i++){
        m_array[i]=new Typ[m_height];
        for(j=0;j<m_height;j++){m_array[i-s2][j]=m_blank;}
      }  
      delete ablage;
    }else{
      if( ((m>m_top)||(m<m_bottom))&&(n>=m_left)&&(n<=m_right) ){
      long heightOld=m_height;
      //long topOld=m_top;
      long bottomOld=m_bottom;
      long s1,s2;
      if(m<m_bottom){m_bottom=m;s1=bottomOld-m;s2=heightOld;}else{m_top=m;s1=0;s2=0;}
      m_height=m_top-m_bottom+1;
      for(i=0;i<m_width;i++){
        Typ *ablage;
        ablage=m_array[i];
        m_array[i]= new Typ[m_height];
        for(j=0;j<heightOld;j++){m_array[i][j+s1]=ablage[j];}
        for(j=heightOld;j<m_height;j++){m_array[i][j-s2]=m_blank;}
        delete [] ablage;
      }
    }else{
      if((m>m_top)||(m<m_bottom)||(n<m_left)||(n>m_right)){
      long leftOld=m_left;
      long bottomOld=m_bottom;
      long widthOld=m_width;
      long heightOld=m_height;
      Typ **ablage;
      ablage=m_array;
      if(m>m_top){m_top=m;}
      if(m<m_bottom){m_bottom=m;}
      if(n<m_left){m_left=n;}
      if(n>m_right){m_right=n;}
      m_width=m_right-m_left+1;
      m_height=m_top-m_bottom+1;
      m_array = new Typ* [m_width];
      for(i=0;i<m_width;i++){
        m_array[i]=new Typ[m_height];
        for(j=0;j<m_height;j++){m_array[i][j]=m_blank;}
      }
      for(i=0;i<widthOld;i++){
        for(j=0;j<heightOld;j++){
          m_array[i+leftOld-m_left][j+bottomOld-m_bottom]=ablage[i][j];
        }
      }
      for(i=0;i<widthOld;i++){delete [] ablage[i];}
      delete ablage;
    }}}
     m_array[n-m_left][m-m_bottom]=t;
  }

  void SetBlankAndClear(const Typ& bl){
     int i,j;
     m_blank=bl;
     for(i=0;i<m_width;i++){
        for(j=0;j<m_height;j++){m_array[i][j]=m_blank;}
     }
  }

protected:
   Typ m_blank;
   long m_left,m_bottom,m_right,m_top;
   long m_width,m_height;
   Typ **m_array;
   short m_bFirstSet;
};

typedef ArrayC<char> ByteArrayC;

OAW_END_NAMESPACE

#endif

---