source: Sophya/trunk/SophyaLib/BaseTools/ndatablock.h@ 258

#ifndef NDATABLOCK_H
#define NDATABLOCK_H

#include "machdefs.h"

// Classe pour permettre de partager des donnees avec 
// un autre systeme de gestion de references (ex avec Blitz)
class Bridge {
public:
  Bridge() { } 
  virtual ~Bridge() { }
};

// classe de container avec partage de reference
template <class T>
class NDataBlock {

public:

  // Creation / destruction 
  NDataBlock(size_t n);
  NDataBlock(size_t n, T* data, Bridge* br=NULL);
  NDataBlock();
  NDataBlock(NDataBlock<T>& a);
  NDataBlock(NDataBlock<T>& a,bool share);
  virtual ~NDataBlock();

  // Temporaire?
  inline bool IsTemp(void)       {return mIsTemp;}
  inline void SetTemp(bool temp) {mIsTemp=temp;}

  // Gestion taille/Remplissage
  void Clone(NDataBlock<T>& a);
  void ReSize(size_t n);
  void FillFrom(size_t n,T* data);
  
  // Informations pointeur/data
  inline T* Data()
         {if(mSRef) return mSRef->data; else return NULL;}
  inline size_t Size() const    {return mSz;}
  inline T& operator()(size_t i) {return *(mSRef->data+i);}

  inline T*        Begin()        {return mSRef->data;}
  inline T const*  Begin() const  {return mSRef->data;}
  inline T*        End()          {return mSRef->data+mSz;}
  inline T const*  End() const    {return mSRef->data+mSz;}

  // Impression
  void Print(size_t i1=0,size_t n=0);

  // Surcharge d operateurs
  NDataBlock<T>& operator = (NDataBlock<T>& a);
  NDataBlock<T>& operator = (T v);

  NDataBlock<T>& operator += (T b);
  NDataBlock<T>& operator -= (T b);
  NDataBlock<T>& operator *= (T b);
  NDataBlock<T>& operator /= (T b);

  NDataBlock<T>& operator += (NDataBlock<T>& a);
  NDataBlock<T>& operator -= (NDataBlock<T>& a);
  NDataBlock<T>& operator *= (NDataBlock<T>& a);
  NDataBlock<T>& operator /= (NDataBlock<T>& a);

  NDataBlock<T>& Add(T b);
  NDataBlock<T>& Sub(T b);
  NDataBlock<T>& SubInv(T b);
  NDataBlock<T>& Mul(T b);
  NDataBlock<T>& Div(T b);
  NDataBlock<T>& DivInv(T b);

  NDataBlock<T>& Add(const NDataBlock<T>& b);
  NDataBlock<T>& Sub(const NDataBlock<T>& b);
  NDataBlock<T>& SubInv(const NDataBlock<T>& b);
  NDataBlock<T>& Mul(const NDataBlock<T>& b);
  NDataBlock<T>& Div(const NDataBlock<T>& b);
  NDataBlock<T>& DivInv(const NDataBlock<T>& b);

protected:

  typedef struct {size_t nref; T* data; Bridge* bridge; } NDREF;

  void Alloc(size_t n,T* data=NULL,Bridge* br=NULL);
  void Share(NDataBlock<T>& a);
  void Delete(void);

  size_t   mSz;
  NDREF*   mSRef;
  bool     mIsTemp;
};


template<class T> inline NDataBlock<T> operator + (const NDataBlock<T>& a,T b)
                                                  {return a.Add(b);}
template<class T> inline NDataBlock<T> operator + (T b,const NDataBlock<T>& a)
                                                  {return a.Add(b);}
template<class T> inline NDataBlock<T> operator - (const NDataBlock<T>& a,T b)
                                                  {return a.Sub(b);}
template<class T> inline NDataBlock<T> operator - (T b,const NDataBlock<T>& a)
                                                  {return a.SubInv(b);}
template<class T> inline NDataBlock<T> operator * (const NDataBlock<T>& a,T b)
                                                  {return a.Mul(b);}
template<class T> inline NDataBlock<T> operator * (T b,const NDataBlock<T>& a)
                                                  {return a.Mul(b);}
template<class T> inline NDataBlock<T> operator / (const NDataBlock<T>& a,T b)
                                                  {return a.Div(b);}
template<class T> inline NDataBlock<T> operator / (T b,const NDataBlock<T>& a)
                                                  {return a.DivInv(b);}

template<class T> inline NDataBlock<T> operator + (const NDataBlock<T>& a,const NDataBlock<T>& b)
                                                  {return a.Add(b);}
template<class T> inline NDataBlock<T> operator - (const NDataBlock<T>& a,const NDataBlock<T>& b)
                                                  {return a.Sub(b);}
template<class T> inline NDataBlock<T> operator * (const NDataBlock<T>& a,const NDataBlock<T>& b)
                                                  {return a.Mul(b);}
template<class T> inline NDataBlock<T> operator / (const NDataBlock<T>& a,const NDataBlock<T>& b)
                                                  {return a.Div(b);}


#endif