src/array.h

/***************************************************************************
                          array.h  -  description
                             -------------------
    begin                : Mond Dec 29 2003
    copyright            : (C) 2003 by Lynn Hazan
    email                : lynn.hazan@myrealbox.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef ARRAY_H
#define ARRAY_H

//C include files
#include <cstring>

//General C++ include files
#include <iostream>
using namespace std;

template <class T>
class Array {
public:
     inline Array(long nbOfRows,long nbOfColumns){
    nbColumns = nbOfColumns;
    nbRows = nbOfRows;
    array = new T[nbRows * nbColumns];
  };
  
  inline Array():nbColumns(0),nbRows(0),array(0L){};
  
     inline ~Array(){
    delete []array;
  };
  inline void setSize(long nbOfRows,long nbOfColumns){
    nbColumns = nbOfColumns;
    nbRows = nbOfRows;
    if(array) delete[]array;
    array = new T[nbRows * nbColumns];
  };
  
  inline T operator()(long row,long column) const{
    return array[(row - 1)*nbColumns + (column - 1)];
  };
  inline T& operator()(long row,long column){
    return array[(row - 1)*nbColumns + (column - 1)];
  };
  inline T& operator[](long position){
    return array[position];
  };
  inline long nbOfRows() const{
    return nbRows;
  };
  inline long nbOfColumns() const{
    return nbColumns;
  };


  inline void copyAndPrependColumn(Array& source){
    for(long i = 0;i < nbRows;++i)
      memcpy(&array[i * nbColumns + 1],&(source.array[i * source.nbColumns]),
             source.nbColumns * sizeof(T));
  };

  inline void copySubset(Array& source,long lastColumnToCopy){   
    for(long i = 0;i < nbRows;++i)
      memcpy(&array[i * lastColumnToCopy],&(source.array[i * source.nbColumns]),
             lastColumnToCopy * sizeof(T));
  };

  inline void copySubset(Array& source,long firstColumnToCopy,long lastColumnToCopy,long startingColumn){
    long nbColumnsToCopy = lastColumnToCopy - firstColumnToCopy + 1;
    for(long i = 0;i < nbRows;++i)
      memcpy(&array[i * nbColumns + startingColumn - 1],&(source.array[i * source.nbColumns + (firstColumnToCopy - 1)]),
             nbColumnsToCopy * sizeof(T));
  };
  
  inline void fillWithZeros(){
   memset(array,0,static_cast<unsigned int>(nbRows * nbColumns) * sizeof(T));   
  };


  inline Array<T>& operator=(const Array<T>& source){
   if(&source != this){
    nbColumns = source.nbColumns;
    nbRows = source.nbRows;   
    if(array) delete[]array;
    array = new T[nbRows * nbColumns];
    memcpy(array,source.array,nbRows * nbColumns * sizeof(T));
   } 
    return *this;
  };
    
protected:
  long nbColumns;
  long nbRows;
  T* array;

};


template <class T>
class pArray : public Array<T>{

protected:
  using Array<T>::nbColumns;
  using Array<T>::nbRows;
  using Array<T>::array;

public:
     inline pArray(){};
     inline ~pArray(){};


  inline void copyAndPrependColumn(pArray& source){
   for(long i = 0;i < nbRows;++i){
    for(int j = 0;j<nbColumns;++j){
     array[i*nbColumns + (j + 1)] = source.array[i*source.nbColumns + j];
    }
   }
  };

  inline void copySubset(pArray& source,long lastColumnToCopy){
 for(long i = 0;i < nbRows;++i){
    for(int j = 0;j<lastColumnToCopy;++j){
     array[i*lastColumnToCopy + j] = source.array[i*source.nbColumns + j];
    }
   }
  };

  inline void copySubset(pArray& source,long firstColumnToCopy,long lastColumnToCopy,long startingColumn){
   long nbColumnsToCopy = lastColumnToCopy - firstColumnToCopy + 1;
    for(long i = 0;i < nbRows;++i){
    for(int j = 0;j< nbColumnsToCopy;++j){
     array[i*nbColumns + (startingColumn - 1) + j] = source.array[i*source.nbColumns + (firstColumnToCopy - 1) + j];
    }
   }
  };
  
   
  inline pArray<T>& operator=(pArray<T>& source){
    nbColumns = source.nbColumns;
    nbRows = source.nbRows;
    if(array) delete[]array;
    array = new T[nbRows * nbColumns];
    for(int i = 0;i<nbRows;++i){
      for(int j = 0;j<nbColumns;++j){
      array[i*nbColumns + j] = source.array[i*nbColumns + j];
     } 
    }
    return *this;
  };

  inline pArray<T> operator=(pArray<T>& source) const{
    nbColumns = source.nbColumns;
    nbRows = source.nbRows;
    if(array) delete[]array;
    array = new T[nbRows * nbColumns];
    for(int i = 0;i<nbRows;++i){
     for(int j = 0;j<nbColumns;++j){
      array[i*nbColumns + j] = source.array[i*nbColumns + j];
     }
    }
    return *this;
  };
};

#endif

---