Basic2DArray.h

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

//
// Basic2DArray.h
//
#ifndef __Basic2DArray_h
#define __Basic2DArray_h

#ifdef __GNUC__
#pragma interface
#endif

#ifdef NON_ANSI
#include <iostream.h>
#else
#include <iostream>
using namespace std;
#endif
#ifndef ANSI_HDRS
#include <stdlib.h>
#include <assert.h>
#else
#include <cstdlib>
#include <cassert>
#endif
#include "_generic.h"
#include "BasicArray.h"

#ifndef SWIG

#if !defined(TwoDArraySanityChecking)
#define TwoDArraySanityChecking    1
#endif

template <class T>
class UTILIB_API Basic2DArray;

template <class T>
class UTILIB_API Simple2DArray;

template <class T>
class UTILIB_API Num2DArray;


template <class T>
class UTILIB_API Basic2DArrayRep {
 
  friend class Basic2DArray<T>;
  friend class Simple2DArray<T>;
  friend class Num2DArray<T>;

protected:
 
  Basic2DArrayRep() {ref=1; Nrows=0; Ncols=0; Data=0;}
  T** Data; 
  int ref;
  size_type Nrows;
  size_type Ncols;
  EnumDataOwned own_data;
  EnumDataOwned own_ptrs;

};
#endif // SWIG


#ifdef SWIG
template <class T>
class Basic2DArray
#else
template <class T>
class UTILIB_API Basic2DArray
#endif
{
public:

  Basic2DArray()
                {construct(0,0,(T*)0);}
  Basic2DArray(const BasicArray<T>& array, const size_type nrows=1, 
                const EnumDataOwned own=DataNotOwned)
                {construct(nrows,array.size()/nrows,array,own);}
  Basic2DArray(const size_type nrows, const size_type ncols, T *d=((T*)0), 
                const EnumDataOwned own=DataNotOwned)
                {construct(nrows,ncols,d,own);}
  Basic2DArray(const size_type nrows, const size_type ncols, 
                const BasicArray<T>& array, 
                const EnumDataOwned own=DataNotOwned)
                {construct(nrows,ncols,array,own);}
  Basic2DArray(const Basic2DArray& array)
                {construct(array.a->Nrows,array.a->Ncols,array.a->Data,
                                AcquireOwnership);}

  virtual ~Basic2DArray()
        {free();}

  int resize(const size_type nrows, const size_type ncols);
  size_type nrows() const
        {return a->Nrows;}
  size_type ncols() const
        {return a->Ncols;}
  operator T** () const
        {return a->Data;}
  T** data() const
        {return a->Data;}
  int nrefs() const
        {return a->ref;}
  T* operator[](const int i);
  T* operator[](const int i) const;
  T* operator[](const size_type i);
  T* operator[](const size_type i) const;
  T& operator()(const size_type row, const size_type col);
  const T& operator()(const size_type row, const size_type col) const;

  Basic2DArray<T>& operator=(const Basic2DArray<T>& array);
  Basic2DArray<T>& operator&=(const Basic2DArray<T>& array);
  Basic2DArray<T>& operator<<(const Basic2DArray<T>& array);
  Basic2DArray<T>& operator=(const T& val);
  Basic2DArray<T>& operator=(const BasicArray<T>& val);

  Basic2DArray<T>& set_data(const size_type len, T* data,
                                const EnumDataOwned o=DataNotOwned);
  Basic2DArray<T>& set_data(const BasicArray<T>& array,
                                const EnumDataOwned o=DataNotOwned)
                {return set_data(array.size(),array,o);}

/* BUG??  Where are these defined?
  friend Basic2DArray<T> T(const BasicArray<T>& array);
  friend Basic2DArray<T> T(const Basic2DArray<T>& array);
*/

protected:

  Basic2DArrayRep<T>* a;
  void construct(const size_type nrows, const size_type ncols, T *d, 
                const EnumDataOwned o=DataNotOwned);
  void construct(const size_type nrows, const size_type ncols, T** d, 
                const EnumDataOwned o=DataNotOwned);
  void free();

};


template <class T>
inline T* Basic2DArray<T>::operator[](const int idx)
{
#if (TwoDArraySanityChecking==1)
if ((idx < 0) || ((size_type)idx >= a->Nrows))
   ErrAbort(errmsg("Basic2DArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,a->Nrows));
#endif
 
return a->Data[idx];
}
 
 
template <class T>
inline T* Basic2DArray<T>::operator[](const int idx) const
{
#if (TwoDArraySanityChecking==1)
if ((idx < 0) || ((size_type)idx >= a->Nrows))
   ErrAbort(errmsg("Basic2DArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,a->Nrows));
#endif
 
return a->Data[idx];
}


template <class T>
inline T* Basic2DArray<T>::operator[](const size_type idx)
{
#if (TwoDArraySanityChecking==1)
if (idx >= a->Nrows)
   ErrAbort(errmsg("Basic2DArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,a->Nrows));
#endif
 
return a->Data[idx];
}
 
 
template <class T>
inline T* Basic2DArray<T>::operator[](const size_type idx) const
{
#if (TwoDArraySanityChecking==1)
if (idx >= a->Nrows)
   ErrAbort(errmsg("Basic2DArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,a->Nrows));
#endif
 
return a->Data[idx];
}


template <class T>
inline T& Basic2DArray<T>::operator()(const size_type row, const size_type col)
{
#if (TwoDArraySanityChecking==1)
if ((row >= a->Nrows) || (col >= a->Ncols))
   ErrAbort(errmsg("Basic2DArray<T>::operator() : iterator out of range. %dx%d not in %dx%d",row,col,a->Nrows,a->Ncols));
#endif
 
return a->Data[row][col];
}
 
 
template <class T>
inline const T& Basic2DArray<T>::operator()(const size_type row, const size_type col) const
{
#if (TwoDArraySanityChecking==1)
if ((row >= a->Nrows) || (col >= a->Ncols))
   ErrAbort(errmsg("Basic2DArray<T>::operator() : iterator out of range. %dx%d not in %dx%d",row,col,a->Nrows,a->Ncols));
#endif
 
return a->Data[row][col];
}


template <class T>
void Basic2DArray<T>::construct(const size_type nrows, const size_type ncols, T * d, 
                                        const EnumDataOwned o)
{
a = new Basic2DArrayRep<T>;
assert(a != 0);

a->Nrows = nrows;
a->Ncols = ncols;
if (d == NULL) {
   if (nrows > 0) {
      a->Data = new T* [nrows] ;
      assert(a != 0);
      for (size_type i=0; i<nrows; i++) {
         a->Data[i] = new T [ncols] ;
         assert(a->Data[i] != 0);
         }
      }
   else
      a->Data = NULL;
   a->own_ptrs = AcquireOwnership;
   a->own_data = AcquireOwnership;
   }

else {
   if (o == AcquireOwnership) {
      if (nrows > 0)  {
         a->Data = new T* [nrows] ;
         assert(a->Data != 0);
         for (size_type i=0; i<nrows; i++) {
            a->Data[i] = new T [ncols] ;
            assert(a->Data[i] != 0);
            }
         size_type ndx=0;
         for (size_type ii=0; ii<nrows; ii++)
           for (size_type jj=0; jj<ncols; jj++)
             a->Data[ii][jj] = d[ndx++];
         }
      else
         a->Data = NULL;
      a->own_ptrs = AcquireOwnership;
      a->own_data = AcquireOwnership;
      }
   else {
      if (nrows > 0)  {
         a->Data = new T* [nrows] ;
         assert(a->Data != 0);
         T* tmp = d;
         for (size_type i=0; i<ncols; i++) {
            a->Data[i] = tmp;
            tmp+= ncols;
            }
         }
      else
         a->Data = NULL;
      a->own_ptrs = AcquireOwnership;
      a->own_data = DataNotOwned;
      }
   }
}


template <class T>
void Basic2DArray<T>::construct(const size_type nrows, const size_type ncols, T **d, 
                                        const EnumDataOwned o)
{
a = new Basic2DArrayRep<T>;
assert(a != 0);

a->Nrows = nrows;
a->Ncols = ncols;
if (d == NULL) {
   if (nrows > 0) {
      a->Data = new T* [nrows] ;
      assert(a != 0);
      for (size_type i=0; i<nrows; i++) {
         a->Data[i] = new T [ncols] ;
         assert(a->Data[i] != 0);
         }
      }
   else
      a->Data = NULL;
   a->own_ptrs = AcquireOwnership;
   a->own_data = AcquireOwnership;
   }

else {
   if (o == AcquireOwnership) {
      if (nrows > 0)  {
         a->Data = new T* [nrows] ;
         assert(a->Data != 0);
         for (size_type i=0; i<nrows; i++) {
            a->Data[i] = new T [ncols] ;
            assert(a->Data[i] != 0);
            }
         for (size_type ii=0; ii<nrows; ii++)
           for (size_type jj=0; jj<ncols; jj++)
             a->Data[ii][jj] = d[ii][jj];
         }
      else
         a->Data = NULL;
      a->own_ptrs = AcquireOwnership;
      a->own_data = AcquireOwnership;
      }
   else {
      a->Data=d;
      a->own_ptrs = DataNotOwned;
      a->own_data = DataNotOwned;
      }
   }
}


template <class T>
void Basic2DArray<T>::free()
{
if (--a->ref == 0) {
   if ((a->Data) && (a->Nrows>0)) {
      if (a->own_data && (a->Ncols > 0)) {
         for (size_type i=0; i<a->Nrows; i++)
           delete [] a->Data[i];
         }
      if (a->own_ptrs)
         delete [] a->Data;
      }
   delete a;
   }
}


template <class T>
int Basic2DArray<T>::resize(const size_type nrows, const size_type ncols)
{
//
// Maybe we get lucky.
//
if ((ncols == a->Ncols) && (nrows == a->Nrows))
   return OK;

//
// Need to completely replace old data.
//
if ((ncols != a->Ncols) && (nrows != a->Nrows)) {
   //
   // Delete old data (if owned)
   //
   if ((a->Data) && (a->Nrows>0)) {
      if (a->own_data && (a->Ncols > 0)) {
         for (size_type i=0; i<a->Nrows; i++)
           delete [] a->Data[i];
         }
      if (a->own_ptrs)
         delete [] a->Data;
      }
   //
   // Make new data
   //
   if (nrows > 0) {
      a->Data = new T* [nrows] ;
      assert(a != 0);
      for (size_type i=0; i<nrows; i++) {
         a->Data[i] = new T [ncols] ;
         assert(a->Data[i] != 0);
         }
      }
   else
      a->Data = NULL;
   a->own_ptrs = AcquireOwnership;
   a->own_data = AcquireOwnership;
   a->Nrows = nrows;
   a->Ncols = ncols;
   return OK;
   }

//
// We need to simply resize the number of rows.
//
if (nrows != a->Nrows) {
   T **d=NULL;
   if (nrows > 0) {
      d = new T* [nrows];
      assert(d != 0);
      // 
      // Note:  the new memory is not initialized beyond what the constructors
      // do.
      //
      if (a->Nrows > 0) {
         for (size_type i=0; i<min(nrows,a->Nrows); i++)
           d[i] = a->Data[i];
         }
      }
 
   if (a->Data && a->own_ptrs && (a->Nrows > 0))
      delete [] a->Data;
 
   a->Data = d;
   a->Nrows = nrows;
   }

//
// We need to simply resize the number of columns
//
if (ncols != a->Ncols) {
   if (ncols > 0) {
      for (size_type j=0; j<a->Nrows; j++) {
        T* d=NULL;
        d = new T [ncols];
        assert(d != 0);
        // 
        // Note:  the new memory is not initialized beyond what the constructors
        // do.
        //
        if (a->Ncols > 0) {
           for (size_type i=0; i<min(ncols,a->Ncols); i++)
             d[i] = a->Data[j][i];
           }
        if (a->Data && a->own_data && (a->Ncols > 0))
           delete [] a->Data[j];
        a->Data[j] = d;
        }
      }
   else 
      if (a->Data && a->own_data && (a->Ncols > 0))
         for (size_type i=0; i<a->Nrows; i++) {
           delete [] a->Data[i];
           a->Data[i] = NULL;
           }
 
   a->Ncols = ncols;
   }

return OK;
}


template <class T>
Basic2DArray<T>& Basic2DArray<T>::operator=(const Basic2DArray<T>& array)
{
//ErrAbort("Basic2DArray<T>::operator= : has been temporarily disabled during the transition to the new vector classes.");

if (this != &array) {
   free();
   construct(array.nrows(),array.ncols(),array.data(),AcquireOwnership);
   }
return *this;
}


template <class T>
Basic2DArray<T>& Basic2DArray<T>::operator<<(const Basic2DArray<T>& array)
{
if (array.a == a)
   return *this;
if ((array.a->Nrows != a->Nrows) || (array.a->Ncols != a->Ncols))
   ErrAbort(errmsg("Basic2DArray<T>::operator<< : Unequal vector matrices %dx%d and %dx%d.",a->Nrows,a->Ncols,array.a->Nrows,array.a->Ncols));
 
for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    a->Data[i][j] = array.a->Data[i][j];
 
return *this;
}



template <class T>
Basic2DArray<T>& Basic2DArray<T>::operator&=(const Basic2DArray<T>& array)
{
if (array.a == a) return *this;

free();
a = array.a;
a->ref++;
return *this;
}



template <class T>
Basic2DArray<T>& Basic2DArray<T>::operator=(const T& val)
{
for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    a->Data[i][j] = ( T ) val;
return *this;
}



template <class T>
Basic2DArray<T>& Basic2DArray<T>::operator=(const BasicArray<T>& val)
{
if (a->Ncols != val.size())
   ErrAbort(errmsg("Basic2DArray<T>::operator= : Array length does not equal the 2DArray columns %d and %d",val.size(),a->Ncols));

for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    a->Data[i][j] = val[j];
return *this;
}

template <class T>
Basic2DArray<T>& Basic2DArray<T>::set_data(const size_type len, T * data, const EnumDataOwned o)
{
#if TwoDArraySanityChecking==1
if ( (nrows()*ncols()) != len)
   ErrAbort(errmsg("Basic2DArray<T>::set_data : bad vector size %d != %d.",
                        (nrows()*ncols()),len));
#endif

if (a->own_data && (a->Ncols > 0)) {
   for (size_type i=0; i<a->Nrows; i++)
     delete [] a->Data[i];
   }
size_type ndx=0;
for (size_type i=0; i<a->Nrows; i++) {
  a->Data[i] = &(data[ndx]);
  ndx += a->Ncols;
  }

//
// BUG: I need to fix the model of ownership here.
//
a->own_data = DataNotOwned;
return *this;
}
#endif