source: Sophya/trunk/SophyaLib/BaseTools/ndatablock.cc@ 265

#include "machdefs.h"
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <complex>
#include "pexceptions.h"
#include "ndatablock.h"

#define DEBUG_NDATABLOCK

#ifdef DEBUG_NDATABLOCK
  static size_t NallocData = 0;
  static size_t NallocSRef = 0;
#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

template <class T>
NDataBlock<T>::NDataBlock(size_t n)
// Createur d'une structure de "n" donnees
: mSz(0), mSRef(NULL), mIsTemp(false)
{
Alloc(n);
}

template <class T>
NDataBlock<T>::NDataBlock(size_t n, T* data, Bridge* br)
// Createur d'une structure de "n" donnees, avec donnees preallouees
: mSz(0), mSRef(NULL), mIsTemp(false)
{
Alloc(n,data,br);
}

template <class T>
NDataBlock<T>::NDataBlock()
// Createur par default
: mSz(0), mSRef(NULL), mIsTemp(false)
{
}

template <class T>
NDataBlock<T>::NDataBlock(NDataBlock<T>& a)
// Createur par copie
// ATTENTION: partage les donnees avec "a"
// Ecriture: NDataBlock a = b;
//           NDataBlock a(b)
: mSz(0), mSRef(NULL), mIsTemp(false)
{
Share(a);
}

template <class T>
NDataBlock<T>::NDataBlock(NDataBlock<T>& a,bool share)
// Createur avec choix de partager ou non
: mSz(0), mSRef(NULL), mIsTemp(false)
{
if(share) Share(a); else Clone(a);
}

template <class T>
NDataBlock<T>::~NDataBlock()
// Destructeur
{
Delete();
}

template <class T>
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
//    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*
// -- 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);
{
    #ifdef DEBUG_NDATABLOCK
    cout<<"DEBUG_NDataBlock::Alloc("
        <<n<<","<<data<<","<<br<<") mSRef="<<mSRef<<endl;
    #endif
if(n==0) throw(SzMismatchError("NDataBlock::Alloc n==0\n"));
if(mSRef) Delete();
mSz = n;
mSRef = new NDREF;
mSRef->nref = 1;
if(data) mSRef->data = data; else mSRef->data = new T[n];
mSRef->bridge = br;
    #ifdef DEBUG_NDATABLOCK
    if(!data) NallocData++; NallocSRef++;
    cout<<"...DEBUG_NDataBlock::Alloc("<<n<<") mSRef="<<mSRef
        <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data
        <<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
    #endif
}

template <class T>
void NDataBlock<T>::Clone(NDataBlock<T>& a)
// Clone (copie de donnee) a partir de "a"
{
    #ifdef DEBUG_NDATABLOCK
    cout<<"DEBUG_NDataBlock::Clone("<<&a<<") a.mSz="
        <<a.mSz<<" a.mSRef="<<a.mSRef<<" a.IsTemp="<<a.IsTemp()<<endl;
    #endif
if(!a.mSRef) {mSz=0; mSRef=NULL;} // cas ou "a" est cree par defaut
else if(a.IsTemp()) Share(a);
else {Alloc(a.mSz); memcpy(Data(),a.Data(),mSz*sizeof(T));}
}

template <class T>
void NDataBlock<T>::Share(NDataBlock<T>& a)
// Partage des donnees avec "a"
{
    #ifdef DEBUG_NDATABLOCK
    cout<<"DEBUG_NDataBlock::Share("<<&a<<") a.mSRef="<<a.mSRef<<" mSRef="<<mSRef<<endl;
    #endif
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(mSRef) Delete();
mSz = a.mSz; mSRef = a.mSRef; mSRef->nref++;
    #ifdef DEBUG_NDATABLOCK
    cout<<"...DEBUG_NDataBlock::Share("<<&a<<") mSRef="<<mSRef
        <<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<< mSRef->data<<endl;
    #endif
}

template <class T>
void NDataBlock<T>::Delete(void)
// Pour detruire les pointeurs en tenant compte des references
{
    #ifdef DEBUG_NDATABLOCK
    cout<<"DEBUG_NDataBlock::Delete() mSRef="<<mSRef;
    if(mSRef) cout<<" mSRef->nref="<<mSRef->nref<<" mSRef->data="<<mSRef->data;
    cout<<endl;
    #endif
if(mSRef==NULL) return; // cas du createur par defaut
mSRef->nref--;
if(mSRef->nref != 0) {
    #ifdef DEBUG_NDATABLOCK
      cout<<"...DEBUG_NDataBlock::Delete() pas de desallocation il reste nref="
          <<mSRef->nref<<endl;
    #endif
  return;
}
    #ifdef DEBUG_NDATABLOCK
    if(!mSRef->bridge) NallocData--; NallocSRef--;
    cout<<"...DEBUG_NDataBlock::Delete() desallocation complete il reste nref="
        <<mSRef->nref<<" Total("<<NallocData<<","<<NallocSRef<<")"<<endl;
    #endif
// Si il y a un Bridge les donnees ne n'appartiennent pas, on detruit le Bridge
if(mSRef->bridge) delete mSRef->bridge; 
// sinon, les donnees ont ete allouees par nos soins, on libere l'espace memoire
else delete [] mSRef->data; 
mSRef->bridge=NULL; mSRef->data=NULL;
delete mSRef; mSRef=NULL;
}

template <class T>
void NDataBlock<T>::Reset(T v)
{
if(mSRef==NULL) return;
if(mSRef->data==NULL) return;
if(mSz==0) return;
T *p=Begin(), *pe=End();
while(p<pe) *p++ = v;
}

template <class T>
void NDataBlock<T>::ReSize(size_t n)
// Re-dimension, dans ce cas re-allocation de la place
{
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
{
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(mSz<n) n= mSz;
memcpy(Data(),data,n*sizeof(T));
}

//**** Impression

template <class T>
void NDataBlock<T>::Print(size_t i1,size_t n)
// Impression de n elements a partir de i1
{
size_t nr = 0;
T* p = NULL;
if(mSRef) {nr = mSRef->nref; p = mSRef->data;}
cout<<"NDataBlock::Print nel="<<mSz<<" nref="<<nr<<" ("<<p<<")"<<endl;
if(i1>=mSz || n<=0 || !p) return;
size_t i2 = i1+n; if(i2>mSz) i2=mSz;
size_t im = 1; bool enl;
while(i1<i2) {
  enl = false;
  cout<<" "<<(*this)(i1);  i1++;
  if(im==10) {cout<<"\n"; im=1; enl=true;} else im++;
}
if(!enl) cout<<endl;
}

//**** Surcharge de = : NDataBlock=NDataBlock; NDataBlock=<T> b; 

template <class T>
NDataBlock<T>& NDataBlock<T>::operator = (NDataBlock<T>& a)
// surcharge avec partage des donnees
// Ecriture:  NDataBlock a; a = b;
//            NDataBlock a(10); a = b; (a est re-affecte)
{
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;
{
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;

template <class T>
NDataBlock<T>& NDataBlock<T>::operator += (T b)
{
if(mSz==0) throw(SzMismatchError("NDataBlock::operator+=v null size\n"));
T *p=Begin(), *pe=End();
while (p<pe) *p++ += b;
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator -= (T b)
{
if(mSz==0) throw(SzMismatchError("NDataBlock::operator-=v null size\n"));
T *p=Begin(), *pe=End();
while (p<pe) *p++ -= b;
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator *= (T b)
{
if(mSz==0) throw(SzMismatchError("NDataBlock::operator*=v null size\n"));
T *p=Begin(), *pe=End();
while (p<pe) *p++ *= b;
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator /= (T b)
{
if(b==(T) 0) throw(ParmError("NDataBlock::operator/=v divide by zero\n"));
if(mSz==0) throw(SzMismatchError("NDataBlock::operator/=v null size\n"));
T *p=Begin(), *pe=End();
while (p<pe) *p++ /= b;
return *this;
}

//**** Surcharge de +=,-=,*=,/= (INPLACE): NDataBlock += NDataBlock;

template <class T>
NDataBlock<T>& NDataBlock<T>::operator += (NDataBlock<T>& a)
{
if(mSz==0 || mSz!=a.mSz)
  throw(SzMismatchError("NDataBlock::operator+=A size mismatch/null"));
T *p=Begin(), *pe=End(), *pa=a.Begin();
while (p<pe) *p++ += *pa++; // ca marche meme si *this=a
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator -= (NDataBlock<T>& a)
{
if(mSz==0 || mSz!=a.mSz)
  throw(SzMismatchError("NDataBlock::operator-=A size mismatch/null"));
T *p=Begin(), *pe=End(), *pa=a.Begin();
while (p<pe) *p++ -= *pa++; // ca marche meme si *this=a
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator *= (NDataBlock<T>& a)
{
if(mSz==0 || mSz!=a.mSz)
  throw(SzMismatchError("NDataBlock::operator*=A size mismatch/null"));
T *p=Begin(), *pe=End(), *pa=a.Begin();
while (p<pe) *p++ *= *pa++; // ca marche meme si *this=a
return *this;
}

template <class T>
NDataBlock<T>& NDataBlock<T>::operator /= (NDataBlock<T>& a)
{
if(mSz==0 || mSz!=a.mSz)
  throw(SzMismatchError("NDataBlock::operator/=A size mismatch/null"));
T *p=Begin(), *pe=End(), *pa=a.Begin();
while (p<pe) *p++ /= *pa++;
return *this;
}

//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+<T>b; NDataBlock = <T>b+NDataBlock;
// ATTENTION: re-affectation imposee

template <class T>
NDataBlock<T> NDataBlock<T>::Add(T b)
// Pour A+b
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
return result += b;
}

template <class T>
NDataBlock<T> NDataBlock<T>::Sub(T b)
// Pour A-b
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
return result -= b;
}

template <class T>
NDataBlock<T> NDataBlock<T>::SubInv(T b)
// Pour b-A
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
while(p<pe) {*p++ = b - *pa++;}
return result;
}

template <class T>
NDataBlock<T> NDataBlock<T>::Mul(T b)
// Pour A*b
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
return result *= b;
}

template <class T>
NDataBlock<T> NDataBlock<T>::Div(T b)
// Pour A/b
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
return result /= b;
}

template <class T>
NDataBlock<T> NDataBlock<T>::DivInv(T b)
// Pour b/A
{
NDataBlock<T>& a = *this;
NDataBlock<T> result(a,false); result.SetTemp(true);
T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
while(p<pe) {*p++ = b / *pa++;}
return result;
}

//**** Surcharge de +,-,*,/ : NDataBlock = NDataBlock+NDataBlock;

template <class T>
NDataBlock<T> NDataBlock<T>::Add(NDataBlock<T>& b)
// Pour A+B
{
NDataBlock<T>& a = *this;
if(a.mSz!=b.mSz)
  throw(SzMismatchError("NDataBlock operator C=A+B size mismatch/null\n"));
if(b.IsTemp()) {
  NDataBlock<T> result(b,true); result.SetTemp(true);
  return result += a;
} else {
  NDataBlock<T> result(a,false); result.SetTemp(true);
  return result += b;
}
}

template <class T>
NDataBlock<T> NDataBlock<T>::Mul(NDataBlock<T>& b)
// Pour A*B
{
NDataBlock<T>& a = *this;
if(a.mSz!=b.mSz)
  throw(SzMismatchError("NDataBlock operator C=A*B size mismatch/null\n"));
if(b.IsTemp()) {
  NDataBlock<T> result(b,true); result.SetTemp(true);
  return result *= a;
} else {
  NDataBlock<T> result(a,false); result.SetTemp(true);
  return result *= b;
}
}

template <class T>
NDataBlock<T> NDataBlock<T>::Sub(NDataBlock<T>& b)
// Pour A-B
{
NDataBlock<T>& a = *this;
if(a.mSz!=b.mSz)
  throw(SzMismatchError("NDataBlock operator C=A-B size mismatch/null\n"));
if(b.IsTemp()) {
  NDataBlock<T> result(b,true); result.SetTemp(true);
  T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
  while(p<pe) {*p = *pa++  - *p; p++;}
  return result;
} else {
  NDataBlock<T> result(a,false); result.SetTemp(true);
  return result -= b;
}
}

template <class T>
NDataBlock<T> NDataBlock<T>::Div(NDataBlock<T>& b)
// Pour A/B
{
NDataBlock<T>& a = *this;
if(a.mSz!=b.mSz)
  throw(SzMismatchError("NDataBlock operator C=A/B size mismatch/null\n"));
if(b.IsTemp()) {
  NDataBlock<T> result(b,true); result.SetTemp(true);
  T *p=result.Begin(), *pe=result.End(), *pa=a.Begin();
  while(p<pe) {*p = *pa++  / *p; p++;}
  return result;
} else {
  NDataBlock<T> result(a,false); result.SetTemp(true);
  return result /= b;
}
}


#ifdef __CXX_PRAGMA_TEMPLATES__
#pragma define_template NDataBlock<uint_1>
#pragma define_template NDataBlock<uint_2>
#pragma define_template NDataBlock<int_2>
#pragma define_template NDataBlock<int_4>
#pragma define_template NDataBlock<int_8>
#pragma define_template NDataBlock<uint_2>
#pragma define_template NDataBlock<uint_4>
#pragma define_template NDataBlock<uint_8>
#pragma define_template NDataBlock<r_4>
#pragma define_template NDataBlock<r_8>
// pas de definitions de cout pour les complex ??
//#pragma define_template NDataBlock< complex<float> >
//#pragma define_template NDataBlock< complex<double> >
#endif

#ifdef __GNU_TEMPLATES__
template class NDataBlock<uint_1>;
template class NDataBlock<uint_2>;
template class NDataBlock<int_2>;
template class NDataBlock<int_4>;
template class NDataBlock<int_8>;
template class NDataBlock<uint_2>;
template class NDataBlock<uint_4>;
template class NDataBlock<uint_8>;
template class NDataBlock<r_4>;
template class NDataBlock<r_8>;
template class NDataBlock< complex<float> >;
template class NDataBlock< complex<double> >;
#endif

#if defined(__ANSI_TEMPLATES__) 
template class NDataBlock<uint_1>;
template class NDataBlock<uint_2>;
template class NDataBlock<int_2>;
template class NDataBlock<int_4>;
template class NDataBlock<int_8>;
template class NDataBlock<uint_2>;
template class NDataBlock<uint_4>;
template class NDataBlock<uint_8>;
template class NDataBlock<r_4>;
template class NDataBlock<r_8>;
template class NDataBlock< complex<float> >;
template class NDataBlock< complex<double> >;
#endif