Changeset 2699 in Sophya


Ignore:
Timestamp:
Apr 27, 2005, 1:48:19 PM (20 years ago)
Author:
ansari
Message:

1/ Corrections diverses ds BaseDataTable, en particulier GetSegment() -> GetCstSegment(), et ameliorations/debug divers
2/ Classe SWPPFDataTable debugge, rendu +/- operationnelle
3/ Gestionnaire PPersist de DataTable et SWPPFDataTable fusionnee en une seule
classe ObjFileIO<BaseDataTable> - mis ds fio_dtable.cc
4/ mis a jour histats.h avec swppfdtable.h, objlist.list et histinit.cc

Reza, 27 Avril 2005

Location:
trunk/SophyaLib/HiStats
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/HiStats/basedtable.cc

    r2693 r2699  
    117117sa_size_t BaseDataTable::IndexNom(char const* nom) const
    118118{
    119   for(sa_size_t k=0; k<NVar(); k++)
    120     if ( mNames[k].nom == nom )  return k;
    121   throw NotFoundExc("BaseDataTable::IndexNom() : column name not found ");
     119  for(sa_size_t k=0; k<NVar(); k++)
     120    if ( mNames[k].nom == nom )      return k;
     121  return -1;
     122  // Reza:Avril 2005 : PINtuple se base sur le renvoi de -1 et pas d'une exception
     123  //  throw NotFoundExc("BaseDataTable::IndexNom() : column name not found ");
    122124}
    123125
    … …  
    202204  sa_size_t off = n%mSegSz;
    203205  for(sa_size_t k=0; k<mIColsP.size(); k++)
    204     mVarMTV[mIColIdx[k]] = mIColsP[k]->GetSegment(bid)[off];
     206    mVarMTV[mIColIdx[k]] = mIColsP[k]->GetCstSegment(bid)[off];
    205207  for(sa_size_t k=0; k<mLColsP.size(); k++)
    206     mVarMTV[mLColIdx[k]] = mLColsP[k]->GetSegment(bid)[off];
     208    mVarMTV[mLColIdx[k]] = mLColsP[k]->GetCstSegment(bid)[off];
    207209  for(sa_size_t k=0; k<mFColsP.size(); k++)
    208     mVarMTV[mFColIdx[k]] = mFColsP[k]->GetSegment(bid)[off];
     210    mVarMTV[mFColIdx[k]] = mFColsP[k]->GetCstSegment(bid)[off];
    209211  for(sa_size_t k=0; k<mDColsP.size(); k++)
    210     mVarMTV[mDColIdx[k]] = mDColsP[k]->GetSegment(bid)[off];
     212    mVarMTV[mDColIdx[k]] = mDColsP[k]->GetCstSegment(bid)[off];
    211213  for(sa_size_t k=0; k<mSColsP.size(); k++)
    212     mVarMTV[mSColIdx[k]] = atof(mSColsP[k]->GetSegment(bid)[off].c_str());
     214    mVarMTV[mSColIdx[k]] = atof(mSColsP[k]->GetCstSegment(bid)[off].c_str());
    213215
    214216  return mVarMTV;
    … …  
    307309  sa_size_t off = n%mSegSz;
    308310  for(sa_size_t k=0; k<mIColsP.size(); k++)
    309     mVarD[mIColIdx[k]] = mIColsP[k]->GetSegment(bid)[off];
     311    mVarD[mIColIdx[k]] = mIColsP[k]->GetCstSegment(bid)[off];
    310312  for(sa_size_t k=0; k<mLColsP.size(); k++)
    311     mVarD[mLColIdx[k]] = mLColsP[k]->GetSegment(bid)[off];
     313    mVarD[mLColIdx[k]] = mLColsP[k]->GetCstSegment(bid)[off];
    312314  for(sa_size_t k=0; k<mFColsP.size(); k++)
    313     mVarD[mFColIdx[k]] = mFColsP[k]->GetSegment(bid)[off];
     315    mVarD[mFColIdx[k]] = mFColsP[k]->GetCstSegment(bid)[off];
    314316  for(sa_size_t k=0; k<mDColsP.size(); k++)
    315     mVarD[mDColIdx[k]] = mDColsP[k]->GetSegment(bid)[off];
     317    mVarD[mDColIdx[k]] = mDColsP[k]->GetCstSegment(bid)[off];
    316318  for(sa_size_t k=0; k<mSColsP.size(); k++)
    317     mVarD[mSColIdx[k]] = atof(mSColsP[k]->GetSegment(bid)[off].c_str());
     319    mVarD[mSColIdx[k]] = atof(mSColsP[k]->GetCstSegment(bid)[off].c_str());
    318320
    319321  return mVarD;
    … …  
    326328  if ((n < 0) || (n >= NEntry()))
    327329    throw RangeCheckError("BaseDataTable::GetCell() out of range line index n");
    328   if ((k < 0) || (n >= NVar()))
     330  if ((k < 0) || (k >= NVar()))
    329331    throw RangeCheckError("BaseDataTable::GetCell() out of range column index k");
    330332  double rv = BADVAL;
    … …  
    332334  sa_size_t bid = n/mSegSz;
    333335  sa_size_t off = n%mSegSz;
     336
    334337  switch (mNames[k].type) {
    335338  case IntegerField :
    336     rv = mIColsP[sk]->GetSegment(bid)[off];
     339    rv = mIColsP[sk]->GetCstSegment(bid)[off];
    337340    break;
    338341  case LongField :
    339     rv = mLColsP[sk]->GetSegment(bid)[off];
     342    rv = mLColsP[sk]->GetCstSegment(bid)[off];
    340343    break;
    341344  case FloatField :
    342     rv = mFColsP[sk]->GetSegment(bid)[off];
     345    rv = mFColsP[sk]->GetCstSegment(bid)[off];
    343346    break;
    344347  case DoubleField :
    345     rv = mDColsP[sk]->GetSegment(bid)[off];
     348    rv = mDColsP[sk]->GetCstSegment(bid)[off];
    346349    break;
    347350  case StringField :
    348     rv = atof(mSColsP[sk]->GetSegment(bid)[off].c_str());
     351    rv = atof(mSColsP[sk]->GetCstSegment(bid)[off].c_str());
    349352    break;
    350353  default:
    … …  
    365368  if ((n < 0) || (n >= NEntry()))
    366369    throw RangeCheckError("BaseDataTable::GetCell() out of range line index n");
    367   if ((k < 0) || (n >= NVar()))
     370  if ((k < 0) || (k >= NVar()))
    368371    throw RangeCheckError("BaseDataTable::GetCell() out of range column index k");
    369372  MuTyV rv;;
    … …  
    373376  switch (mNames[k].type) {
    374377  case IntegerField :
    375     rv = mIColsP[sk]->GetSegment(bid)[off];
     378    rv = mIColsP[sk]->GetCstSegment(bid)[off];
    376379    break;
    377380  case LongField :
    378     rv = mLColsP[sk]->GetSegment(bid)[off];
     381    rv = mLColsP[sk]->GetCstSegment(bid)[off];
    379382    break;
    380383  case FloatField :
    381     rv = mFColsP[sk]->GetSegment(bid)[off];
     384    rv = mFColsP[sk]->GetCstSegment(bid)[off];
    382385    break;
    383386  case DoubleField :
    384     rv = mDColsP[sk]->GetSegment(bid)[off];
     387    rv = mDColsP[sk]->GetCstSegment(bid)[off];
    385388    break;
    386389  case StringField :
    387     rv = atof(mSColsP[sk]->GetSegment(bid)[off].c_str());
     390    rv = mSColsP[sk]->GetCstSegment(bid)[off];
    388391    break;
    389392  default:
    … …  
    420423  case IntegerField :
    421424    for(size_t is=0; is<mIColsP[sk]->NbSegments(); is++) {
    422       int_4* sp = mIColsP[sk]->GetSegment(is);
     425      const int_4* sp = mIColsP[sk]->GetCstSegment(is);
    423426      for(size_t n=0; n<mIColsP[sk]->SegmentSize(); n++) {
    424427        if (cnt >= NEntry())  break;
    … …  
    432435  case LongField :
    433436    for(size_t is=0; is<mLColsP[sk]->NbSegments(); is++) {
    434       int_8* sp = mLColsP[sk]->GetSegment(is);
     437      const int_8* sp = mLColsP[sk]->GetCstSegment(is);
    435438      for(size_t n=0; n<mLColsP[sk]->SegmentSize(); n++) {
    436439        if (cnt >= NEntry())  break;
    … …  
    443446  case FloatField :
    444447    for(size_t is=0; is<mFColsP[sk]->NbSegments(); is++) {
    445       r_4* sp = mFColsP[sk]->GetSegment(is);
     448      const r_4* sp = mFColsP[sk]->GetCstSegment(is);
    446449      for(size_t n=0; n<mFColsP[sk]->SegmentSize(); n++) {
    447450        if (cnt >= NEntry())  break;
    … …  
    454457  case DoubleField :
    455458    for(size_t is=0; is<mDColsP[sk]->NbSegments(); is++) {
    456       r_8* sp = mDColsP[sk]->GetSegment(is);
     459      const r_8* sp = mDColsP[sk]->GetCstSegment(is);
    457460      for(size_t n=0; n<mDColsP[sk]->SegmentSize(); n++) {
    458461        if (cnt >= NEntry())  break;
    … …  
    524527string BaseDataTable::LineHeaderToString() const
    525528{
    526   char buff[32];
    527   string rets=" Num    ";
     529  string rets,s;
     530 
    528531  for(int i=0; i<NVar(); i++) {
    529     sprintf(buff, "%8s ", NomIndex(i).c_str() );
    530     rets += buff;
    531   }
    532   rets += '\n';
     532    s = mNames[i].nom;
     533    s += ' ';
     534    size_t l = s.length();
     535    for(size_t ii=l; ii<10; ii++) s += ' ';
     536    rets += s;
     537  }
    533538  return(rets); 
    534539}
    … …  
    547552    switch (mNames[k].type) {
    548553    case IntegerField :
    549       rv = mIColsP[sk]->GetSegment(bid)[off];
     554      rv = mIColsP[sk]->GetCstSegment(bid)[off];
    550555      break;
    551556    case LongField :
    552       rv = mLColsP[sk]->GetSegment(bid)[off];
     557      rv = mLColsP[sk]->GetCstSegment(bid)[off];
    553558      break;
    554559    case FloatField :
    555       rv = mFColsP[sk]->GetSegment(bid)[off];
     560      rv = mFColsP[sk]->GetCstSegment(bid)[off];
    556561      break;
    557562    case DoubleField :
    558       rv = mDColsP[sk]->GetSegment(bid)[off];
     563      rv = mDColsP[sk]->GetCstSegment(bid)[off];
    559564      break;
    560565    case StringField :
    561       rv = atof(mSColsP[sk]->GetSegment(bid)[off].c_str());
     566      rv = mSColsP[sk]->GetCstSegment(bid)[off];
    562567    break;
    563568    default:
    … …  
    565570      break;
    566571    }
    567     rs += " ";
    568     rs += (string)rv;
     572    string s = (string)rv;
     573    s += ' ';
     574    size_t l = s.length();
     575    for(size_t ii=l; ii<10; ii++) s += ' ';
     576    rs += s;
    569577  }
    570578  return rs;

  • trunk/SophyaLib/HiStats/basedtable.h

    r2688 r2699  
    8787  //! Copy or merges  the data from \b a into the data table (cp=true -> copy)
    8888  virtual void      CopyMerge(BaseDataTable const& a, bool cp=false) ;
    89   //! Equal (copy) operator
    90   inline BaseDataTable&  operator = (BaseDataTable const& a)
    91   { CopyMerge(a, true) ; return *this ; }
    92    
     89
     90  //! Clear/reset the table content and structure.
     91  virtual void Clear() = 0;
     92
     93  // ---- ASCII I/O
    9394  void              Print(int num, int nmax=1) const ;
    9495 
    … …  
    101102  int               FillFromASCIIFile(string const& fn);
    102103 
    103   // Declaration de l interface NTuple
     104  //-------------------------------------------------------------
     105  //-----------  Declaration de l interface NTuple --------------
     106
    104107  virtual sa_size_t NbLines() const ;
    105108  virtual sa_size_t NbColumns() const ;
    … …  
    115118  virtual string    LineHeaderToString() const;
    116119  virtual string    LineToString(sa_size_t n) const; 
     120
     121  //  Pour la gestion de persistance PPF
     122  friend class ObjFileIO<BaseDataTable> ;
    117123 
    118124protected:

  • trunk/SophyaLib/HiStats/datatable.cc

    r2696 r2699  
    217217}
    218218
    219 /*!
    220    \class SOPHYA::ObjFileIO<DataTable>
    221    \ingroup HiStats
    222    Persistence (serialisation) handler for class DataTable
    223 */
    224 /* --Methode-- */
    225 DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
    226 void   ObjFileIO<DataTable>::WriteSelf(POutPersist& s)  const
    227 //      Serialisation en ecriture du DataTable sur stream PPF
    228 {
    229   if (dobj == NULL)   
    230     throw NullPtrError("ObjFileIO<DataTable>::WriteSelf() NULL dobj pointer ");
    231   //-------  On ecrit 3 uint_4 ....
    232   //  [0]: Numero de version ;
    233   //  [1] : bit1 non nul -> has info 
    234   //  [2] : reserve
    235   uint_4 itab[3];
    236   itab[0] = 1;  // Numero de version a 1
    237   itab[1] = itab[2] = 0;
    238   if (dobj->mInfo)  itab[1] = 1;
    239   s.Put(itab, 3);
    240 
    241   //-------- Ecriture de segment size, nb de colonnes, nb de lignes ... 
    242   // [0] : SegmentSize()        [1] : NVar()
    243   // [2] : NEntry()             [3] : NbSegments()
    244   uint_8 ltab[5];
    245   ltab[0] = dobj->SegmentSize();
    246   ltab[1] = dobj->NVar();
    247   ltab[2] = dobj->NEntry();
    248   ltab[3] = dobj->NbSegments();
    249   ltab[4] = 0;
    250   s.Put(ltab, 5);
    251 
    252   //------ Ecriture du nom et type des colonnes
    253   for(sa_size_t k=0; k<dobj->NVar(); k++) {
    254     uint_2 typ = dobj->mNames[k].type;
    255     s.Put(typ);
    256     s.Put(dobj->mNames[k].nom);
    257   }
    258   // ------- Ecriture des tableaux min,max et n_minmax
    259   for(uint_8 k=0; k<ltab[1]; k++) {
    260     s.Put(dobj->mMin[k]);
    261     s.Put(dobj->mMax[k]);
    262     s.Put(dobj->mMinMaxNEnt[k]);
    263   } 
    264   //------- Ecriture du DVList Info() associe, si existant
    265   if (dobj->mInfo)  s << (*(dobj->mInfo));
    266 
    267   //------- Ecriture des SegDataBlock<T>
    268   for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
    269     sa_size_t sk = dobj->mNames[kk].ser;
    270     switch (dobj->mNames[kk].type) {
    271     case BaseDataTable::IntegerField :
    272       s << dobj->mICols[sk];
    273     break;
    274     case BaseDataTable::LongField :
    275       s << dobj->mLCols[sk];
    276       break;
    277     case BaseDataTable::FloatField :
    278       s << dobj->mFCols[sk];
    279       break;
    280     case BaseDataTable::DoubleField :
    281       s << dobj->mDCols[sk];
    282       break;
    283     case BaseDataTable::StringField :
    284       s << dobj->mSCols[sk];
    285       break;
    286     default:
    287       throw ForbiddenError("ObjFileIO<DataTable>::WriteSelf() : unknown column type ");
    288     break;
    289     }
    290   }   
    291   return;
    292 }
    293 
    294 /* --Methode-- */
    295 DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
    296 void  ObjFileIO<DataTable>::ReadSelf(PInPersist& s)
    297 //      Serialisation en lecture du DataTable sur stream PPF
    298 {
    299   // ------- On lit les 3 premiers uint_4
    300   //  [0]: Numero de version ;
    301   //  [1] : bit1 non nul -> has info 
    302   //  [2] : reserve
    303   uint_4 itab[3] = {0,0,0};
    304   s.Get(itab, 3);
    305   bool hadinfo = false;
    306   if ((itab[1]&1) == 1)  hadinfo = true;
    307 
    308   // -------- Lecture de segment size, nb de colonnes, nb de lignes ... 
    309   // [0] : SegmentSize()        [1] : NVar()
    310   // [2] : NEntry()             [3] : NbSegments()
    311   uint_8 ltab[5] = {0,0,0,0,0};
    312   s.Get(ltab, 5);
    313   if (dobj == NULL) dobj = new DataTable(ltab[0]);
    314   else { dobj->Clear();  dobj->mSegSz = ltab[0]; }
    315   // -------- Lecture nom/type colonnes et allocation des colonnes
    316   uint_2 typ;
    317   string cnom;
    318   for(uint_8 k=0; k<ltab[1]; k++) {
    319     s.Get(typ);
    320     s.Get(cnom);
    321     BaseDataTable::FieldType ft = (BaseDataTable::FieldType)typ;
    322     dobj->AddColumn(ft, cnom);
    323   }
    324   // ------- Lecture des tableaux min,max et n_minmax
    325   for(uint_8 k=0; k<ltab[1]; k++) {
    326     s.Get(dobj->mMin[k]);
    327     s.Get(dobj->mMax[k]);
    328     s.Get(dobj->mMinMaxNEnt[k]);
    329   } 
    330   // ------- Lecture du DVList Info() associe, si necessaire
    331   if (hadinfo) {    // Lecture eventuelle du DVList Info
    332     if (dobj->mInfo == NULL)  dobj->mInfo = new DVList;
    333     s >> (*(dobj->mInfo));
    334   }
    335   // ------- Mise a jour des champs Nb d'entrees, nb segments ...
    336   dobj->mNEnt = ltab[2];
    337   dobj->mNSeg = ltab[3];
    338   // ------- Lecture des SegDataBlock<T>
    339   for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
    340     sa_size_t sk = dobj->mNames[kk].ser;
    341     switch (dobj->mNames[kk].type) {
    342     case BaseDataTable::IntegerField :
    343       s >> dobj->mICols[sk];
    344     break;
    345     case BaseDataTable::LongField :
    346       s >> dobj->mLCols[sk];
    347       break;
    348     case BaseDataTable::FloatField :
    349       s >> dobj->mFCols[sk];
    350       break;
    351     case BaseDataTable::DoubleField :
    352       s >> dobj->mDCols[sk];
    353       break;
    354     case BaseDataTable::StringField :
    355       s >> dobj->mSCols[sk];
    356       break;
    357     default:
    358       throw ForbiddenError("ObjFileIO<DataTable>::ReadSelf() : unknown column type ");
    359     break;
    360     }
    361   }   
    362 return;
    363 }
    364 
    365 #ifdef __CXX_PRAGMA_TEMPLATES__
    366 #pragma define_template ObjFileIO<DataTable>
    367 #endif
    368 
    369 #if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
    370 template class ObjFileIO<DataTable>;
    371 #endif

  • trunk/SophyaLib/HiStats/datatable.h

    r2693 r2699  
    3131
    3232  //  Pour la gestion de persistance PPF
    33   friend class ObjFileIO<DataTable> ;
     33  friend class ObjFileIO<BaseDataTable> ;
    3434  // pour fichiers FITS
    3535  friend class FITS_DataTable;
    3636 
    3737  //! Reset the table content and structure
    38   void Clear();
     38  virtual void Clear();
    3939protected:
    4040  void Share(DataTable const & a);
    … …  
    5151/*! Writes the object in the POutPersist stream \b os */
    5252inline POutPersist& operator << (POutPersist& os, DataTable & obj)
    53 { ObjFileIO<DataTable> fio(&obj);  fio.Write(os);  return(os); }
     53{ ObjFileIO<BaseDataTable> fio(&obj);  fio.Write(os);  return(os); }
    5454/*! Reads the object from the PInPersist stream \b is */
    5555inline PInPersist& operator >> (PInPersist& is, DataTable & obj)
    56 { ObjFileIO<DataTable> fio(&obj); is.SkipToNextObject(); fio.Read(is); return(is); }
     56{ ObjFileIO<BaseDataTable> fio(&obj); is.SkipToNextObject();
     57  fio.Read(is); return(is); }
    5758// Classe pour la gestion de persistance
    58 // ObjFileIO<DataTable>
     59// ObjFileIO<BaseDataTable>
    5960} // namespace SOPHYA
    6061

  • trunk/SophyaLib/HiStats/histats.h

    r2688 r2699  
    1010#include "xntuple.h"
    1111#include "datatable.h"
     12#include "swppfdtable.h"
    1213
    1314#endif // HISTATS_SEEN

  • trunk/SophyaLib/HiStats/histinit.cc

    r2688 r2699  
    1313#include "xntuple.h"
    1414#include "datatable.h"
     15#include "swppfdtable.h"
    1516
    1617/*!
    … …  
    4849  DObjRegister(ObjFileIO<XNTuple>, XNTuple);
    4950
    50   PPRegister(ObjFileIO<DataTable>);
    51   DObjRegister(ObjFileIO<DataTable>, DataTable);
     51  PPRegister(ObjFileIO<BaseDataTable>);
     52  DObjRegister(ObjFileIO<BaseDataTable>, DataTable);
     53  DObjRegister(ObjFileIO<BaseDataTable>, SwPPFDataTable);
    5254
    5355}

  • trunk/SophyaLib/HiStats/objlist.list

    r2688 r2699  
    11basedtable.o
    22datatable.o
     3fio_dtable.o
    34hisprof.o
    45histerr.o
    … …  
    910ntuple.o
    1011proxtuple.o
     12swppfdtable.o
    1113xntuple.o

  • trunk/SophyaLib/HiStats/swppfdtable.cc

    r2696 r2699  
    4646SwPPFDataTable::SwPPFDataTable(POutPersist & os, sa_size_t segsz)
    4747  : BaseDataTable(segsz) ,
    48     mISwapper(os), mLSwapper(os), mFSwapper(os), mDSwapper(os), mSSwapper(os),
    49     mSwOut(&os), mSwIn(NULL)
     48    mSwOut(&os), mSwIn(NULL),
     49    mISwapper(os), mLSwapper(os), mFSwapper(os), mDSwapper(os), mSSwapper(os)
    5050{
    5151}
    … …  
    5353SwPPFDataTable::SwPPFDataTable(PInPersist & is, sa_size_t segsz)
    5454  : BaseDataTable(segsz) ,
    55     mISwapper(is), mLSwapper(is), mFSwapper(is), mDSwapper(is), mSSwapper(is),
    56     mSwOut(NULL), mSwIn(&is)
    57 {
     55    mSwOut(NULL), mSwIn(NULL)
     56{
     57  PInPersist* pis = new PInPersist(is.FileName(), false);
     58  mSwIn = new St_InSwap;
     59  mSwIn->pis = pis;  mSwIn->refcnt = 1;
     60  mISwapper.SetInStream(*pis);
     61  mLSwapper.SetInStream(*pis);
     62  mFSwapper.SetInStream(*pis);
     63  mDSwapper.SetInStream(*pis);
     64  mDSwapper.SetInStream(*pis);
    5865}
    5966
    … …  
    6471{
    6572  Share(a);
     73}
     74//! Destructor - Deletes / closes the input PPF swap stream 
     75SwPPFDataTable::~SwPPFDataTable()
     76{
     77  if (mSwIn) {
     78    mSwIn->refcnt--;
     79    if (mSwIn->refcnt == 0) {
     80      delete mSwIn->pis;
     81      delete mSwIn;
     82      mSwIn = NULL;
     83    }
     84  }
    6685}
    6786
    … …  
    7796  mSwOut = a.mSwOut;
    7897  mSwIn = a.mSwIn;
     98  if (mSwIn)  mSwIn->refcnt++;  // comptage de reference pour le stream input
    7999
    80100  // On recopie la taille de segment
    … …  
    277297}
    278298
    279 /*!
    280    \class SOPHYA::ObjFileIO<SwPPFDataTable>
    281    \ingroup HiStats
    282    Persistence (serialisation) handler for class SwPPFDataTable
    283 */
    284 /* --Methode-- */
    285 DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
    286 void   ObjFileIO<SwPPFDataTable>::WriteSelf(POutPersist& s)  const
    287 //      Serialisation en ecriture du SwPPFDataTable sur stream PPF
    288 {
    289   if (dobj == NULL)   
    290     throw NullPtrError("ObjFileIO<SwPPFDataTable>::WriteSelf() NULL dobj pointer ");
    291   if (dobj->mSwOut != &s)
    292     throw NotAvailableOperation("ObjFileIO<SwPPFDataTable>::WriteSelf() OutputStream <> SwapStream");
    293   //-------  On ecrit 3 uint_4 ....
    294   //  [0]: Numero de version ;
    295   //  [1] : bit1 non nul -> has info 
    296   //  [2] : reserve
    297   uint_4 itab[3];
    298   itab[0] = 1;  // Numero de version a 1
    299   itab[1] = itab[2] = 0;
    300   if (dobj->mInfo)  itab[1] = 1;
    301   s.Put(itab, 3);
    302 
    303   //-------- Ecriture de segment size, nb de colonnes, nb de lignes ... 
    304   // [0] : SegmentSize()        [1] : NVar()
    305   // [2] : NEntry()             [3] : NbSegments()
    306   uint_8 ltab[5];
    307   ltab[0] = dobj->SegmentSize();
    308   ltab[1] = dobj->NVar();
    309   ltab[2] = dobj->NEntry();
    310   ltab[3] = dobj->NbSegments();
    311   ltab[4] = 0;
    312   s.Put(ltab, 5);
    313 
    314   //------ Ecriture du nom et type des colonnes
    315   for(sa_size_t k=0; k<dobj->NVar(); k++) {
    316     uint_2 typ = dobj->mNames[k].type;
    317     s.Put(typ);
    318     s.Put(dobj->mNames[k].nom);
    319   }
    320   // ------- Ecriture des tableaux min,max et n_minmax
    321   for(uint_8 k=0; k<ltab[1]; k++) {
    322     s.Put(dobj->mMin[k]);
    323     s.Put(dobj->mMax[k]);
    324     s.Put(dobj->mMinMaxNEnt[k]);
    325   } 
    326   //------- Ecriture du DVList Info() associe, si existant
    327   if (dobj->mInfo)  s << (*(dobj->mInfo));
    328 
    329   //------- Ecriture des tables de positionnement de SwSegDataBlock<T>
    330   for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
    331     sa_size_t sk = dobj->mNames[kk].ser;
    332     switch (dobj->mNames[kk].type) {
    333     case BaseDataTable::IntegerField :
    334       s.PutPosTagTable(dobj->mICols[sk].GetSwapPosTagTable());
    335       break;
    336     case BaseDataTable::LongField :
    337       s.PutPosTagTable(dobj->mLCols[sk].GetSwapPosTagTable());
    338       break;
    339     case BaseDataTable::FloatField :
    340       s.PutPosTagTable(dobj->mFCols[sk].GetSwapPosTagTable());
    341       break;
    342     case BaseDataTable::DoubleField :
    343       s.PutPosTagTable(dobj->mDCols[sk].GetSwapPosTagTable());
    344       break;
    345     case BaseDataTable::StringField :
    346       s.PutPosTagTable(dobj->mSCols[sk].GetSwapPosTagTable());
    347       break;
    348     default:
    349       throw ForbiddenError("ObjFileIO<SwPPFDataTable>::WriteSelf() : unknown column type ");
    350     break;
    351     }
    352   }   
    353   return;
    354 }
    355 
    356 /* --Methode-- */
    357 DECL_TEMP_SPEC  /* equivalent a template <> , pour SGI-CC en particulier */
    358 void  ObjFileIO<SwPPFDataTable>::ReadSelf(PInPersist& s)
    359 //      Serialisation en lecture du SwPPFDataTable sur stream PPF
    360 {
    361   // ------- On lit les 3 premiers uint_4
    362   //  [0]: Numero de version ;
    363   //  [1] : bit1 non nul -> has info 
    364   //  [2] : reserve
    365   uint_4 itab[3] = {0,0,0};
    366   s.Get(itab, 3);
    367   bool hadinfo = false;
    368   if ((itab[1]&1) == 1)  hadinfo = true;
    369 
    370   // -------- Lecture de segment size, nb de colonnes, nb de lignes ... 
    371   // [0] : SegmentSize()        [1] : NVar()
    372   // [2] : NEntry()             [3] : NbSegments()
    373   uint_8 ltab[5] = {0,0,0,0,0};
    374   s.Get(ltab, 5);
    375   if (dobj == NULL) dobj = new SwPPFDataTable(s, ltab[0]);
    376   else {
    377     // Copie brutale en utilisant l'operateur =
    378      *dobj = SwPPFDataTable(s, ltab[0]);
    379   }
    380   // -------- Lecture nom/type colonnes et allocation des colonnes
    381   uint_2 typ;
    382   string cnom;
    383   for(uint_8 k=0; k<ltab[1]; k++) {
    384     s.Get(typ);
    385     s.Get(cnom);
    386     BaseDataTable::FieldType ft = (BaseDataTable::FieldType)typ;
    387     dobj->AddColumn(ft, cnom);
    388   }
    389   // ------- Lecture des tableaux min,max et n_minmax
    390   for(uint_8 k=0; k<ltab[1]; k++) {
    391     s.Get(dobj->mMin[k]);
    392     s.Get(dobj->mMax[k]);
    393     s.Get(dobj->mMinMaxNEnt[k]);
    394   } 
    395   // ------- Lecture du DVList Info() associe, si necessaire
    396   if (hadinfo) {    // Lecture eventuelle du DVList Info
    397     if (dobj->mInfo == NULL)  dobj->mInfo = new DVList;
    398     s >> (*(dobj->mInfo));
    399   }
    400   // ------- Mise a jour des champs Nb d'entrees, nb segments ...
    401   dobj->mNEnt = ltab[2];
    402   dobj->mNSeg = ltab[3];
    403   cout << " DEBUG___ SegmentSize()= " << dobj->SegmentSize() << endl;
    404   // ------- Lecture des tag de positionnement des SwSegDataBlock<T>
    405   vector<int_8> swpos;
    406   for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
    407     sa_size_t sk = dobj->mNames[kk].ser;
    408     switch (dobj->mNames[kk].type) {
    409     case BaseDataTable::IntegerField :
    410       swpos.clear();
    411       s.GetPosTagTable(swpos);
    412       dobj->mICols[sk] = SwSegDataBlock<int_4>(dobj->mISwapper, swpos, dobj->SegmentSize());
    413     break;
    414     case BaseDataTable::LongField :
    415       swpos.clear();
    416       s.GetPosTagTable(swpos);
    417       dobj->mLCols[sk] = SwSegDataBlock<int_8>(dobj->mLSwapper, swpos, dobj->SegmentSize());
    418       break;
    419     case BaseDataTable::FloatField :
    420       swpos.clear();
    421       s.GetPosTagTable(swpos);
    422       dobj->mFCols[sk] = SwSegDataBlock<r_4>(dobj->mFSwapper, swpos, dobj->SegmentSize());
    423       break;
    424     case BaseDataTable::DoubleField :
    425       swpos.clear();
    426       s.GetPosTagTable(swpos);
    427       dobj->mDCols[sk] = SwSegDataBlock<r_8>(dobj->mDSwapper, swpos, dobj->SegmentSize());
    428       break;
    429     case BaseDataTable::StringField :
    430       swpos.clear();
    431       s.GetPosTagTable(swpos);
    432       dobj->mSCols[sk] = SwSegDataBlock<string>(dobj->mSSwapper, swpos, dobj->SegmentSize());
    433       break;
    434     default:
    435       throw ForbiddenError("ObjFileIO<SwPPFDataTable>::ReadSelf() : unknown column type ");
    436     break;
    437     }
    438   }   
    439 return;
    440 }
    441 
    442 #ifdef __CXX_PRAGMA_TEMPLATES__
    443 #pragma define_template ObjFileIO<SwPPFDataTable>
    444 #endif
    445 
    446 #if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
    447 template class ObjFileIO<SwPPFDataTable>;
    448 #endif

  • trunk/SophyaLib/HiStats/swppfdtable.h

    r2696 r2699  
    2020  SwPPFDataTable(POutPersist & os, sa_size_t segsz=512);
    2121  SwPPFDataTable(SwPPFDataTable const& a);
    22  
     22
     23  virtual ~SwPPFDataTable();
     24
    2325  virtual sa_size_t AddColumn(FieldType ft, string const & cnom);
    2426
    … …  
    3234
    3335  //  Pour la gestion de persistance PPF
    34   friend class ObjFileIO<SwPPFDataTable> ;
     36  friend class ObjFileIO<BaseDataTable> ;
    3537 
    3638  //! Reset the table content and structure
    37   void Clear();
     39  virtual void Clear();
    3840  /*! This method should be called in order to empty the swapout buffer,
    3941     before saving object to PPF stream
    … …  
    5658  PPFDataSwapper<string> mSSwapper;
    5759 
    58   POutPersist* mSwOut;
    59   PInPersist* mSwIn;
     60  // Output swap stream doit etre cree avant l'appel au constructeur
     61  // et rester valide (non detruit) tant que l'objet SwPPFDataTable existe
     62  POutPersist* mSwOut;   
     63  // Input swap stream - On cree un input swap stream et on fait
     64  // un comptage de reference pour le detruire lorsque tous les tables
     65  // l'utilisant sont supprimes
     66  typedef struct { PInPersist* pis; uint_4 refcnt; } St_InSwap;
     67  St_InSwap * mSwIn;
    6068};
    6169 
    6270/*! Writes the object in the POutPersist stream \b os */
    6371inline POutPersist& operator << (POutPersist& os, SwPPFDataTable & obj)
    64 { obj.SwapOutAll();  ObjFileIO<SwPPFDataTable> fio(&obj);  fio.Write(os);  return(os); }
     72{ obj.SwapOutAll();  ObjFileIO<BaseDataTable> fio(&obj);  fio.Write(os);  return(os); }
    6573/*! Reads the object from the PInPersist stream \b is */
    6674inline PInPersist& operator >> (PInPersist& is, SwPPFDataTable & obj)
    67 {  ObjFileIO<SwPPFDataTable> fio(&obj); is.SkipToNextObject(); fio.Read(is); return(is); }
    68 // Classe pour la gestion de persistance
    69 // ObjFileIO<SwPPFDataTable>
     75{  ObjFileIO<BaseDataTable> fio(&obj); is.SkipToNextObject(); fio.Read(is); return(is); }
     76
    7077} // namespace SOPHYA
    7178
Note: See TracChangeset for help on using the changeset viewer.