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

//
// Simple2DArray.h
//
#ifndef __Simple2DArray_h
#define __Simple2DArray_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 "Basic2DArray.h"
#include "PackBuf.h"

#if !defined(Simple2DArrayT)
#ifdef USING_TEMPLATES
#define Simple2DArrayT(T) Simple2DArray<##T##>
#else
#define Simple2DArrayT(T) Simple2DArray_##T
#endif
#endif


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

  Simple2DArray()  
                : Basic2DArray<T>() {}
  Simple2DArray(const BasicArray<T>& array, const size_type nrows=1,
                const EnumDataOwned own=DataNotOwned)
                : Basic2DArray<T>(array,nrows,own) {}
  Simple2DArray(const size_type nrows, const size_type ncols, T *d=((T*)0),
                const EnumDataOwned own=DataNotOwned)
                : Basic2DArray<T>(nrows,ncols,d,own) {}
  Simple2DArray(const size_type nrows, const size_type ncols, const BasicArray<T>& array,
                const EnumDataOwned own=DataNotOwned)
                : Basic2DArray<T>(nrows,ncols,array,own) {}
  Simple2DArray(const Simple2DArray<T>& array)
                : Basic2DArray<T>(array) {}
 
  Simple2DArray<T>& operator=(const Simple2DArray<T>& array)
                {Basic2DArray<T>::operator=(array); return *this;}
  Simple2DArray<T>& operator=(const T& val)
                {Basic2DArray<T>::operator=(val); return *this;}

  int  operator== (const Simple2DArray<T>& array) const;
  int  operator!= (const Simple2DArray<T>& array) const;
  int  compare(const Simple2DArray<T>& array) const;
/* BUG!  Let's see where this is used!
  int  operator<(const Simple2DArray<T>& array) const
                {return compare(array);}
*/

  virtual int write(ostream& output) const;       
  virtual int read(istream& input);              
  virtual int write(PackBuffer& output) const;  
  virtual int read(UnPackBuffer& input);       

};

 

template <class T>
inline UTILIB_API ostream& operator<<(ostream& output, const Simple2DArray<T>& array)
{ array.write(output); return(output); }
 
template <class T>
inline UTILIB_API istream& operator>>(istream& input, Simple2DArray<T>& array)
{ array.read(input); return(input); }
 
template <class T>
inline UTILIB_API PackBuffer& operator<<(PackBuffer& output, const Simple2DArray<T>& array)
{ array.write(output); return(output); }
 
template <class T>
inline UTILIB_API UnPackBuffer& operator>>(UnPackBuffer& input, Simple2DArray<T>& array)
{ array.read(input); return(input); }



template <class T>
int Simple2DArray<T>::compare(const Simple2DArray<T>& array) const
{
if (array.a == a)
   return 0;
 
for (size_type i=0; i<min(a->Nrows,array.a->Nrows); i++)
  for (size_type j=0; j<min(a->Ncols,array.a->Nrows); j++)
    if (a->Data[i][j] < array.a->Data[i][j])
       return -1;
    else if (a->Data[i][j] > array.a->Data[i][j])
       return 1;

if ((array.a->Nrows == a->Nrows) && (array.a->Ncols == a->Ncols))
   return 0;

if ((array.a->Nrows < a->Nrows) || (array.a->Nrows < a->Nrows))
   return -1;
return 1;
}


template <class T>
int Simple2DArray<T>::operator==(const Simple2DArray<T>& array) const
{
if (array.a == a)
   return 1;
if ((array.a->Nrows != a->Nrows) || (array.a->Ncols != a->Ncols))
   return 0;
 
for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    if (a->Data[i][j] != array.a->Data[i][j])
       return 0;
 
return 1;
}


template <class T>
int Simple2DArray<T>::operator!=(const Simple2DArray<T>& array) const
{
if ((array.a->Nrows != a->Nrows) || (array.a->Ncols != a->Ncols))
   return 1;
 
for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    if (a->Data[i][j] != array.a->Data[i][j])
       return 1;
 
return 0;
}


template <class T>
int Simple2DArray<T>::write(PackBuffer& os) const
{
os << a->Nrows << a->Ncols;
if (a->Data) {
   for (size_type i=0; i<a->Nrows; i++)
     for (size_type j=0; j<a->Ncols; j++)
       os << a->Data[i][j];
   }
return OK;
}


template <class T>
int Simple2DArray<T>::write(ostream& os) const
{
os << a->Nrows << " " << a->Ncols << ": ";
if (a->Data) {
   for (size_type i=0; i<a->Nrows; i++) {
     for (size_type j=0; j<a->Ncols; j++)
       os << a->Data[i][j] << " ";
     os << endl;
     }
   }
return OK;
}


template <class T>
int Simple2DArray<T>::read(UnPackBuffer& is)
{
size_type nrows,ncols;
is >> nrows >> ncols;
resize(nrows,ncols);
for (size_type i=0; i<a->Nrows; i++)
  for (size_type j=0; j<a->Ncols; j++)
    is >> a->Data[i][j];

return OK;
}



template <class T>
int Simple2DArray<T>::read(istream& /*is*/)
{
free();

//
// TODO
//

return OK;
}
#endif