Index: /trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 274)
+++ /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 275)
@@ -13,5 +13,5 @@
 using namespace PlanckDPC;
 
-//define DEBUG_NDATABLOCK
+// define DEBUG_NDATABLOCK
 
 #ifdef DEBUG_NDATABLOCK
@@ -24,4 +24,5 @@
 //   - gestion du partage de reference
 
+////////////////////////////////////////////////////////////////
 //************ Createur, Destructeur, gestion des donnees
 
@@ -41,4 +42,5 @@
 NDataBlock<T>::NDataBlock(size_t n, T* data, Bridge* br)
 // Createur d'une structure de "n" donnees, avec donnees preallouees
+//  (Voir explications dans Alloc())
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
@@ -101,4 +103,6 @@
 }
 
+////////////////////////////////////////////////////////////////
+
 template <class T>
 void NDataBlock<T>::SetTemp(bool temp) const 
@@ -116,19 +120,23 @@
 void NDataBlock<T>::Alloc(size_t n,T* data,Bridge* br)
 // Allocation d'un NOUVEL espace de stoquage
-// Si data==NULL : allocation de l'espace memoire
+// Si data==NULL : allocation de l'espace memoire (vide)
 //    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)
+//    br!=NULL   : les donnees ne nous appartiennent pas (ex: Blitz)
+//
 // Exemple: on veut connecter a un tableau de T*
-// -- On veut que NDataBlock ne desalloue pas le tableau
-//   float *x = new float[5]; ... remplissage de x[] ...;
-//   NDataBlock A(5,x,new Bridge);
-//   delete [] x;   // Il faut deleter explicitement
-// -- On veut que NDataBlock desalloue le tableau
-//          ( Ne Pas Faire "delete [] x;" )
-//   float *x = new float[5]; ... remplissage de x[] ...;
-//   NDataBlock A(5,x);
-//   -- Autre solution:
-//   NDataBlock A(5); A.FillFrom(5,x);
+// 1- On veut que NDataBlock NE DESALLOUE PAS le tableau "data"
+//    a- Premiere solution
+//       float *x = new float[5]; ... remplissage de x[] ...;
+//       NDataBlock A(5,x,new Bridge);
+//       delete [] x;   // Il faut deleter explicitement
+//       (et Bridge est delete par le destructeur de la classe)
+//    b- Autre solution:
+//       NDataBlock A(5); A.FillFrom(5,x);
+//       delete [] x;   // Il faut deleter explicitement
+// 2- On veut que NDataBlock desalloue le tableau
+//       float *x = new float[5]; ... remplissage de x[] ...;
+//       NDataBlock A(5,x);
+//       (Ne Pas Faire "delete [] x;")
 {
 #ifdef DEBUG_NDATABLOCK
@@ -138,4 +146,6 @@
 #endif
 
+if(br && !data)
+  throw(NullPtrError("NDataBlock::Alloc br!=NULL && data==NULL\n"));
 if(n==0) throw(SzMismatchError("NDataBlock::Alloc n==0\n"));
 if(mSRef) Delete();
@@ -147,5 +157,9 @@
 
 #ifdef DEBUG_NDATABLOCK
-if(!data) NallocData++; NallocSRef++;
+// 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<<"...DEBUG_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
     <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
@@ -158,10 +172,12 @@
 void NDataBlock<T>::Clone(const NDataBlock<T>& a)
 // Clone (copie de donnee) a partir de "a"
-{
-    #ifdef DEBUG_NDATABLOCK
-    cout<<"DEBUG_NDataBlock::Clone("<<this<<","<<&a<<") a.(mSz="
-        <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
-        <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-    #endif
+// sauf si "a" est une classe temporaire (dans ce cas share!)
+{
+#ifdef DEBUG_NDATABLOCK
+cout<<"DEBUG_NDataBlock::Clone("<<this<<","<<&a<<") a.(mSz="
+    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
+    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
+#endif
+
 if(!a.mSRef) {mSz=0; mSRef=NULL;} // cas ou "a" est cree par defaut
 else if(a.IsTemp()) Share(a);
@@ -212,5 +228,5 @@
 #ifdef DEBUG_NDATABLOCK
 cout<<"...DEBUG_NDataBlock::Delete() pas de desallocation il reste nref="
-    <<mSRef->nref<<endl;
+    <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
 
@@ -232,4 +248,6 @@
 }
 
+////////////////////////////////////////////////////////////////
+
 template <class T>
 void NDataBlock<T>::Reset(T v)
@@ -243,9 +261,9 @@
 
 template <class T>
-void NDataBlock<T>::ReSize(size_t n)
-// Re-dimension, dans ce cas re-allocation de la place
-{
-// Pas de realloc, si pas de changement de taille ?
-if (n == mSz)  return;  // $CHECK$ A verifier , Reza 26/04/99
+void NDataBlock<T>::ReSize(size_t n,bool force_alloc)
+// Re-dimension, avec re-allocation de la place si n != mSz
+// Si n==mSz, la place n'est re-allouee que si force_alloc=true
+{
+if(!force_alloc && n == mSz)  return;
 Alloc(n);
 }
@@ -264,4 +282,5 @@
 }
 
+////////////////////////////////////////////////////////////////
 //**** Impression
 
@@ -287,4 +306,5 @@
 }
 
+////////////////////////////////////////////////////////////////
 //**** Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; 
 
@@ -324,4 +344,6 @@
 return *this;
 }
+
+////////////////////////////////////////////////////////////////
 
 template <class T>
@@ -349,4 +371,5 @@
 }
 
+////////////////////////////////////////////////////////////////
 //**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += <T> b;
 
@@ -388,4 +411,6 @@
 }
 
+
+////////////////////////////////////////////////////////////////
 //**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += NDataBlock;
 
@@ -434,5 +459,8 @@
 }
 
-//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b; NDataBlock = <T>b+NDataBlock;
+
+////////////////////////////////////////////////////////////////
+//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b;
+//                            NDataBlock = <T>b+NDataBlock;
 // ATTENTION: re-affectation imposee
 
@@ -492,4 +520,6 @@
 }
 
+
+////////////////////////////////////////////////////////////////
 //**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+NDataBlock;
 
@@ -566,5 +596,5 @@
 }
 
-
+////////////////////////////////////////////////////////////////
 // -------------------------------------------------------------------------
 //   Les objets delegues pour la gestion de persistance 
@@ -644,5 +674,5 @@
 }
 
-
+///////////////////////////////////////////////////////////////
 #ifdef __CXX_PRAGMA_TEMPLATES__
 #pragma define_template NDataBlock<uint_1>
@@ -658,5 +688,4 @@
 #pragma define_template NDataBlock< complex<float> >
 #pragma define_template NDataBlock< complex<double> >
-
 // Instances des delegues FileIO (PPersist)
 #pragma define_template FIO_NDataBlock<uint_1>
@@ -672,5 +701,4 @@
 #pragma define_template FIO_NDataBlock< complex<float> >
 #pragma define_template FIO_NDataBlock< complex<double> >
-
 #endif
 
@@ -689,5 +717,4 @@
 template class NDataBlock< complex<float> >;
 template class NDataBlock< complex<double> >;
-
 // Instances des delegues FileIO (PPersist)
 template class FIO_NDataBlock<uint_1>;
Index: /trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 274)
+++ /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 275)
@@ -42,5 +42,5 @@
   void Clone(const NDataBlock<T>& a);
   void Reset(T v=0);
-  void ReSize(size_t n);
+  void ReSize(size_t n,bool force_alloc=false);
   void FillFrom(size_t n,T* data);
   
