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

//
// BasicArray.h
//
#ifndef __BasicArray_h
#define __BasicArray_h

#ifdef NON_ANSI
#include <iostream.h>
#else
#include <iostream>
using namespace std;
#endif
#ifndef ANSI_HDRS
#include <stdlib.h>
#else
#include <cstdlib>
#endif
#include "_generic.h"
#include "_math.h"
#include "errmsg.h"
#include "ClassRef.h"


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

template <class T>
class UTILIB_API BasicArray;


template <class T>
class BasicArray {

  friend class ArrayRef<T,BasicArray<T> >;

public:

  BasicArray()
        {construct(0,(T*)0,DataNotOwned);}
#ifndef NON_ANSI
  explicit 
#endif
  BasicArray(const size_type mylen, T *d=((T*)0), 
                        const EnumDataOwned o=DataNotOwned)
        {construct(mylen,d,o);}
  BasicArray(const BasicArray<T>& array)
        {construct(array.size(), array.data(), AcquireOwnership);}
  virtual ~BasicArray()
        {free();}

  int shared_mem() const
        {return (shared != NULL);}
  virtual int resize(const size_type newl);
  size_type size() const
        { return Len; }
  int len() const
        {return (int)size();}
  T* data() const
        { return Data; }
#ifndef SWIG

  operator T* () const
        { return Data; }
#endif

  int nrefs() const
        {if (shared) return shared->ref; return 0;}
  T & operator[](const int i);
  const T & operator[](const int i) const;
  T & operator[](const size_type i);
  const T & operator[](const size_type i) const;

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

  BasicArray<T>& set_data(const size_type len, T *data,
                                const EnumDataOwned o=DataNotOwned);
  BasicArray<T>& set_data(const BasicArray<T>& vec, const size_type start,
                                const size_type newlen);
  BasicArray<T>& set_data(const BasicArray<T>& vec, const size_type start=0)
                {return set_data(vec,start,vec.size()-start);}
  BasicArray<T>& set_subvec(const size_type start, const size_type len,
                                const BasicArray<T>& datavec, 
                                const size_type offset=0);
#ifndef SWIG

  BasicArray<T>& at(const size_type start, const size_type newlen,
                                BasicArray<T>* array = (BasicArray<T>*)0) const;
  BasicArray<T>& at(const size_type start=0) const
                {return at(start, size()-start);}
#endif

  void append(T& element)
        {
        size_type tmp=Len;
        resize(tmp+1);
        (*this)[tmp] = element;
        }

  void append(BasicArray<T>& vec)
        {
        size_type tmp=Len;
        resize(tmp+vec.size());
        for (size_type i=tmp; i<Len; i++)
          (*this)[i] = vec[i-tmp];
        }

  static void set_ref_limit(const int num)
        { ClassRef<BasicArray<T> >::num_refs_limit = num; }

  void freeze_memory()
        {
        if (!shared) 
           set_shared_data(Data, Len, AcquireOwnership);
        shared->freeze();
        }

protected:

  T* Data;
  size_type Len;
  ArrayRef<T,BasicArray<T> >* shared;

  virtual void construct(const size_type mylen, T *d, 
                                const EnumDataOwned o=DataNotOwned);
  virtual void initialize(T* /*data*/, const size_type /*start*/, 
                                        const size_type /*stop*/)
                {}
  void free();
  void set_shared_data(T *data, const size_type len_,
                                const EnumDataOwned o=DataNotOwned);

};



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


template <class T>
inline T & BasicArray<T>::operator[](const size_type idx)
{
#if (ArraySanityChecking==1)
if (idx >= Len)
   ErrAbort(errmsg("BasicArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,Len));
#endif
 
return Data[idx];
}
 
 
template <class T>
inline const T & BasicArray<T>::operator[](const size_type idx) const
{
#if (ArraySanityChecking==1)
if (idx >= Len)
   ErrAbort(errmsg("BasicArray<T>::operator[] : iterator out of range. idx=%d len=%d",idx,Len));
#endif
 
return Data[idx];
}



template <class T>
void BasicArray<T>::construct(const size_type mylen, T *d, const EnumDataOwned o)
{
Len = mylen;
if (d == NULL) {
   if (mylen > 0) {
      Data = new T [mylen] ;
      if (Data == 0)
         ErrAbort(errmsg("BasicArray::construct - new T [%d] failed.",mylen));
      }
   else
      Data = NULL;
   }

else {
   if (o == AcquireOwnership) {
      if (mylen > 0)  {
         Data = new T [mylen] ;
         if (Data == 0)
           ErrAbort(errmsg("BasicArray::construct - new T [%d] failed.",mylen));
         for (size_type i=0; i<mylen; i++) Data[i] = d[i] ;
         }
      }
   else
      Data = d;
   }

shared=0;
if ((d != NULL) && (o != AcquireOwnership))
   set_shared_data(Data,Len,o);
}


template <class T>
void BasicArray<T>::free()
{
if (shared) {
   bool flag = shared->release(this);
   if (flag)
      delete shared;
   shared=0;
   }
else if (Len > 0) {
   delete [] Data;
   Data=NULL;
   Len=0;
   }
}


template <class T>
BasicArray<T>& BasicArray<T>::operator=(const BasicArray<T>& array)
{
if (this != &array) {
   free();
   construct(array.size(),array.data(),AcquireOwnership);
   }
return *this;
}


template <class T>
BasicArray<T>& BasicArray<T>::operator=(const T& val)
{
if (size() == 0)
   return *this;
T *start = Data;
T *end = start + size();
for ( ; start < end ; start++ )
  *start = val;
return *this;
}


template <class T>
BasicArray<T>& BasicArray<T>::operator&=(const BasicArray<T>& array)
{
if ((Data != NULL) && (array.Data == Data)) return *this;

if (!array.shared)
   ErrAbort("BasicArray<T>::operator&= - argument is an array with unshared memory!");

free();
shared = array.shared;
shared->acquire(this);

return *this;
}



template <class T>
BasicArray<T>& BasicArray<T>::operator&=(BasicArray<T>& array)
{
if ((Data != NULL) && (array.Data == Data)) return *this;

if (!array.shared)
   array.set_shared_data(array.Data, array.Len, AcquireOwnership);

free();
shared = array.shared;
shared->acquire(this);

return *this;
}



template <class T>
int BasicArray<T>::resize(const size_type newl)
{
if (newl == Len) return OK;

if (newl == 0) {
   if (shared)
      shared->set_data(0,0,AcquireOwnership);
   else if (Len > 0) {
      delete [] Data;
      Data = 0;
      Len = 0;
      }
   return OK;
   }

T *d;
d = new T [newl];
if (d == 0)
   ErrAbort(errmsg("BasicArray::resize - new T [%d] failed.",newl));
if (Len > 0) {
   T* start = Data;
   for (size_type i=0; i<min(newl,Len); i++,start++)
     d[i] = *start;
   }

if (newl > Len)
   initialize(d,Len,newl);

if (shared)
   shared->set_data(d,newl,AcquireOwnership);
else {
   if (Len > 0) 
      delete [] Data;
   Data = d;
   Len = newl;
   }

return OK;
}


template <class T>
void BasicArray<T>::set_shared_data(T* data, const size_type len,
                                                const EnumDataOwned o)
{
if (!shared) {
   if ((Len > 0) && (data != Data))
      delete [] Data;
   shared = new ArrayRef<T,BasicArray<T> >();
   if (!shared)
      ErrAbort("BasicArray<T>::set_shared_data - error allocated a ArrayRef object");
   shared->acquire(this);
   }

shared->set_data(data,len,o);
}


template <class T>
BasicArray<T>& BasicArray<T>::set_data(const size_type len, T * data, 
                                                        const EnumDataOwned o)
{
if (Data == data) return *this;

set_shared_data(data, len, o);
return *this;
}



template <class T>
BasicArray<T>& BasicArray<T>::set_data(const BasicArray<T>& array, 
                                                const size_type start,
                                                const size_type newlen)
{
if (array.Data == Data)                      // Return unmodified array when
   return *this;                             // you are setting yourself.
 
if (array.Data)
   set_shared_data( &(array.Data[start]), newlen, DataNotOwned);
else
   resize(0);
return *this;
}


template <class T>
BasicArray<T>& BasicArray<T>::set_subvec(const size_type start, 
                        const size_type len,
                        const BasicArray<T>& array, const size_type offset)
{
T* begin = Data + start;
T* newdata = array.Data + offset;
for (size_type i=0; i<len; i++, begin++, newdata++)
  *begin = *newdata;
 
return *this;
}
 

template <class T>
BasicArray<T>& BasicArray<T>::at(const size_type start, const size_type newlen,
                                BasicArray<T>* array ) const
{
BasicArray<T> *tmp;
 
if (array == NULL) {
   tmp = new BasicArray<T>();
   if (tmp == 0)
      ErrAbort("BasicArray::at - new BasicArray failed.");
   }
else
   tmp = array;
tmp->set_data((*this), start, newlen);
return *tmp;
}

#define BasicArray_DEFN


//
// Copies an array without memory allocation.
//
template <class T, class V>
BasicArray<T>& operator<<(BasicArray<T>& x, const BasicArray<V>& y)
{
if (((void*)(x.data())) == ((void*)(y.data())))
   return x;
if (x.size() != y.size())
   ErrAbort(errmsg("operator<< : Unequal array lengths %d and %d",
                        x.size(), y.size()));
 
size_type len = x.size();
for (size_type i=0; i<len; i++)
  x[i] = y[i];

return x;
}

#endif