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

//
// SimpleArray.h
//
#ifndef __SimpleArray_h
#define __SimpleArray_h

#ifdef NON_ANSI
#include <iostream.h>
#else
#include <iostream>
using namespace std;
#endif

#if !defined (ANSI_HDRS)
#include <stdlib.h>
#include <assert.h>
#else
#include <cstdlib>
#include <cassert>
#endif


#include "_generic.h"
#include "BasicArray.h"
#include "PackBuf.h"

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

public:

  SimpleArray() : BasicArray<T>() {}
#ifndef NON_ANSI
  explicit 
#endif
  SimpleArray(const int len, T *d=((T*)0), const EnumDataOwned o=DataNotOwned)
                : BasicArray<T>(len,d,o) {}
  SimpleArray(const SimpleArray<T>& array)
                : BasicArray<T>(array) {}

  SimpleArray<T>& operator=(const SimpleArray<T>& array)
                {BasicArray<T>::operator=(array); return *this;}
  SimpleArray<T>& operator=(const T& val)
                {BasicArray<T>::operator=(val); return *this;}
  virtual ~SimpleArray() {}
 
  int  operator==(const T& val) const;
  int  operator!=(const T& val) const;
  int  operator==(const SimpleArray<T>& array) const;
  int  operator!=(const SimpleArray<T>& array) const;
  int  compare(const SimpleArray<T>& array) const;

  virtual int write(ostream& os) const;
  virtual int read(istream& is);
  virtual int write(PackBuffer& os) const;
  virtual int read(UnPackBuffer& is);

};

 
#ifndef SWIG

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



template <class T>
int SimpleArray<T>::operator==(const T& val) const
{
T* tmp = Data;
size_type mylen = size();
for (size_type i=0; i<mylen; i++)
  if (tmp[i] != val)
     return 0;
 
return 1;
}


template <class T>
int SimpleArray<T>::operator!=(const T& val) const
{
T* tmp = Data;
size_type mylen = size();
for (size_type i=0; i<mylen; i++)
  if (tmp[i] != val)
     return 1;
 
return 0;
}
 
 

template <class T>
int SimpleArray<T>::operator==(const SimpleArray<T>& array) const
{
if (array.Data == Data)
   return 1;
if (array.size() != size())
   return 0;
 
T* tmp = Data;
T* arraytmp = array.Data;
size_type mylen = size();
for (size_type i=0; i<mylen; i++)
  if (tmp[i] != arraytmp[i])
     return 0;
 
return 1;
}


template <class T>
int SimpleArray<T>::compare(const SimpleArray<T>& array) const
{
if (array.Data == Data)
   return 0;

size_type mylen = size();
size_type arraylen = array.size();
if (arraylen > mylen)   
   return 1;
if (arraylen < mylen)   
   return -1;
 
T* tmp = Data;
T* arraytmp = array.Data;
for (size_type i=0; i<mylen; i++) {
  if (tmp[i] != arraytmp[i]) {
     if (tmp[i] < arraytmp[i]) return -1;
     else return 1;
     }
  }
 
return 0;
}


template <class T>
int SimpleArray<T>::operator!=(const SimpleArray<T>& array) const
{
if (array.Data == Data)
   return 0;

size_type mylen = size();
if (array.size() != mylen)
   return 1;
 
T* tmp = Data;
T* arraytmp = array.Data;
for (size_type i=0; i<mylen; i++)
  if (tmp[i] != arraytmp[i])
     return 1;
 
return 0;
}


template <class T>
inline int SimpleArray<T>::write(PackBuffer& os) const
{
size_type mylen = size();
os << mylen;
T* tmp = Data;
for (size_type i=0; i<mylen; i++, tmp++)
  os << *tmp;
return OK;
}


template <class T>
inline int SimpleArray<T>::write(ostream& os) const
{
size_type mylen = size();
os << mylen << " : ";
T* tmp = Data;
for (size_type i=0; i<mylen; i++, tmp++)
  os << *tmp << " ";
return OK;
}


template <class T>
inline int SimpleArray<T>::read(UnPackBuffer& is)
{
size_type len;
is >> len;
resize(len);

T* tmp = Data;
for (size_type i=0; i<len; i++, tmp++)
  is >> *tmp;

return OK;
}



template <class T>
inline int SimpleArray<T>::read(istream& is)
{
size_type len;
is >> len;
resize(len);

char c;
is >> c;

T* tmp = Data;
for (size_type i=0; i<len; i++, tmp++)
  is >> *tmp;

return OK;
}

template <class T>
inline int compare(const SimpleArray<T>& first, const SimpleArray<T>& second)
{ return first.compare(second);}
#endif