Index: /trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 943)
+++ /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 944)
@@ -10,14 +10,66 @@
 #include "ndatablock.h"
 
-// define DEBUG_NDATABLOCK
-
-#ifdef DEBUG_NDATABLOCK
-  static size_t NallocData = 0;
-  static size_t NallocSRef = 0;
-#endif
-
-////////////////////////////////////////////////////////////////
-//************ Createur, Destructeur
-
+/*!
+  \class SOPHYA::NDataBlock
+  \ingroup SysTools
+  Management of data blocks
+*/
+
+//////////////////////////////////
+// Fonctionnement en mode debug //
+//////////////////////////////////
+
+template <class T> int    NDataBlock<T>::Debug_NDataBlock = 0;
+template <class T> size_t NDataBlock<T>::NallocData       = 0;
+template <class T> size_t NDataBlock<T>::NallocSRef       = 0;
+
+//! Set debug (and level print) for allocation and references debug.
+/*!
+  \param prtlevel : activate/des-activate debug mode
+                    and select print level
+
+  \arg prtlevel <= 0 : no debug
+  \arg prtlevel == 1 : debug activated, no print
+  \arg prtlevel >=2  : debug activated,
+       print infos in all routines that have something to do with
+       allocations or des-allocation of datas or references.
+ */
+template <class T>
+void NDataBlock<T>::SetPrintDebug(int prtdbglevel)
+{
+  Debug_NDataBlock = prtdbglevel;
+}
+
+//! Reset debug counter values.
+/*!
+  \param nallocdata : reset number of allocated data structures to \b nallocdata
+  \param nallocsref : reset number of allocated references to \b nallocsref
+  \warning In principle this routine should not be use (only experts)
+ */
+template <class T>
+void NDataBlock<T>::ResetDebug(size_t nallocdata, size_t nallocsref)
+{
+NallocData = nallocdata;
+NallocSRef = nallocsref;
+}
+
+//! Print debug current status.
+/*!
+  Print debug current status for number of allocated
+  data structures and number of allocated references.
+ */
+template <class T>
+void NDataBlock<T>::PrintDebug()
+{
+cout<<"... ... ... NallocData = "<<NallocData
+    <<"  ,  NallocSRef = "<<NallocSRef
+    <<" ... ... ..."<<endl;
+}
+
+///////////////////////////
+// Createur, Destructeur //
+///////////////////////////
+
+//! Constructor for \b n datas
 template <class T>
 NDataBlock<T>::NDataBlock(size_t n)
@@ -25,11 +77,16 @@
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::NDataBlock("<<this<<",n="<<n<<")"<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::NDataBlock("<<this<<",n="<<n<<")"<<endl;
 
 Alloc(n, NULL, NULL, true);   // allocation et mise a zero
 }
 
+//! Constructor for \b n datas shared with external
+/*!
+  Datas are previously allocated by an other external source.
+  \warning This require particular care (see Alloc)
+  \sa Alloc
+ */
 template <class T>
 NDataBlock<T>::NDataBlock(size_t n, T* data, Bridge* br)
@@ -38,12 +95,12 @@
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::NDataBlock("<<this
-    <<",data="<<data<<",br="<<br<<")"<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::NDataBlock("<<this
+      <<",data="<<data<<",br="<<br<<")"<<endl;
 
 Alloc(n,data,br);
 }
 
+//! Default constructor
 template <class T>
 NDataBlock<T>::NDataBlock()
@@ -51,9 +108,12 @@
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::NDataBlock("<<this<<") default"<<endl;
-#endif
-}
-
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::NDataBlock("<<this<<") default"<<endl;
+}
+
+//! Copy constructor
+/*!
+  \warning datas are shared if \b a is temporary, cloned if not.
+ */
 template <class T>
 NDataBlock<T>::NDataBlock(const NDataBlock<T>& a)
@@ -61,11 +121,14 @@
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<")"<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<")"<<endl;
 
 CloneOrShare(a);
 }
 
+//! Copy constructor with \b share option
+/*!
+  \warning datas are shared if \b share is \b true, cloned if not.
+ */
 template <class T>
 NDataBlock<T>::NDataBlock(const NDataBlock<T>& a,bool share)
@@ -73,95 +136,154 @@
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<",sh=<<"<<share<<")"<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<",sh=<<"<<share<<")"<<endl;
 
 if(share) Share(a); else Clone(a);
 }
 
+//! Destructor
 template <class T>
 NDataBlock<T>::~NDataBlock()
 // Destructeur
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::~NDataBlock("<<this<<")"<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::~NDataBlock("<<this<<")"<<endl;
 
 Delete();
 }
 
-////////////////////////////////////////////////////////////////
-//************ Gestion de donnees
-
+////////////////////////
+// Gestion de donnees //
+////////////////////////
+
+//! Clone datas from \b a
+template <class T>
+void NDataBlock<T>::Clone(const NDataBlock<T>& a)
+// Clone: copie de donnees a partir de "a"
+{
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::Clone("<<this<<","<<&a<<") a.(mSz="
+      <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
+      <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
+
+if(&a==NULL) throw(NullPtrError("NDataBlock::Clone  &a==NULL\n"));
+if(!a.mSRef || a.mSz==0) throw(SzMismatchError("NDataBlock::Clone a.mSz==0\n"));
+Alloc(a.mSz, NULL, NULL, false);  // pas de mise a zero 
+memcpy(Data(),a.Data(),mSz*sizeof(T));
+}
+
+//! Share datas with \b a
+template <class T>
+void NDataBlock<T>::Share(const NDataBlock<T>& a)
+// Share: Partage les donnees avec "a"
+{
+if(Debug_NDataBlock>1) {
+  cout<<"?_NDataBlock::Share("<<this<<","<<&a<<")";
+  if(&a!=NULL) cout<<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef
+                   <<" IsTemp="<<a.IsTemp()<<")";
+  cout<<", mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
+}
+
+if(&a==NULL) throw(NullPtrError("NDataBlock::Share  &a==NULL\n"));
+if(!a.mSRef || a.mSz==0) throw(NullPtrError("NDataBlock::Share a.mSz=0\n"));
+if(mSRef) Delete();
+mSz = a.mSz; mSRef = a.mSRef; mSRef->nref++;
+
+if(Debug_NDataBlock>1)
+  cout<<"...?_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
+      <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
+      <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp<<endl;
+}
+
+//! \b Share with \b a if \b temporary, \b clone from \b a if not.
+template <class T>
+void NDataBlock<T>::CloneOrShare(const NDataBlock<T>& a)
+// CloneOrShare: Share si "a" temporaire, Clone sinon.
+{
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::CloneOrShare("<<this<<","<<&a<<")"<<endl;
+
+if(&a==NULL) throw(NullPtrError("NDataBlock::CloneOrShare  &a==NULL\n"));
+if(a.IsTemp()) Share(a); else Clone(a);
+}
+
+////////////////////////////////////////////////////////////
+// Allocation , destruction , remplissage et reallocation //
+////////////////////////////////////////////////////////////
+
+//! Allocation management
+/*!
+   Allocation d'un NOUVEL espace de stoquage de "n" donnees
+   \verbatim
+   Si data==NULL : allocation de l'espace memoire 
+      si zero == true , l'espace est remplis de zeros
+      data!=NULL : partage des donnees avec l'adresse data
+   Si br==NULL   : les donnees nous appartiennent
+      br!=NULL   : les donnees ne nous appartiennent pas (ex: Blitz)
+  
+   Exemple: on veut connecter a un tableau de T*
+   > float *x = new float[5]; ... remplissage de x[] ...;
+   1- On veut que NDataBlock NE DESALLOUE PAS le tableau "x[]"
+      a- Premiere solution
+         > NDataBlock A(5,x,new Bridge);
+         ......
+         > delete [] x;
+            - Il faut deleter x[] explicitement.
+            - Le destructeur de "A" ne detruit pas x[].
+            ATTENTION: Une fois x[] detruit, "A" ne peut
+                       plus acceder les donnees!
+            - Bridge est detruit par le destructeur de "A"
+      b- Autre solution:
+         > NDataBlock A(5); A.FillFrom(5,x);
+         > delete [] x;
+         ......
+            - Il faut deleter x[] explicitement.
+            - "A" possede une copie en local de x[].
+            - Le destructeur de "A" ne detruit pas x[] mais la copie locale.
+   2- On veut que NDataBlock desalloue le tableau
+         > NDataBlock A(5,x);
+            - Ne Pas Faire "delete [] x;"
+            - "A" partage les donnees avec x[].
+            - Le destructeur de "A" detruit x[].
+  
+   --- REMARQUE SUR LE DANGER DE CERTAINES SITUATIONS (CMV):
+   1-/ x = new float[n1]; NDataBlock A(n2,x);
+       1er danger: si n2>n1 depassement de tableaux (core dump)
+       2sd danger: celui qui alloue x[] ne doit pas faire le "delete"
+                   en desaccord avec toutes les regles de bonne conduite.
+   2-/ float x[5]={1,2,3,4,5}; {NDataBlock A(n2,&x[0]);} cout<<x[2];
+       Ici, a la sortie du bloc {}, le destructeur de "A" va detruire
+       l'adresse de &x[0]: je n'ose imaginer que ca se fasse sans probleme
+       et de toute facon, cout<<x[2]; va surement faire des etincelles.
+   3-/ x = new float[n1]; NDataBlock A(n2,x,new Bridge);
+       1er danger: si n2>n1 depassement de tableaux (core dump)
+       2sd danger: si la methode bridgee (blitz?) detruit x[]
+                   "A" n'a plus de donnees connectees!
+   --- CONCLUSION
+   Cette classe est franchement merdique.
+   - On peut accepter la prise de risque liee a NDataBlock(n2,x,new Bridge);
+     car je ne vois pas comment on pourrait faire autrement pour connecter
+     un tableau de type blitz par exemple.
+   - Par contre le createur NDataBlock(n2,x); doit etre interdit
+     dans sa forme actelle car trop dangereux et il me semble inutile.
+   - Dans cette nouvelle optique:
+     NDataBlock(n2,x,new Bridge) et NDataBlock(n2,x) disparaissent
+     On remplace par NDataBlock(n2,x) {Alloc(n2,x,new Bridge);}
+        qui force le Bridge dans tout les cas puisque NDataBlock
+        ne possede pas les donnees.
+     Mais puis-je encore le faire vu que NDataBlock est a la base
+     de TVector,TMatrix et qu'il faut donc reprendre tout le code DPC
+   - Quoiqu'il arrive Alloc est une methode privee et peut donc rester
+     sous sa forme actuelle.
+              
+   \endverbatim
+ */
 template <class T>
 void NDataBlock<T>::Alloc(size_t n,T* data,Bridge* br,bool zero)
-// Allocation d'un NOUVEL espace de stoquage de "n" donnees
-// Si data==NULL : allocation de l'espace memoire 
-//    si zero == true , l'espace est remplis de zeros
-//    data!=NULL : partage des donnees avec l'adresse data
-// Si br==NULL   : les donnees nous appartiennent
-//    br!=NULL   : les donnees ne nous appartiennent pas (ex: Blitz)
-//
-// Exemple: on veut connecter a un tableau de T*
-// > float *x = new float[5]; ... remplissage de x[] ...;
-// 1- On veut que NDataBlock NE DESALLOUE PAS le tableau "x[]"
-//    a- Premiere solution
-//       > NDataBlock A(5,x,new Bridge);
-//       ......
-//       > delete [] x;
-//          - Il faut deleter x[] explicitement.
-//          - Le destructeur de "A" ne detruit pas x[].
-//          ATTENTION: Une fois x[] detruit, "A" ne peut
-//                     plus acceder les donnees!
-//          - Bridge est detruit par le destructeur de "A"
-//    b- Autre solution:
-//       > NDataBlock A(5); A.FillFrom(5,x);
-//       > delete [] x;
-//       ......
-//          - Il faut deleter x[] explicitement.
-//          - "A" possede une copie en local de x[].
-//          - Le destructeur de "A" ne detruit pas x[] mais la copie locale.
-// 2- On veut que NDataBlock desalloue le tableau
-//       > NDataBlock A(5,x);
-//          - Ne Pas Faire "delete [] x;"
-//          - "A" partage les donnees avec x[].
-//          - Le destructeur de "A" detruit x[].
-//
-// --- REMARQUE SUR LE DANGER DE CERTAINES SITUATIONS (CMV):
-// 1-/ x = new float[n1]; NDataBlock A(n2,x);
-//     1er danger: si n2>n1 depassement de tableaux (core dump)
-//     2sd danger: celui qui alloue x[] ne doit pas faire le "delete"
-//                 en desaccord avec toutes les regles de bonne conduite.
-// 2-/ float x[5]={1,2,3,4,5}; {NDataBlock A(n2,&x[0]);} cout<<x[2];
-//     Ici, a la sortie du bloc {}, le destructeur de "A" va detruire
-//     l'adresse de &x[0]: je n'ose imaginer que ca se fasse sans probleme
-//     et de toute facon, cout<<x[2]; va surement faire des etincelles.
-// 3-/ x = new float[n1]; NDataBlock A(n2,x,new Bridge);
-//     1er danger: si n2>n1 depassement de tableaux (core dump)
-//     2sd danger: si la methode bridgee (blitz?) detruit x[]
-//                 "A" n'a plus de donnees connectees!
-// --- CONCLUSION
-// Cette classe est franchement merdique.
-// - On peut accepter la prise de risque liee a NDataBlock(n2,x,new Bridge);
-//   car je ne vois pas comment on pourrait faire autrement pour connecter
-//   un tableau de type blitz par exemple.
-// - Par contre le createur NDataBlock(n2,x); doit etre interdit
-//   dans sa forme actelle car trop dangereux et il me semble inutile.
-// - Dans cette nouvelle optique:
-//   NDataBlock(n2,x,new Bridge) et NDataBlock(n2,x) disparaissent
-//   On remplace par NDataBlock(n2,x) {Alloc(n2,x,new Bridge);}
-//      qui force le Bridge dans tout les cas puisque NDataBlock
-//      ne possede pas les donnees.
-//   Mais puis-je encore le faire vu que NDataBlock est a la base
-//   de TVector,TMatrix et qu'il faut donc reprendre tout le code DPC
-// - Quoiqu'il arrive Alloc est une methode privee et peut donc rester
-//   sous sa forme actuelle.
-//            
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::Alloc("<<this<<","
-    <<n<<","<<data<<","<<br<<") mSz="<<mSz
-    <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
+{
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::Alloc("<<this<<","
+      <<n<<","<<data<<","<<br<<") mSz="<<mSz
+      <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
 
 if(br && !data)
@@ -176,80 +298,31 @@
 mSRef->bridge = br;
 
-#ifdef DEBUG_NDATABLOCK
-// Meme dans le cas data!=0 et br==0 (connexion d'un tableau
-// avec destruction geree par ~NDataBlock (cas 2-) on compte
-// comme si on avait fait une allocation du tableau (ce qui a ete
-// fait au niveau du dessus!).
-if(!br) NallocData++; NallocSRef++;
-cout<<"...?_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
-    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
-    <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp
-    <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
-#endif
-}
-
-template <class T>
-void NDataBlock<T>::Clone(const NDataBlock<T>& a)
-// Clone: copie de donnees a partir de "a"
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::Clone("<<this<<","<<&a<<") a.(mSz="
-    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
-    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
-
-if(&a==NULL) throw(NullPtrError("NDataBlock::Clone  &a==NULL\n"));
-if(!a.mSRef || a.mSz==0) throw(SzMismatchError("NDataBlock::Clone a.mSz==0\n"));
-Alloc(a.mSz, NULL, NULL, false);  // pas de mise a zero 
-memcpy(Data(),a.Data(),mSz*sizeof(T));
-}
-
-template <class T>
-void NDataBlock<T>::CloneOrShare(const NDataBlock<T>& a)
-// CloneOrShare: Share si "a" temporaire, Clone sinon.
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::CloneOrShare("<<this<<","<<&a<<")"<<endl;
-#endif
-
-if(&a==NULL) throw(NullPtrError("NDataBlock::CloneOrShare  &a==NULL\n"));
-if(a.IsTemp()) Share(a); else Clone(a);
-}
-
-template <class T>
-void NDataBlock<T>::Share(const NDataBlock<T>& a)
-// Share: Partage les donnees avec "a"
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::Share("<<this<<","<<&a<<")";
-if(&a!=NULL) cout<<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef
-                 <<" IsTemp="<<a.IsTemp()<<")";
-cout<<", mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
-
-if(&a==NULL) throw(NullPtrError("NDataBlock::Share  &a==NULL\n"));
-if(!a.mSRef || a.mSz==0) throw(NullPtrError("NDataBlock::Share a.mSz=0\n"));
-if(mSRef) Delete();
-mSz = a.mSz; mSRef = a.mSRef; mSRef->nref++;
-
-#ifdef DEBUG_NDATABLOCK
-cout<<"...?_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
-    <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
-    <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp<<endl;
-#endif
-}
-
+if(Debug_NDataBlock>0) {
+  // Meme dans le cas data!=0 et br==0 (connexion d'un tableau
+  // avec destruction geree par ~NDataBlock (cas 2-) on compte
+  // comme si on avait fait une allocation du tableau (ce qui a ete
+  // fait au niveau du dessus!).
+  if(!br) NallocData++; NallocSRef++;
+  if(Debug_NDataBlock>1)
+    cout<<"...?_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
+        <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
+        <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp
+        <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
+}
+}
+
+//! Management of de-allocation
 template <class T>
 void NDataBlock<T>::Delete(void)
 // Pour detruire les pointeurs en tenant compte des references
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::Delete("<<this<<") mSz="<<mSz
-    <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp;
-if(mSRef)
-  cout<<" mSRef->nref="<<mSRef->nref<<" mSRef->data="
-      <<mSRef->data<<" mSRef->bridge="<<mSRef->bridge;
-cout<<endl;
-#endif
+if(Debug_NDataBlock>1) {
+  cout<<"?_NDataBlock::Delete("<<this<<") mSz="<<mSz
+      <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp;
+  if(mSRef)
+    cout<<" mSRef->nref="<<mSRef->nref<<" mSRef->data="
+        <<mSRef->data<<" mSRef->bridge="<<mSRef->bridge;
+  cout<<endl;
+}
 
 if(mSRef==NULL) return;
@@ -257,8 +330,7 @@
 if(mSRef->nref != 0) {
 
-#ifdef DEBUG_NDATABLOCK
+if(Debug_NDataBlock>1)
   cout<<"...?_NDataBlock::Delete() pas de desallocation il reste nref="
       <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
-#endif
 
   mSz = 0; mSRef=NULL;
@@ -266,9 +338,10 @@
 }
 
-#ifdef DEBUG_NDATABLOCK
-if(!mSRef->bridge) NallocData--; NallocSRef--;
-cout<<"...?_NDataBlock::Delete() desallocation complete il reste nref="
-    <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
-#endif
+if(Debug_NDataBlock>0) {
+  if(!mSRef->bridge) NallocData--; NallocSRef--;
+  if(Debug_NDataBlock>1)
+    cout<<"...?_NDataBlock::Delete() desallocation complete il reste nref="
+        <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
+}
 
 // Si il y a un Bridge les donnees ne n'appartiennent pas, on detruit le Bridge
@@ -279,4 +352,10 @@
 }
 
+//! Fill dats of this NDataBlock with the \b n datas pointed by \b data
+/*!
+  \warning If class empty : allocate space in memory
+  \warning If class already connected : overwrite with minimum size
+           (\b n or \b mSz)
+ */
 template <class T>
 void NDataBlock<T>::FillFrom(size_t n,T* data)
@@ -293,19 +372,26 @@
 }
 
+//! Re-allocate space for \b nnew datas
+/*!
+  \param nnnew : new size
+  \param force : to manage the way re-allocation will be done (see after).
+  \verbatim
+  Re-allocation de "nnew" place memoire pour les donnees
+  avec conservation des "nold" donnees precedentes si possible.
+  "force" gere la re-allocation de la place memoire pour les donnees.
+  Divers cas se presentent:
+  a-/ *** nnew>nold force=quelconque ***
+      place re-allouee, donnees [0,nold[ copiees, surplus [nold,new[ mis a zero
+  b-/ *** nnew<=nold force=true ***
+      place re-allouee, donnees [0,nnew[ copiees, pas de surplus
+  c-/ *** nnew<=nold force=false ***
+      place non re-allouee, seule la valeur de la taille est diminuee
+  - On tient compte du partage des donnees dans tous les cas.
+  - Si il n'y a pas de donnees connectees a la classe, on re-alloue
+    dans tous les cas
+  \endverbatim
+ */
 template <class T>
 void NDataBlock<T>::Realloc(size_t nnew,bool force)
-// Re-allocation de "nnew" place memoire pour les donnees
-// avec conservation des "nold" donnees precedentes si possible.
-// "force" gere la re-allocation de la place memoire pour les donnees.
-// Divers cas se presentent:
-// a-/ *** nnew>nold force=quelconque ***
-//     place re-allouee, donnees [0,nold[ copiees, surplus [nold,new[ mis a zero
-// b-/ *** nnew<=nold force=true ***
-//     place re-allouee, donnees [0,nnew[ copiees, pas de surplus
-// c-/ *** nnew<=nold force=false ***
-//     place non re-allouee, seule la valeur de la taille est diminuee
-// - On tient compte du partage des donnees dans tous les cas.
-// - Si il n'y a pas de donnees connectees a la classe, on re-alloue
-//   dans tous les cas
 {
 if(nnew==0) throw(ParmError("NDataBlock::Realloc  n<=0\n"));
@@ -323,7 +409,9 @@
 }
 
-////////////////////////////////////////////////////////////////
-//**** Impression
-
+////////////////
+// Impression //
+////////////////
+
+//! Give infos and print \b n datas beginning at \b i1 on stream \b os.
 template <class T>
 void NDataBlock<T>::Print(ostream& os,size_t i1,size_t n) const
@@ -347,6 +435,9 @@
 }
 
-////////////////////////////////////////////////////////////////
-
+//////////////////////////////////////////////
+// Calcul de la somme / produit des donnees //
+//////////////////////////////////////////////
+
+//! Return sum of \b n datas beginning at data \b i1.
 template <class T>
 T NDataBlock<T>::Sum(size_t i1,size_t n) const
@@ -361,4 +452,5 @@
 }
 
+//! Return product of \b n datas beginning at data \b i1.
 template <class T>
 T NDataBlock<T>::Product(size_t i1,size_t n) const
@@ -373,16 +465,18 @@
 }
 
-////////////////////////////////////////////////////////////////
-//**** Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; 
-
+///////////////////////////////////////////////////////////////
+// Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; //
+///////////////////////////////////////////////////////////////
+
+//! Operator = : ND = ND1
+/*! \warning share if \b a is temporary, clone if not */
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator = (const NDataBlock<T>& a)
 // Affectation: partage des donnees si "a" temporaire, clone sinon.
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::operator=("<<this<<","<<&a<<") a.(mSz="
-    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
-    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::operator=("<<this<<","<<&a<<") a.(mSz="
+      <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
+      <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
 
 if(this == &a) return *this;
@@ -393,12 +487,13 @@
 }
 
+//! Operator = : ND = \b v (at dats set to \b v).
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator = (T v)
 // Affectation de tous les elements a une constante "v"
 {
-#ifdef DEBUG_NDATABLOCK
-cout<<"?_NDataBlock::operator=("<<this<<","<<v<<")"
-    <<" mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
+if(Debug_NDataBlock>1)
+  cout<<"?_NDataBlock::operator=("<<this<<","<<v<<")"
+      <<" mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
+
 
 if(mSz==0) throw(SzMismatchError("NDataBlock::operator=v null size\n"));
@@ -408,7 +503,9 @@
 }
 
-////////////////////////////////////////////////////////////////
-//**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += <T> b;
-
+//////////////////////////////////////////////////////////////
+// Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += <T> b; //
+//////////////////////////////////////////////////////////////
+
+//! Add a constant : ND += b
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator += (T b)
@@ -420,4 +517,5 @@
 }
 
+//! Substract a constant : ND -= b
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator -= (T b)
@@ -429,4 +527,5 @@
 }
 
+//! Multiply by a constant : ND *= b
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator *= (T b)
@@ -438,4 +537,5 @@
 }
 
+//! Divide by a constant : ND *= b
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator /= (T b)
@@ -448,7 +548,9 @@
 }
 
-////////////////////////////////////////////////////////////////
-//**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += NDataBlock;
-
+////////////////////////////////////////////////////////////////////
+// Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += NDataBlock1; //
+////////////////////////////////////////////////////////////////////
+
+//! Add a NDataBlock : ND += ND1
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator += (const NDataBlock<T>& a)
@@ -462,4 +564,5 @@
 }
 
+//! Substract a NDataBlock : ND -= ND1
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator -= (const NDataBlock<T>& a)
@@ -473,4 +576,5 @@
 }
 
+//! Multiply by a NDataBlock : ND *= ND1
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator *= (const NDataBlock<T>& a)
@@ -484,4 +588,5 @@
 }
 
+//! Divide by a NDataBlock : ND *= ND1
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator /= (const NDataBlock<T>& a)
@@ -497,7 +602,9 @@
 
 ////////////////////////////////////////////////////////////////
-//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b;
-//                            NDataBlock = <T>b+NDataBlock;
-
+// Pour surcharge de +,-,*,/ : NDataBlock = NDataBlock1+<T>b; //
+//                             NDataBlock = <T>b+NDataBlock1; //
+////////////////////////////////////////////////////////////////
+
+//! Add a constant and return NDataBlock : NDret = ND + b
 template <class T>
 NDataBlock<T> NDataBlock<T>::Add(T b) const
@@ -509,4 +616,5 @@
 }
 
+//! Substract a constant and return NDataBlock : NDret = ND - b
 template <class T>
 NDataBlock<T> NDataBlock<T>::Sub(T b) const
@@ -517,4 +625,5 @@
 }
 
+//! Substract from a constant and return NDataBlock : NDret = b - ND
 template <class T>
 NDataBlock<T> NDataBlock<T>::SubInv(T b) const
@@ -528,4 +637,5 @@
 }
 
+//! Multiply by a constant and return NDataBlock : NDret = ND * b
 template <class T>
 NDataBlock<T> NDataBlock<T>::Mul(T b) const
@@ -536,4 +646,5 @@
 }
 
+//! Divide by a constant and return NDataBlock : NDret = ND / b
 template <class T>
 NDataBlock<T> NDataBlock<T>::Div(T b) const
@@ -544,4 +655,5 @@
 }
 
+//! Divide from a constant and return NDataBlock : NDret = b / ND
 template <class T>
 NDataBlock<T> NDataBlock<T>::DivInv(T b) const
@@ -555,7 +667,9 @@
 }
 
-////////////////////////////////////////////////////////////////
-//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+NDataBlock;
-
+///////////////////////////////////////////////////////////////////////
+// Pour surcharge de +,-,*,/ : NDataBlock = NDataBlock1+NDataBlock2; //
+///////////////////////////////////////////////////////////////////////
+
+//! Add a NDataBlock and return a NDataBlock: ND = NDthis + NDb
 template <class T>
 NDataBlock<T> NDataBlock<T>::Add(const NDataBlock<T>& b) const
@@ -570,4 +684,5 @@
 }
 
+//! Multiply by a NDataBlock and return a NDataBlock: ND = NDthis * NDb
 template <class T>
 NDataBlock<T> NDataBlock<T>::Mul(const NDataBlock<T>& b) const
@@ -582,4 +697,5 @@
 }
 
+//! Substract a NDataBlock and return a NDataBlock: ND = NDthis - NDb
 template <class T>
 NDataBlock<T> NDataBlock<T>::Sub(const NDataBlock<T>& b) const
@@ -597,4 +713,5 @@
 }
 
+//! Divide by a NDataBlock and return a NDataBlock: ND = NDthis / NDb
 template <class T>
 NDataBlock<T> NDataBlock<T>::Div(const NDataBlock<T>& b) const
Index: /trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 943)
+++ /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 944)
@@ -12,6 +12,19 @@
 namespace SOPHYA {
 
+////////////////////////////////////////////////////////////////
+//// ------------------- Class Bridge ----------------------- //
+////////////////////////////////////////////////////////////////
+/*!
+  \class Bridge
+  \ingroup SysTools
+  This class is use by NDataBlock. It allows sharing of datas
+  with external structures : by example, if you want to connect
+  a Blitz data structure with a NDataBlock or a TMatrix or ...
+  \sa NDataBlock
+*/
+
 // Classe pour permettre de partager des donnees avec 
 // un autre systeme de gestion de references (ex avec Blitz)
+//! Empty class which allows data sharing with external structures (for NDataBlock)
 class Bridge {
 public:
@@ -20,9 +33,19 @@
 };
 
+////////////////////////////////////////////////////////////////
+//// ----------------- Class NDataBlock --------------------- //
+////////////////////////////////////////////////////////////////
+
 // classe de container avec partage de reference
+//! Container of data with reference sharing
 template <class T>
 class NDataBlock : public AnyDataObj {
 
 public:
+
+  // Methodes statiques pour debug.
+  static void SetPrintDebug(int prtdbglevel=1);
+  static void ResetDebug(size_t nallocdata=0, size_t nallocsref=0);
+  static void PrintDebug();
 
   // Creation / destruction 
@@ -35,5 +58,7 @@
 
   // Temporaire?
+  //! Return true if data block is temporay
   inline bool IsTemp(void) const {return mIsTemp;}
+  //! Set temporary caracter of data block
   inline void SetTemp(bool temp=false) const {mIsTemp = temp;}
 
@@ -43,4 +68,5 @@
   void Share(const NDataBlock<T>& a);
   void FillFrom(size_t n,T* data);
+  //! Re-set all data values to \b v
   inline void Reset(T v=0)
          {if(mSz==0) return; T *p=Begin(),*pe=End(); while(p<pe) *p++=v;}
@@ -50,4 +76,7 @@
   // et le nouveau tableau mis a zero. La nouvelle structure de
   // donnees n'a qu'une reference (celle de cette classe).
+  //! Re-size the data structure
+  /*! Old datas are lost (for this class). The new values are set to zero.
+    The new data structure has only one reference (itself!). */
   inline void ReSize(size_t n) {Alloc(n);}
 
@@ -55,19 +84,30 @@
   
   // Informations pointeur/data
+  //! Return pointer on data structure.
   inline T* Data()
          {if(mSRef) return mSRef->data; else return NULL;}
+  //! Return pointer on data structure.
   inline T* Data() const
          {if(mSRef) return mSRef->data; else return NULL;}
+  //! Return the size of the data structure
   inline size_t Size() const    {return mSz;}
+  //! Return the \b i th element of  the data structure
   inline T& operator()(size_t i)       {return *(mSRef->data+i);}
+  //! Return the \b i th element of  the data structure
   inline T  operator()(size_t i) const {return *(mSRef->data+i);}
+  //! Return pointer to the beginning of the data structure.
   inline T*        Begin()        {return mSRef->data;}
+  //! Return pointer to the beginning of the data structure.
   inline T const*  Begin() const  {return mSRef->data;} 
+  //! Return pointer to the end of the data structure.
   inline T*        End()          {return mSRef->data+mSz;}
+  //! Return pointer to the end of the data structure.
   inline T const*  End() const    {return mSRef->data+mSz;}
+  //! Return the number of references to the data structure
   inline size_t NRef() const {if(mSRef) return 0; else return mSRef->nref;}
 
   // Impression
   void Print(ostream& os, size_t i1=0,size_t n=10) const;
+  //! print infos and datas (from \b i1 to \b i2) on stdout.
   inline void Print(size_t i1=0,size_t n=0) const {Print(cout,i1,n);}
 
@@ -106,58 +146,78 @@
 
 protected:
-  typedef struct {size_t nref; T* data; Bridge* bridge; } NDREF;
+  //! NDREF structure for reference management
+  typedef struct {
+    size_t nref;      //!< Number of references to the data structure
+    T* data;          //!< Pointer to data structure itself
+    Bridge* bridge;   //!< Pointer to a bridge for the data structure
+  } NDREF;
 
   void Alloc(size_t n,T* data=NULL,Bridge* br=NULL, bool zero=true);
   void Delete(void);
 
-  size_t       mSz;
-  NDREF*       mSRef;
-  mutable bool mIsTemp;
+  static int Debug_NDataBlock; //!< DEBUG: set debug level (all type<T> classes)
+  static size_t NallocData; //!< DEBUG: number of allocations (all type<T> classes)
+  static size_t NallocSRef; //!< DEBUG: number of references (all type<T> classes)
+
+  size_t       mSz;      //!< size of data structure
+  NDREF*       mSRef;    //!< NDREF structure for reference management
+  mutable bool mIsTemp;  //!< true if class is temporary
 };
 
-
+//! Define operator \<\< for printing
 template<class T>
 inline ostream& operator << (ostream& os, const NDataBlock<T>& a)
                       {a.Print(os); return(os);}
+
+//! Add a constant to datas and return NDataBlock : ND = NDa + b
 template<class T>
 inline NDataBlock<T> operator + (const NDataBlock<T>& a,T b)
                       {return a.Add(b);}
+//! Add a constant to datas and return NDataBlock : ND = b + NDa
 template<class T>
 inline NDataBlock<T> operator + (T b,const NDataBlock<T>& a)
                       {return a.Add(b);}
+//! Substract a constant to datas and return NDataBlock : ND = NDa - b
 template<class T>
 inline NDataBlock<T> operator - (const NDataBlock<T>& a,T b)
                       {return a.Sub(b);}
+//! Substract a constant to datas and return NDataBlock : ND = b - NDa
 template<class T>
 inline NDataBlock<T> operator - (T b,const NDataBlock<T>& a)
                       {return a.SubInv(b);}
+//! Multiply datas by a constant and return NDataBlock : ND = NDa * b
 template<class T>
 inline NDataBlock<T> operator * (const NDataBlock<T>& a,T b)
                       {return a.Mul(b);}
+//! Multiply datas by a constant and return NDataBlock : ND = b * NDa
 template<class T>
 inline NDataBlock<T> operator * (T b,const NDataBlock<T>& a)
                       {return a.Mul(b);}
+//! Divide datas by a constant and return NDataBlock : ND = NDa / b
 template<class T>
 inline NDataBlock<T> operator / (const NDataBlock<T>& a,T b)
                       {return a.Div(b);}
+//! Divide a constant by datas and return NDataBlock : ND = b / NDa
 template<class T>
 inline NDataBlock<T> operator / (T b,const NDataBlock<T>& a)
                       {return a.DivInv(b);}
 
+//! Add datas of two data blocks and return NDataBlock : ND = NDa + NDb
 template<class T>
 inline NDataBlock<T> operator + (const NDataBlock<T>& a,const NDataBlock<T>& b)
                       {return a.Add(b);}
+//! Substract datas of two data blocks and return NDataBlock : ND = NDa - NDb
 template<class T>
 inline NDataBlock<T> operator - (const NDataBlock<T>& a,const NDataBlock<T>& b)
                       {return a.Sub(b);}
+//! Multiply datas of two data blocks and return NDataBlock : ND = NDa * NDb
 template<class T>
 inline NDataBlock<T> operator * (const NDataBlock<T>& a,const NDataBlock<T>& b)
                       {return a.Mul(b);}
+//! Divide datas of two data blocks and return NDataBlock : ND = NDa / NDb
 template<class T>
 inline NDataBlock<T> operator / (const NDataBlock<T>& a,const NDataBlock<T>& b)
                       {return a.Div(b);}
 
-
-
 } // Fin du namespace
 
