// This may look like C code, but it is really -*- C++ -*-
//      template array class for numerical types
//                     R. Ansari, C.Magneville   03/2000

#ifndef TArray_SEEN
#define TArray_SEEN

#include "machdefs.h"
#include <math.h>
#include <iostream.h>
#include "basarr.h"
#include "ndatablock.h"
#include <complex>
#include "utilarr.h"


namespace SOPHYA {

// Forward declaration
template <class T> class FIO_TArray;

//   --------------------------- classe template Array -----------------------
//  ( See BaseArray class for data organisation in  memory and related methods )

template <class T>
class TArray : public BaseArray {
public:
  // Creation / destruction 
  TArray();
  TArray(uint_4 ndim, uint_4 * siz, uint_4 step =1);
  TArray(uint_4 nx, uint_4 ny=0, uint_4 nz=0);
  TArray(uint_4 ndim, uint_4 * siz, NDataBlock<T> & db, bool share=false, uint_4 step=1, uint_8 offset=0);
  TArray(uint_4 ndim, uint_4 * siz, T* values, uint_4 step=1, uint_8 offset=0, Bridge* br=NULL);
  TArray(const TArray<T>& a);
  TArray(const TArray<T>& a, bool share);

  virtual ~TArray();

  // A = B : partage les donnees si "a" est temporaire, clone sinon.
  virtual TArray<T>& operator = (const TArray<T>& a);

  // Gestion taille/Remplissage
  virtual void Clone(const TArray<T>& a); 
  virtual void ReSize(uint_4 ndim, uint_4 * siz, uint_4 step=1);
  virtual void Realloc(uint_4 ndim, uint_4 * siz, uint_4 step=1, bool force=false);

  // Compacts size=1 array dimensions
  virtual TArray<T>& CompactAllDimensions();
  virtual TArray<T>& CompactTrailingDimensions();

  // SubArrays
  virtual TArray<T> operator () (Range rx, Range ry, Range rz=0, Range rt=0, Range ru=0); 


  // ---- Access to data
  // Definition of virtual element acces method inherited from BaseArray class 
  virtual double ValueAtPosition(uint_8 ip) const;

  // Data Access: operator overloaded inline acces methods 
  inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz) const ;
  inline T&       operator()(uint_4 ix, uint_4 iy, uint_4 iz);
  inline T const& operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0) const ;
  inline T&       operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu=0);
  inline T const& operator[](uint_8 ip) const ;
  inline T&       operator[](uint_8 ip);

  inline T const& Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
  inline T&       Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
  inline T const& ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0) const ;
  inline T&       ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);

  inline        T* Data()       {return mNDBlock.Begin()+offset_;}
  inline const  T* Data() const {return mNDBlock.Begin()+offset_;}
  inline        NDataBlock<T>& DataBlock()       {return mNDBlock;}
  inline const  NDataBlock<T>& DataBlock() const {return mNDBlock;}

  // Temporaire?
  inline bool   IsTemp(void) const {return mNDBlock.IsTemp();}
  inline void   SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}

// Operations diverses  = , +=, ...
// Conversion en type T, if Size() == 1
  inline T toScalar();
// Met les elements a une suite de valeurs
  virtual TArray<T>&  operator = (Sequence seq);
// A = x (tous les elements a x)
  virtual TArray<T>&  operator = (T x);
// A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
  virtual TArray<T>&  operator += (T x);
  virtual TArray<T>&  operator -= (T x);
  virtual TArray<T>&  operator *= (T x);
  virtual TArray<T>&  operator /= (T x);
// A += -=  (ajoute, soustrait element par element les deux tableaux )
  virtual TArray<T>&  operator += (const TArray<T>& a);
  virtual TArray<T>&  operator -= (const TArray<T>& a);
// Multiplication, division element par element les deux tableaux 
  virtual TArray<T>&  MultElt(const TArray<T>& a);
  virtual TArray<T>&  DivElt(const TArray<T>& a);

// Impression, I/O, ...
  virtual string DataType() const;   // definition of abstract method inherited from BaseArray
  virtual void  Print(ostream& os, int_4 maxprt=-1, bool si=false) const ;

//  Pour la gestion de persistance
  friend class  FIO_TArray<T>;

protected:
  // partage les donnees si "a" temporaire, clone sinon.
  void CloneOrShare(const TArray<T>& a);
  // Share: partage les donnees de "a"
  void Share(const TArray<T>& a);

  NDataBlock<T> mNDBlock;      // Le bloc des donnees
};

////////////////////////////////////////////////////////////////
//   Surcharge d'operateur << 
template <class T>
inline ostream& operator << (ostream& os, const TArray<T>& a)
                            { a.Print(os);    return(os);    }

////////////////////////////////////////////////////////////////
// Surcharge d'operateurs A (+,-,*,/) (T) x

template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}

template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}

template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
    {TArray<T> result(a); result.SetTemp(true); result -= b; return result;}

template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
    {TArray<T> result(a); result.SetTemp(true);
     result.DataBlock() = b-result.DataBlock(); return result;}

template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
    {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}

template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
    {TArray<T> result(a); result.SetTemp(true); result *= b; return result;}

template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
    {TArray<T> result(a); result.SetTemp(true); result /= b; return result;}

////////////////////////////////////////////////////////////////
// Surcharge d'operateurs C = A (+,-) B

template <class T>
inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}

template <class T>
inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
    {TArray<T> result(a); result.SetTemp(true); result += b; return result;}


// --------------------------------------------------
//        inline element acces methods
// --------------------------------------------------
template <class T>
inline T const& TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
{
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2] +
	      it*step_[3] + iu*step_[4]) );
}

template <class T>
inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
{
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2] +
	      it*step_[3] + iu*step_[4]) );
}

template <class T>
inline T const& TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
{
  CheckBound(ix, iy, iz, it, iu, 4);
  Elem(ix, iy, iz, it, iu);
}

template <class T>
inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
{
  CheckBound(ix, iy, iz, it, iu, 4);
  Elem(ix, iy, iz, it, iu);
}

template <class T>
inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
{
#ifdef SO_BOUNDCHECKING
  CheckBound(ix, iy, iz, 0, 0, 4);
#endif
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2]) );
}

template <class T>
inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) 
{
#ifdef SO_BOUNDCHECKING
  CheckBound(ix, iy, iz, 0, 0, 4);
#endif
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2]) );
}

template <class T>
inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu) const
{
#ifdef SO_BOUNDCHECKING
  CheckBound(ix, iy, iz, it, iu, 4);
#endif
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2] +
	      it*step_[3] + iu*step_[4]) );
}

template <class T>
inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
{
#ifdef SO_BOUNDCHECKING
  CheckBound(ix, iy, iz, it, iu, 4);
#endif
  return ( *( mNDBlock.Begin()+ offset_+ 
	      ix*step_[0] + iy*step_[1] + iz*step_[2] +
	      it*step_[3] + iu*step_[4]) );
}


template <class T>
inline T const& TArray<T>::operator[](uint_8 ip) const
{
#ifdef SO_BOUNDCHECKING
  if (ip >= totsize_)  throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
#endif
return *(mNDBlock.Begin()+Offset(ip));
}

template <class T>
inline T & TArray<T>::operator[](uint_8 ip) 
{
#ifdef SO_BOUNDCHECKING
  if (ip >= totsize_)  throw( ParmError("TArray<T>::operator[] Out-of-bound Error") );
#endif
return *(mNDBlock.Begin()+Offset(ip));
}


template <class T>
inline T TArray<T>::toScalar()
{ 
  if (Size() != 1) throw(SzMismatchError("TArray<T>::operator T() Size() != 1")) ;
  return ( (*this)[0] );
}

} // Fin du namespace

#endif