plDataValues.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plDataValues.h
 * Author         : Juan-Manuel Ahuactzin
 * Creation       : Tue Jan 29 10:40:44 2002
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *   
 *   
 *-----------------------------------------------------------------------------
 */

#ifndef _plDataValues_h_
#define _plDataValues_h_


#include <plData.h>

#ifdef macintosh
#include <sys/malloc.h>
#else
#include <malloc.h>
#endif


#ifdef PL_USE_ATHAPASCAN
#include <athapascan-1>
#endif


#define THIERRY_DV
#define PL_USE_ALLOCA


//#define TRACE_DV

/*****************************************************************************
 *                           External Classes
 *****************************************************************************/
class kplVariable;

/*****************************************************************************
 *                           Classes Definitions
 *****************************************************************************/

//=============================================================================

#ifndef RAVI_INTERFACE
#ifdef THIERRY_DV

#ifndef PL_USE_ALLOCA
#define PL_DEF_LOCAL_PL_DATA_VALUE(name, theSize) \
  plData pt_values##name[theSize];          \
  plDataValues name((theSize), pt_values##name, true);
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_TYPE(name, theSize, theType) \
  plData pt_values##name[(theSize)];                     \
  plDataValues name((theSize), pt_values##name, theType, true);
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_VAR_LIST(name, theVarList) \
  plData pt_values##name[(theVarList).size()];             \
  plDataValues name((theVarList), pt_values##name, true);

#else

#define PL_DEF_LOCAL_PL_DATA_VALUE(name, theSize) \
  plData* pt_values##name = (plData*)alloca( sizeof(plData) * (theSize)); \
  plDataValues name((theSize), pt_values##name, true);
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_TYPE(name, theSize, theType) \
  plData* pt_values##name = (plData*)alloca( sizeof(plData) * (theSize)); \
  plDataValues name((theSize), pt_values##name, (theType), true);
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_VAR_LIST(name, theVarList) \
  plData* pt_values##name = (plData*)alloca( sizeof(plData) * (theVarList).size()); \
  plDataValues name((theVarList), pt_values##name, true);

#endif //PL_USE_ALLOCA

#else
#define PL_DEF_LOCAL_PL_DATA_VALUE(name, theSize) \
  plDataValues name;\
  name.resize(theSize);
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_TYPE(name, theSize, theType) \
  plDataValues name((theSize), (theType));
#define PL_DEF_LOCAL_PL_DATA_VALUE_WITH_VAR_LIST(name, theVarList) \
  plDataValues name((theVarList), NULL, false);
#endif

// A {\em plDataValues} is an array of {\em plData} used to store the values of
//a set of {\em plVariablesConjunction}s.
class plDataValues //:public plObject
{
protected:
 
  void Output(ostream &out) const;

  //=============================================================================
  void set(const list <kplVariable*> &variables_list);
  
public:

  //=============================================================================
  inline plDataValues()
#ifdef THIERRY_DV
    : v(0), onstack(false), sz(0), psz(0)
#else
      : v()
#endif
  {
#ifdef TRACE_DV
    cout << "plDataValues()" << endl;
#endif
  }

  //=============================================================================
  inline plDataValues( unsigned int sizev, plData* ptr, bool onstackv )
#ifdef THIERRY_DV
    : v(ptr), onstack(onstackv), sz(sizev), psz(sizev)
#else
      : v( sizev )
#endif
  {
#ifdef TRACE_DV
    cout << "plDataValues(unsigned int size, plData* ptr, bool stack): size = " << sizev << endl;
#endif
    
#ifdef THIERRY_DV
    
    unsigned int i;
    
    if ((ptr ==0) && (sizev >0)) {
      v = (plData*)malloc( sizeof(plData)*sizev);
      onstack = false;
      for (i=0; i<sizev; ++i)
    new (&v[i]) plData();
    }
#ifdef PL_USE_ALLOCA
    if (ptr !=0) {
      for (i=0; i<sizev; ++i)
    new (&v[i]) plData();
    }
#endif
    
#else
#endif
  }

  //=============================================================================
  inline plDataValues( unsigned int sizev)
#ifdef THIERRY_DV
    :sz(sizev), psz(sizev)
#else
      : v(sizev)
#endif
  {
#ifdef TRACE_DV
    cout << ":plDataValues(unsigned int sizev)" << endl;
#endif
    
#ifdef THIERRY_DV
    v = (plData*)malloc( sizeof(plData)*sizev);
    onstack = false;
    for (unsigned int i=0; i<sizev; ++i)
      new (&v[i]) plData();
#endif
  }

  //=============================================================================
  inline plDataValues(unsigned int sizev, plData::plData_type the_type)
#ifdef THIERRY_DV
    :sz(sizev), psz(sizev)
  {
    v = (plData*)malloc( sizeof(plData)*sizev);
    onstack = false;
    for (unsigned int i=0; i<sizev; ++i){
      new (&v[i]) plData();
      v[i].data_type = the_type;
    }
    
  }
#else
  {
    unsigned int i;
    resize(sizev);
    
    for(i=0;i<sizev;i++){
      v[i].data_type = the_type;
    }
    
  }
#endif

  //=============================================================================
  inline plDataValues(unsigned int sizev, plData* ptr, plData::plData_type the_type, 
              bool stack)
#ifdef THIERRY_DV
    : v(ptr), onstack(stack), sz(sizev), psz(sizev)
#else
      : v( sizev )
#endif
  {
    unsigned int i;
    
#ifdef TRACE_DV
    cout << "plDataValues(unsigned int sizev, plData* ptr, plData_type the_type, bool stack)" << endl;
#endif
    
#ifdef THIERRY_DV
    if ((ptr ==0) && (sizev >0))
      {
    v = (plData*)malloc( sizeof(plData)*sizev);
    onstack = false;
    for (i=0; i<sizev; ++i){
      new (&v[i]) plData();
      v[i].data_type = the_type;
    }
      }
    if (ptr !=0){
      for (i=0; i<sizev; ++i){
#ifdef PL_USE_ALLOCA
    new (&v[i]) plData();
#endif
    v[i].data_type = the_type;  
      }
    }
#else
#endif
  }

  //=============================================================================
  plDataValues(const list <kplVariable*> &variables_list);


  //=============================================================================
  plDataValues(const list <kplVariable*> &variables_list, 
           plData* ptr, bool stack);
  
    
  //=============================================================================
  inline ~plDataValues()
  {
#ifdef THIERRY_DV
    if ((v !=0) && (!onstack)) free(v);
#endif
  }
  
  //=============================================================================
#if 1//def THIERRY_DV
  inline plDataValues(const plDataValues& pd )
#ifdef THIERRY_DV
    : v(0), onstack(false), sz(pd.sz), psz(pd.sz)
  {
#ifdef TRACE_DV
    cout << "plDataValues(const plDataValues& pd )" << endl;
#endif
    
    if (sz > 0) {
      v = (plData*)malloc( sizeof(plData)*sz);
      unsigned int i=0;
      for (; i<sz; ++i)
    new (&v[i]) plData(pd.v[i]);
    }
  }
#else
  : v(pd.v)
  {
  }
#endif

  //=============================================================================
  inline plDataValues& operator=(const plDataValues& pd )
  {
#ifdef TRACE_DV
    cout << "operator= size() = " << size() << " pd.size() = " << pd.size() << endl;
#endif
    
#ifdef THIERRY_DV
    if (psz < pd.sz) {
      if ((v !=0) && (!onstack)) 
    free(v);
      v = (plData*)malloc( sizeof(plData)*pd.sz);
      onstack = false;
      psz = sz = pd.sz; 
      for (unsigned int i=0; i<sz; ++i)
    new (&v[i]) plData(pd.v[i]);
      
    }
    else {
      /* because no operator= over plData, this case should never be used ? 
       */
      sz = pd.sz;
      memcpy(v, 
         pd.v,
         sz*sizeof(plData));
    }
#else
    v = pd.v;
#endif
    return *this;
  }
#endif
  
  
  inline void deliver_values(const vector <pair <int,int> > &key_box, 
                 plDataValues &addressee_value) const
  {
    unsigned int i;
    for(i=0;i<key_box.size();i++){
      /* the key box contains in "first" the addresse position and in 
     "second" the source position */
      addressee_value.v[ key_box[i].first] = v[key_box[i].second];
    }
    
  }

  
#ifdef THIERRY_DV
  plData* v;
public:
  bool    onstack;
  size_t  sz;   /* user size */
  size_t  psz;  /* physical size */
public:
#else
  vector <plData> v;
#endif
  
  //=============================================================================
  inline void resize(const int &new_size)
  {
#ifdef TRACE_DV
    cout << "plDataValues::resize(const int &new_size)" << endl;
#endif
      
#ifdef THIERRY_DV
    size_t ns = (size_t)new_size;
    if (psz >= ns) {
      sz = ns; return;
    }
    plData* newv = (plData*)malloc( sizeof(plData)*ns);
    unsigned int i;
    if (sz >0) {
      for (i=0; i<sz; ++i)
    new (&newv[i]) plData(v[i]);
      for (; i<ns; ++i)
    new (&newv[i]) plData();
    }
    else {
      for (i=0; i<ns; ++i)
    new (&newv[i]) plData();
    }
    if ((v !=0) && (!onstack))
      free(v);
    v = newv;
    onstack = false;
    psz = sz = ns;
#else
    v.resize(new_size);
#endif
  }

  //=============================================================================
  inline unsigned int size() const 
  {
#ifdef THIERRY_DV
    return sz;
#else
    return(v.size());
#endif
  }
  
  //=============================================================================
  inline bool operator==(const plDataValues &value) const
  {
    if (size() != value.size())
      return(false);
      
    unsigned int i;
    unsigned int values_size = size();
      
    for(i=0;i<values_size;i++)
      {
    if (! (v[i] == value.v[i])){
      return false;
    }
      }
    return(true);
  }
  
  //=============================================================================
    inline bool operator!=(const plDataValues &value) const
  {
    return !(*this == value);
  }


  inline plData& operator[](unsigned int i){return v[i];}
  inline const plData& operator[](unsigned int i) const {return v[i];}

  inline bool operator < (const plDataValues &b ) const
  {
    unsigned int i = 0;
    while(i < size()){
      if (v[i] < b.v[i]) {return true;}
      if (v[i] > b.v[i]) {return false;}
      i++ ;
    }
    return false;
  }
  
  inline bool operator >= (const plDataValues &b ) const {return !(*this < b);}
  
  inline bool operator > (const plDataValues &b ) const
  {
    unsigned int i = 0;
    while(i < size()){
      if (v[i] > b.v[i]) {return true;}
      if (v[i] < b.v[i]) {return false;}
      i++ ;
    }
    return false;
  }
  
  inline bool operator <= (const plDataValues &b ) const {return !(*this > b);}
  
  
  //=============================================================================
  friend inline void concatenate (plDataValues &result, 
                  const plDataValues &Values1, 
                  const plDataValues &Values2)
  {
#ifdef THIERRY_DV
    unsigned int values1_size = Values1.sz*sizeof(plData);
    unsigned int values2_size = Values2.sz*sizeof(plData);
      
    memcpy(result.v, 
       Values1.v,
       values1_size);
    memcpy(result.v + Values1.sz,
       Values2.v, 
       values2_size);
      
#else
    result.v = Values1.v;
    result.v.insert(result.v.end(),
            Values2.v.begin(),
            Values2.v.end());
#endif
  }


  //=============================================================================
  inline void extract(plDataValues &result, unsigned int start, unsigned int n)const
  {
#ifdef THIERRY_DV
    memcpy(result.v, 
       v+start,
       n*sizeof(plData));
#else
    for(unsigned int i = 0; i < n; i++)
      result.v[i] = v[start+i];
#endif
  }
  
  friend class plComputableObject;
  friend class kplGibbsSampler;
  friend class kplMCGenerator;

  friend ostream &operator<<(ostream &out, const plDataValues &data){
    data.Output(out);
    return out;
  }

#ifdef PL_USE_ATHAPASCAN
  friend a1::OStream& operator<< ( a1::OStream& o, const plDataValues& pv );
  friend a1::IStream& operator>> ( a1::IStream& o, plDataValues& pv );

#endif

};

#endif

#endif

---