Index: /trunk/SophyaLib/BaseTools/ndatablock.cc
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 288)
+++ /trunk/SophyaLib/BaseTools/ndatablock.cc	(revision 289)
@@ -20,10 +20,6 @@
 #endif
 
-// LOGIQUE DE BASE:
-//   - le createur par copie et la surcharge de l operateur = "partage" les donnees
-//   - gestion du partage de reference
-
-////////////////////////////////////////////////////////////////
-//************ Createur, Destructeur, gestion des donnees
+////////////////////////////////////////////////////////////////
+//************ Createur, Destructeur
 
 template <class T>
@@ -33,5 +29,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",n="<<n<<")"<<endl;
+cout<<"?_NDataBlock::NDataBlock("<<this<<",n="<<n<<")"<<endl;
 #endif
 
@@ -46,5 +42,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::NDataBlock("<<this
+cout<<"?_NDataBlock::NDataBlock("<<this
     <<",data="<<data<<",br="<<br<<")"<<endl;
 #endif
@@ -59,5 +55,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<") default"<<endl;
+cout<<"?_NDataBlock::NDataBlock("<<this<<") default"<<endl;
 #endif
 }
@@ -65,27 +61,21 @@
 template <class T>
 NDataBlock<T>::NDataBlock(const NDataBlock<T>& a)
-// Createur par copie
-// ATTENTION: partage les donnees avec "a"
-// Ecriture: NDataBlock a = b;
-//           NDataBlock a(b)
+// Createur par copie: partage les donnees si "a" temporaire, clone sinon.
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<") a.(mSz="
-    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()<<")"<<endl;
-#endif
-
-Share(a);
+cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<")"<<endl;
+#endif
+
+CloneOrShare(a);
 }
 
 template <class T>
 NDataBlock<T>::NDataBlock(const NDataBlock<T>& a,bool share)
-// Createur avec choix de partager ou non
-// Si "a" temporaire alors partage meme si share=false
+// Createur avec choix de partager ou non selon "share"
 : mSz(0), mSRef(NULL), mIsTemp(false)
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<",sh=<<"<<share<<")"
-    <<" a.(mSz="<<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()<<")"<<endl;
+cout<<"?_NDataBlock::NDataBlock("<<this<<",&a="<<&a<<",sh=<<"<<share<<")"<<endl;
 #endif
 
@@ -98,5 +88,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::~NDataBlock("<<this<<")"<<endl;
+cout<<"?_NDataBlock::~NDataBlock("<<this<<")"<<endl;
 #endif
 
@@ -105,16 +95,5 @@
 
 ////////////////////////////////////////////////////////////////
-
-template <class T>
-void NDataBlock<T>::SetTemp(bool temp) const 
-// Set temporary
-{
-mIsTemp=temp;
-
-#ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::SetTemp("<<this<<","<<temp
-    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
-}
+//************ Gestion de donnees
 
 template <class T>
@@ -142,5 +121,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::Alloc("<<this<<","
+cout<<"?_NDataBlock::Alloc("<<this<<","
     <<n<<","<<data<<","<<br<<") mSz="<<mSz
     <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
@@ -164,5 +143,5 @@
 // fait au niveau du dessus!).
 if(!br) NallocData++; NallocSRef++;
-cout<<"...DEBUG_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
+cout<<"...?_NDataBlock::Alloc mSz="<<mSz<<" mSRef="<<mSRef
     <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
     <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp
@@ -173,24 +152,36 @@
 template <class T>
 void NDataBlock<T>::Clone(const NDataBlock<T>& a)
-// Clone (copie de donnee) a partir de "a"
-// sauf si "a" est une classe temporaire (dans ce cas share!)
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::Clone("<<this<<","<<&a<<") a.(mSz="
+// 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.mSz==0) throw(SzMismatchError("NDataBlock::Clone a.mSz==0\n"));
-else if(a.IsTemp()) Share(a);
-else {Alloc(a.mSz); memcpy(Data(),a.Data(),mSz*sizeof(T));}
+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);
+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)
-// Partage des donnees avec "a"
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::Share("<<this<<","<<&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()<<")";
@@ -199,11 +190,10 @@
 
 if(&a==NULL) throw(NullPtrError("NDataBlock::Share  &a==NULL\n"));
-// on ne peut partager si "a" pas alloue
-if(!a.mSRef) throw(NullPtrError("NDataBlock::Share not allocated a\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<<"...DEBUG_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
+cout<<"...?_NDataBlock::Share mSz="<<mSz<<" mSRef="<<mSRef
     <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
     <<" mSRef->bridge="<<mSRef->bridge<<" IsTemp="<<mIsTemp<<endl;
@@ -216,5 +206,5 @@
 {
 #ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::Delete("<<this<<") mSz="<<mSz
+cout<<"?_NDataBlock::Delete("<<this<<") mSz="<<mSz
     <<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp;
 if(mSRef)
@@ -224,10 +214,10 @@
 #endif
 
-if(mSRef==NULL) return; // cas du createur par defaut
+if(mSRef==NULL) return;
 mSRef->nref--;
 if(mSRef->nref != 0) {
 
 #ifdef DEBUG_NDATABLOCK
-cout<<"...DEBUG_NDataBlock::Delete() pas de desallocation il reste nref="
+cout<<"...?_NDataBlock::Delete() pas de desallocation il reste nref="
     <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
@@ -239,5 +229,5 @@
 #ifdef DEBUG_NDATABLOCK
 if(!mSRef->bridge) NallocData--; NallocSRef--;
-cout<<"...DEBUG_NDataBlock::Delete() desallocation complete il reste nref="
+cout<<"...?_NDataBlock::Delete() desallocation complete il reste nref="
     <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
 #endif
@@ -250,31 +240,14 @@
 }
 
-////////////////////////////////////////////////////////////////
-
-template <class T>
-void NDataBlock<T>::Reset(T v)
-{
-if(mSRef==NULL || mSRef->data==NULL || mSz==0) return;
-T *p=Begin(), *pe=End(); while(p<pe) *p++ = v;
-}
-
-template <class T>
-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);
-}
-
 template <class T>
 void NDataBlock<T>::FillFrom(size_t n,T* data)
 // Remplissage par un tableau de donnees
 // - Si classe vide : creation de l'espace memoire
-// - Si classe connectee : on ecrit selon la longueur
+// - Si classe connectee : on ecrit selon la longueur minimale
+//                         (cad this->mSz ou "n")
 {
 if(data==NULL) throw(NullPtrError("NDataBlock::FillFrom  data==NULL\n"));
 if(n==0) throw(ParmError("NDataBlock::FillFrom  n<=0\n"));
-if(mSRef==NULL) Alloc(n); // cas du createur par default
+if(mSRef==NULL) Alloc(n);
 if(mSz<n) n = mSz;
 memcpy(Data(),data,n*sizeof(T));
@@ -306,43 +279,4 @@
 
 ////////////////////////////////////////////////////////////////
-//**** Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; 
-
-template <class T>
-NDataBlock<T>& NDataBlock<T>::operator = (const NDataBlock<T>& a)
-// surcharge avec partage des donnees
-// Ecriture:  NDataBlock a; a = b;
-//            NDataBlock a(10); a = b; (a est re-affecte)
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::operator=("<<this<<","<<&a<<") a.(mSz="
-    <<a.mSz<<" mSRef="<<a.mSRef<<" IsTemp="<<a.IsTemp()
-    <<"), mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
-
-if(this == &a) return *this;
-if(a.mSz!=mSz)
-  throw(SzMismatchError("NDataBlock::operator=A size mismatch/null\n"));
-Share(a);
-return *this;
-}
-
-template <class T>
-NDataBlock<T>& NDataBlock<T>::operator = (T v)
-// surcharge avec copie des donnees (pas de partage)
-// "this" est sur-ecrit, attention au partage de reference!
-// NDataBlock a; a = v; ou bien NDataBlock a(10); a = v;
-{
-#ifdef DEBUG_NDATABLOCK
-cout<<"DEBUG_NDataBlock::operator=("<<this<<","<<v<<")"
-    <<" mSz="<<mSz<<" mSRef="<<mSRef<<" IsTemp="<<mIsTemp<<endl;
-#endif
-
-if(mSz==0) throw(SzMismatchError("NDataBlock::operator=v null size\n"));
-T *p=Begin(), *pe=End();
-while (p<pe) *p++ = v;
-return *this;
-}
-
-////////////////////////////////////////////////////////////////
 
 template <class T>
@@ -371,4 +305,39 @@
 
 ////////////////////////////////////////////////////////////////
+//**** Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; 
+
+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(this == &a) return *this;
+if(a.mSz==0)
+  throw(SzMismatchError("NDataBlock::operator=A null size\n"));
+CloneOrShare(a);
+return *this;
+}
+
+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(mSz==0) throw(SzMismatchError("NDataBlock::operator=v null size\n"));
+T *p=Begin(), *pe=End();
+while (p<pe) *p++ = v;
+return *this;
+}
+
+////////////////////////////////////////////////////////////////
 //**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += <T> b;
 
@@ -410,5 +379,4 @@
 }
 
-
 ////////////////////////////////////////////////////////////////
 //**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += NDataBlock;
@@ -421,5 +389,5 @@
 T *p=Begin(), *pe=End();
 T const * pa=a.Begin();
-while (p<pe) *p++ += *pa++; // ca marche meme si *this=a
+while (p<pe) *p++ += *pa++;
 return *this;
 }
@@ -432,5 +400,5 @@
 T *p=Begin(), *pe=End();
 T const *pa=a.Begin();
-while (p<pe) *p++ -= *pa++; // ca marche meme si *this=a
+while (p<pe) *p++ -= *pa++;
 return *this;
 }
@@ -443,5 +411,5 @@
 T *p=Begin(), *pe=End();
 T const *pa=a.Begin();
-while (p<pe) *p++ *= *pa++; // ca marche meme si *this=a
+while (p<pe) *p++ *= *pa++;
 return *this;
 }
@@ -449,4 +417,5 @@
 template <class T>
 NDataBlock<T>& NDataBlock<T>::operator /= (const NDataBlock<T>& a)
+// Attention, aucune protection si un element de "a" est nul.
 {
 if(mSz==0 || mSz!=a.mSz)
@@ -461,5 +430,4 @@
 //**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b;
 //                            NDataBlock = <T>b+NDataBlock;
-// ATTENTION: re-affectation imposee
 
 template <class T>
@@ -467,5 +435,5 @@
 // Pour A+b
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 result += b;
 return result;
@@ -476,5 +444,5 @@
 // Pour A-b
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 return result -= b;
 }
@@ -484,5 +452,5 @@
 // Pour b-A
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 T *p=result.Begin(), *pe=result.End();
 T const *pa=this->Begin();
@@ -495,5 +463,5 @@
 // Pour A*b
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 return result *= b;
 }
@@ -503,5 +471,5 @@
 // Pour A/b
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 return result /= b;
 }
@@ -511,5 +479,5 @@
 // Pour b/A
 {
-NDataBlock<T> result(*this,false); result.SetTemp(true);
+NDataBlock<T> result(*this); result.SetTemp(true);
 T *p=result.Begin(), *pe=result.End();
 T const *pa = this->Begin();
@@ -518,5 +486,4 @@
 }
 
-
 ////////////////////////////////////////////////////////////////
 //**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+NDataBlock;
@@ -529,11 +496,6 @@
   throw(SzMismatchError("NDataBlock operator C=A+B size mismatch/null\n"));
 NDataBlock<T> result; result.SetTemp(true);
-if(b.IsTemp()) {
-  result.Share(b);
-  result += *this;
-} else {
-  result.Clone(*this);
-  result += b;
-}
+if(b.IsTemp()) {result.Share(b);            result += *this;}
+  else         {result.CloneOrShare(*this); result += b;}
 return result;
 }
@@ -546,11 +508,6 @@
   throw(SzMismatchError("NDataBlock operator C=A*B size mismatch/null\n"));
 NDataBlock<T> result; result.SetTemp(true);
-if(b.IsTemp()) {
-  result.Share(b);
-  result *= *this;
-} else {
-  result.Clone(*this);
-  result *= b;
-}
+if(b.IsTemp()) {result.Share(b);            result *= *this;}
+  else         {result.CloneOrShare(*this); result *= b;}
 return result;
 }
@@ -565,11 +522,7 @@
 if(b.IsTemp()) {
   result.Share(b);
-  T *p=result.Begin(), *pe=result.End();
-  T const *pa=Begin();
+  T *p=result.Begin(), *pe=result.End(); T const *pa=Begin();
   while(p<pe) {*p = *pa++  - *p; p++;}
-} else {
-  result.Clone(*this);
-  result -= b;
-}
+} else {result.CloneOrShare(*this); result -= b;}
 return result;
 }
@@ -584,11 +537,7 @@
 if(b.IsTemp()) {
   result.Share(b);
-  T *p=result.Begin(), *pe=result.End();
-  T const *pa=Begin();
+  T *p=result.Begin(), *pe=result.End(); T const *pa=Begin();
   while(p<pe) {*p = *pa++  / *p; p++;}
-} else {
-  result.Clone(*this);
-  result /= b;
-}
+} else {result.CloneOrShare(*this); result /= b;}
 return result;
 }
@@ -659,5 +608,5 @@
 is.Get(itab, 3);
 if (dobj == NULL) dobj = new NDataBlock<T>(itab[1]);
-else dobj->ReSize(itab[1], false);
+else dobj->ReSize(itab[1]);
 // On lit le tableau de nombres
 PIOSReadArray(is, dobj->Data(), dobj->Size()); 
@@ -707,5 +656,4 @@
 #endif
 
-
 #if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
 template class NDataBlock<uint_1>;
Index: /trunk/SophyaLib/BaseTools/ndatablock.h
===================================================================
--- /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 288)
+++ /trunk/SophyaLib/BaseTools/ndatablock.h	(revision 289)
@@ -37,11 +37,14 @@
   // Temporaire?
   inline bool IsTemp(void) const {return mIsTemp;}
-  void SetTemp(bool temp=false) const;
+  inline void SetTemp(bool temp=false) const {mIsTemp = temp;}
 
   // Gestion taille/Remplissage
   void Clone(const NDataBlock<T>& a);
-  void Reset(T v=0);
-  void ReSize(size_t n,bool force_alloc=true);
+  void CloneOrShare(const NDataBlock<T>& a);
+  void Share(const NDataBlock<T>& a);
   void FillFrom(size_t n,T* data);
+  inline void Reset(T v=0)
+         {if(mSz==0) return; T *p=Begin(),*pe=End(); while(p<pe) *p++=v;}
+  inline void ReSize(size_t n) {Alloc(n);}
   
   // Informations pointeur/data
@@ -53,5 +56,4 @@
   inline T& operator()(size_t i)       {return *(mSRef->data+i);}
   inline T  operator()(size_t i) const {return *(mSRef->data+i);}
-
   inline T*        Begin()        {return mSRef->data;}
   inline T const*  Begin() const  {return mSRef->data;} 
@@ -67,5 +69,5 @@
   T Product(size_t i1=0,size_t n=0) const;
 
-  // Surcharge d operateurs
+  // Surcharge d'operateurs INPLACE: A = x , A = B , A @= x , A @= B
   NDataBlock<T>& operator = (const NDataBlock<T>& a);
   NDataBlock<T>& operator = (T v);
@@ -81,4 +83,5 @@
   NDataBlock<T>& operator /= (const NDataBlock<T>& a);
 
+  // Surcharge d'operateurs: C = A @ x , C = A @ B
   NDataBlock<T> Add(T b) const;
   NDataBlock<T> Sub(T b) const;
@@ -99,5 +102,4 @@
 
   void Alloc(size_t n,T* data=NULL,Bridge* br=NULL);
-  void Share(const NDataBlock<T>& a);
   void Delete(void);
 
@@ -153,15 +155,12 @@
 template <class T>
 class FIO_NDataBlock : public  PPersist  {
-
 public:
-	    FIO_NDataBlock();
-	    FIO_NDataBlock(string const & filename); 
-	    FIO_NDataBlock(const NDataBlock<T> & obj);
-	    FIO_NDataBlock(NDataBlock<T> * obj);
-  virtual   ~FIO_NDataBlock();
-
-  virtual   AnyDataObj* DataObj();
+  FIO_NDataBlock();
+  FIO_NDataBlock(string const & filename); 
+  FIO_NDataBlock(const NDataBlock<T> & obj);
+  FIO_NDataBlock(NDataBlock<T> * obj);
+  virtual ~FIO_NDataBlock();
+  virtual AnyDataObj* DataObj();
   inline operator NDataBlock<T>() { return(*dobj); }
-
 protected :
   virtual void       ReadSelf(PInPersist&);           
