Index: trunk/SophyaLib/TArray/tarray.h
===================================================================
--- trunk/SophyaLib/TArray/tarray.h	(revision 813)
+++ trunk/SophyaLib/TArray/tarray.h	(revision 894)
@@ -23,4 +23,9 @@
 //  ( See BaseArray class for data organisation in  memory and related methods )
 
+//! Class for template arrays
+/*!
+  This class implements arrays of dimensions up to
+  \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS"
+*/
 template <class T>
 class TArray : public BaseArray {
@@ -38,4 +43,6 @@
 
   // A = B : partage les donnees si "a" est temporaire, clone sinon.
+  //! = operator between TArray
+  /*! \sa Set */
   inline  TArray<T>& operator = (const TArray<T>& a) { return Set(a); }
   virtual TArray<T>& Set(const TArray<T>& a);
@@ -54,5 +61,7 @@
 
   // SubArrays - $CHECK$ Reza 03/2000 je ne sais pas s'il faut declarer ca const ??
-  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ; 
+  TArray<T> SubArray(Range rx, Range ry, Range rz, Range rt, Range ru) const ;
+  //! () operator for Sub arrays extraction
+  /*! \sa SubArray */
   inline TArray<T> operator () (Range rx, Range ry, Range rz, Range rt=0, Range ru=0) const
                    { return  SubArray(rx, ry, rz, rt, ru); }
@@ -75,11 +84,17 @@
   inline T&       ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it=0, uint_4 iu=0);
 
+  //! Return pointer to first element adress
   inline        T* Data()       {return mNDBlock.Begin()+offset_;}
+  //! Return pointer to first element adress
   inline const  T* Data() const {return mNDBlock.Begin()+offset_;}
+  //! Return reference to datablock NDataBlock
   inline        NDataBlock<T>& DataBlock()       {return mNDBlock;}
+  //! Return reference to datablock NDataBlock
   inline const  NDataBlock<T>& DataBlock() const {return mNDBlock;}
 
   // Temporaire?
+  //! Are the array temporay ?
   inline bool   IsTemp(void) const {return mNDBlock.IsTemp();}
+  //! Set the array as temporay
   inline void   SetTemp(bool temp=false) const {mNDBlock.SetTemp(temp);}
 
@@ -89,16 +104,22 @@
 // Met les elements a une suite de valeurs
   virtual TArray<T>&  SetSeq(Sequence seq);
+  //! Fill TArray with Sequence \b seq
   inline  TArray<T>&  operator = (Sequence seq)    { return SetSeq(seq); }
 // A = x (tous les elements a x)
   virtual TArray<T>&  SetT(T x);
+  //! Fill TArray with all elements equal to \b x
   inline  TArray<T>&  operator = (T x)             { return SetT(x); }
 // A += -= *= /= x (ajoute, soustrait, ... x a tous les elements)
   virtual TArray<T>&  Add(T x);
+  //! Add \b x to all elements
   inline  TArray<T>&  operator += (T x)            { return Add(x); }
   virtual TArray<T>&  Sub(T x);
+  //! Substract \b x to all elements
   inline  TArray<T>&  operator -= (T x)            { return Sub(x); }
   virtual TArray<T>&  Mul(T x);
+  //! Multiply all elements by \b x
   inline  TArray<T>&  operator *= (T x)            { return Mul(x); }
   virtual TArray<T>&  Div(T x);
+  //! Divide all elements by \b x
   inline  TArray<T>&  operator /= (T x)            { return Div(x); }
   virtual TArray<T>&  SubInv(T x);  //   A ---> x-A
@@ -107,6 +128,8 @@
 // A += -=  (ajoute, soustrait element par element les deux tableaux )
   virtual TArray<T>&  AddElt(const TArray<T>& a);
+  //! Operator TArray += TArray
   inline  TArray<T>&  operator += (const TArray<T>& a)  { return AddElt(a); }
   virtual TArray<T>&  SubElt(const TArray<T>& a);
+  //! Operator TArray -= TArray
   inline  TArray<T>&  operator -= (const TArray<T>& a)  { return SubElt(a); }
 // Multiplication, division element par element les deux tableaux 
@@ -133,9 +156,10 @@
   void Share(const TArray<T>& a);
 
-  NDataBlock<T> mNDBlock;      // Le bloc des donnees
+  NDataBlock<T> mNDBlock; //!< Block for datas
 };
 
 ////////////////////////////////////////////////////////////////
 //   Surcharge d'operateur << 
+//! Print TArray \b a on stream \b os
 template <class T>
 inline ostream& operator << (ostream& os, const TArray<T>& a)
@@ -145,22 +169,29 @@
 // Surcharge d'operateurs A (+,-,*,/) (T) x
 
+//! Operator TArray = TArray + constant
 template <class T> inline TArray<T> operator + (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
+//! Operator TArray = constant + TArray
 template <class T> inline TArray<T> operator + (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.Add(b); return result;}
 
+//! Operator TArray = TArray - constant
 template <class T> inline TArray<T> operator - (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Sub(b); return result;}
 
+//! Operator TArray = constant - TArray
 template <class T> inline TArray<T> operator - (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.SubInv(b); return result;}
 
+//! Operator TArray = TArray * constant
 template <class T> inline TArray<T> operator * (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
+//! Operator TArray = constant * TArray
 template <class T> inline TArray<T> operator * (T b,const TArray<T>& a)
     {TArray<T> result(a); result.SetTemp(true); result.Mul(b); return result;}
 
+//! Operator TArray = TArray / constant
 template <class T> inline TArray<T> operator / (const TArray<T>& a, T b)
     {TArray<T> result(a); result.SetTemp(true); result.DivInv(b); return result;}
@@ -169,8 +200,10 @@
 // Surcharge d'operateurs C = A (+,-) B
 
+//! Operator TArray = TArray + TArray
 template <class T>
 inline TArray<T> operator + (const TArray<T>& a,const TArray<T>& b)
     {TArray<T> result(a); result.SetTemp(true); result.AddElt(b); return result;}
 
+//! Operator TArray = TArray - TArray
 template <class T>
 inline TArray<T> operator - (const TArray<T>& a,const TArray<T>& b)
@@ -181,4 +214,6 @@
 //        inline element acces methods
 // --------------------------------------------------
+
+//! Return element (ix,iy,iz,it,iu) value
 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
@@ -189,4 +224,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T & TArray<T>::Elem(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -197,4 +233,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
 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
@@ -204,4 +241,5 @@
 }
 
+//! Return element (ix,iy,iz,it,iu) value with Check of indexes bound first
 template <class T>
 inline T & TArray<T>::ElemCheckBound(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -211,4 +249,5 @@
 }
 
+//! Return element (ix,iy,iz) value
 template <class T>
 inline T const& TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) const
@@ -221,4 +260,5 @@
 }
 
+//! Return element (ix,iy,iz) value
 template <class T>
 inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz) 
@@ -231,4 +271,5 @@
 }
 
+//! Operator () : return element (ix,iy,iz,it,iu) value
 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
@@ -242,4 +283,5 @@
 }
 
+//! Operator () : return element (ix,iy,iz,it,iu) value
 template <class T>
 inline T & TArray<T>::operator()(uint_4 ix, uint_4 iy, uint_4 iz, uint_4 it, uint_4 iu)
@@ -254,4 +296,5 @@
 
 
+//! Operator [] : return element at positon ip
 template <class T>
 inline T const& TArray<T>::operator[](uint_8 ip) const
@@ -263,4 +306,5 @@
 }
 
+//! Operator [] : return element at positon ip
 template <class T>
 inline T & TArray<T>::operator[](uint_8 ip) 
@@ -273,4 +317,5 @@
 
 
+//! Return the value of first element
 template <class T>
 inline T TArray<T>::toScalar()
@@ -281,4 +326,5 @@
 
 // Typedef pour simplifier
+//! To simplify, Array \<==\> TArray<r_8>
 typedef TArray<r_8> Array;
 
