source: Sophya/trunk/SophyaLib/HiStats/swppfdtable.cc@ 2696

Last change on this file since 2696 was 2696, checked in by ansari, 20 years ago

1/ Ajout ecriture des tableaux min/max de DataTable ds stream PPF
2/ Ajout classes SwPPFDataTable (DataTable avec Swap sur PPF) -
Pb actuellement avec relecture depuis PPF (Il essaye de swapper en sortie)

Reza 25/4/2005
File size: 12.8 KB
RevLine 
[2696]1#include "swppfdtable.h"
2#include "sopnamsp.h"
3#include "pexceptions.h"
4
5
6/*!
7 \class SOPHYA::SwPPFDataTable
8 \ingroup HiStats
9 This class can be used to organize data in table (row-column) form.
10 Each column holds homogeneous data (same data type), while different
11 columns can be used for different data types (integer, float, string ...)
12 \sa SOPHYA::MuTyV
13 \sa SOPHYA::BaseDataTable
14 \sa SOPHYA::ObjFileIO<DataTable>
15
16 \code
17 #include "swppfdtable.h"
18 // ...
19 DataTable dt(64);
20 dt.AddFloatColumn("X0_f");
21 dt.AddFloatColumn("X1_f");
22 dt.AddDoubleColumn("X0X0pX1X1_d");
23 double x[5];
24 for(int i=0; i<63; i++) {
25 x[0] = (i%9)-4.; x[1] = (i/9)-3.; x[2] = x[0]*x[0]+x[1]*x[1];
26 dt.AddLine(x);
27 }
28 // Printing table info
29 cout << dt ;
30 // Saving object into a PPF file
31 POutPersist po("dtable.ppf");
32 po << dt ;
33 \endcode
34*/
35/*! Default constructor with optional specification of block (or segment) size -
36 NOT intented for general use
37*/
38SwPPFDataTable::SwPPFDataTable(sa_size_t segsz)
39 : BaseDataTable(segsz),
40 mSwOut(NULL), mSwIn(NULL)
41{
42}
43/*! Constructor with the specification of the output swap stream -
44 and optional specification of block (or segment) size
45*/
46SwPPFDataTable::SwPPFDataTable(POutPersist & os, sa_size_t segsz)
47 : BaseDataTable(segsz) ,
48 mISwapper(os), mLSwapper(os), mFSwapper(os), mDSwapper(os), mSSwapper(os),
49 mSwOut(&os), mSwIn(NULL)
50{
51}
52//! Protected constructor for creation from a swap stream
53SwPPFDataTable::SwPPFDataTable(PInPersist & is, sa_size_t segsz)
54 : BaseDataTable(segsz) ,
55 mISwapper(is), mLSwapper(is), mFSwapper(is), mDSwapper(is), mSSwapper(is),
56 mSwOut(NULL), mSwIn(&is)
57{
58}
59
60//! copy constructor - shares the data
61SwPPFDataTable::SwPPFDataTable(SwPPFDataTable const & a)
62 : BaseDataTable(a.SegmentSize()),
63 mSwOut(NULL), mSwIn(NULL)
64{
65 Share(a);
66}
67
68void SwPPFDataTable::Share(SwPPFDataTable const & a)
69{
70 // Recopie (attention !) brutale des swappers et les streams associes
71 mISwapper = a.mISwapper;
72 mLSwapper = a.mLSwapper;
73 mFSwapper = a.mFSwapper;
74 mDSwapper = a.mDSwapper;
75 mSSwapper = a.mSSwapper;
76
77 mSwOut = a.mSwOut;
78 mSwIn = a.mSwIn;
79
80 // On recopie la taille de segment
81 mSegSz = a.SegmentSize();
82 if (a.NVar() == 0) return; // Table sans colonne
83
84 // On copie la structure de table
85 CopyStructure(a);
86
87 //
88 // Update nombre d'entree, ...
89 mNEnt = a.mNEnt;
90 mNSeg = a.mNSeg;
91 if (a.mInfo) mInfo = new DVList(*(a.mInfo));
92
93 // mis a jour des tableax min-max
94 mMin = a.mMin;
95 mMax = a.mMax;
96 mMinMaxNEnt = a.mMinMaxNEnt;
97
98 // Et on partage les donnees des colonnes
99 for (size_t kk=0; kk<mNames.size(); kk++) {
100 sa_size_t sk = mNames[kk].ser;
101 sa_size_t ska = a.mNames[kk].ser;
102 switch (mNames[kk].type) {
103 case IntegerField :
104 mICols[sk] = a.mICols[ska];
105 break;
106 case LongField :
107 mLCols[sk] = a.mLCols[ska];
108 break;
109 case FloatField :
110 mFCols[sk] = a.mFCols[ska];
111 break;
112 case DoubleField :
113 mDCols[sk] = a.mDCols[ska];
114 break;
115 case StringField :
116 mSCols[sk] = a.mSCols[ska];
117 break;
118 default:
119 throw ForbiddenError("SwPPFDataTable::Share() : unknown column type ");
120 break;
121 }
122 }
123}
124void SwPPFDataTable::SwapOutAll() const
125{
126 // Et on vide les buffers de swap
127 for (size_t kk=0; kk<mNames.size(); kk++) {
128 sa_size_t sk = mNames[kk].ser;
129 switch (mNames[kk].type) {
130 case IntegerField :
131 mICols[sk].SwapOutBuffer();
132 break;
133 case LongField :
134 mLCols[sk].SwapOutBuffer();
135 break;
136 case FloatField :
137 mFCols[sk].SwapOutBuffer();
138 break;
139 case DoubleField :
140 mDCols[sk].SwapOutBuffer();
141 break;
142 case StringField :
143 mSCols[sk].SwapOutBuffer();
144 break;
145 default:
146 throw ForbiddenError("SwPPFDataTable::Share() : unknown column type ");
147 break;
148 }
149 }
150}
151
152void SwPPFDataTable::Clear()
153{
154 if ( (NVar() == 0) && (NEntry() == 0)) return;
155 mNEnt = 0;
156 mNSeg = 0;
157 if (mVarD) delete[] mVarD;
158 mVarD = NULL;
159 if (mVarMTV) delete[] mVarMTV;
160 mVarMTV = NULL;
161 mNames.clear();
162 if (mInfo) delete mInfo;
163 mInfo = NULL;
164 mMin.clear();
165 mMax.clear();
166 mMinMaxNEnt.clear();
167 mIColsP.clear();
168 mLColsP.clear();
169 mFColsP.clear();
170 mDColsP.clear();
171 mSColsP.clear();
172
173 mIColIdx.clear();
174 mLColIdx.clear();
175 mFColIdx.clear();
176 mDColIdx.clear();
177 mSColIdx.clear();
178
179 mICols.clear();
180 mLCols.clear();
181 mFCols.clear();
182 mDCols.clear();
183 mSCols.clear();
184}
185
186
187sa_size_t SwPPFDataTable::AddColumn(FieldType ft, string const & cnom)
188{
189 if (NEntry() > 0)
190 throw ParmError("SwPPFDataTable::AddColumn() Table contains already data ");
191 CheckColName(cnom);
192 sa_size_t ser;
193 sa_size_t idx = NVar();
194 switch (ft) {
195 case IntegerField :
196 ser = mICols.size();
197 mICols.push_back(SwSegDataBlock<int_4>(mISwapper, mSegSz));
198 mIColIdx.push_back(idx);
199 mIColsP.push_back(NULL);
200 for(sa_size_t kk=0; kk<mICols.size(); kk++)
201 mIColsP[kk] = &(mICols[kk]);
202 break;
203 case LongField :
204 ser = mLCols.size();
205 mLCols.push_back(SwSegDataBlock<int_8>(mLSwapper, mSegSz));
206 mLColIdx.push_back(idx);
207 mLColsP.push_back(NULL);
208 for(sa_size_t kk=0; kk<mLCols.size(); kk++)
209 mLColsP[kk] = &(mLCols[kk]);
210 break;
211 case FloatField :
212 ser = mFCols.size();
213 mFCols.push_back(SwSegDataBlock<r_4>(mFSwapper, mSegSz));
214 mFColIdx.push_back(idx);
215 mFColsP.push_back(NULL);
216 for(sa_size_t kk=0; kk<mFCols.size(); kk++)
217 mFColsP[kk] = &(mFCols[kk]);
218 break;
219 case DoubleField :
220 ser = mDCols.size();
221 mDCols.push_back(SwSegDataBlock<r_8>( mDSwapper,mSegSz));
222 mDColIdx.push_back(idx);
223 mDColsP.push_back(NULL);
224 for(sa_size_t kk=0; kk<mDCols.size(); kk++)
225 mDColsP[kk] = &(mDCols[kk]);
226 break;
227 case StringField :
228 ser = mDCols.size();
229 mSCols.push_back(SwSegDataBlock<string>(mSSwapper, mSegSz));
230 mSColIdx.push_back(idx);
231 mSColsP.push_back(NULL);
232 for(sa_size_t kk=0; kk<mSCols.size(); kk++)
233 mSColsP[kk] = &(mSCols[kk]);
234 break;
235 default:
236 throw ParmError("SwPPFDataTable::AddColumn() unknown field type ");
237 break;
238 }
239 colst col;
240 col.nom = cnom;
241 col.type = ft;
242 col.ser = ser;
243 mNames.push_back(col);
244 // On est oblige de calculer les min-max lors du remplissage
245 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
246 mMin.push_back(0.);
247 mMax.push_back(0.);
248 mMinMaxNEnt.push_back(0);
249
250 return NVar();
251}
252
253sa_size_t SwPPFDataTable::AddLine(const r_8* data)
254{
255 // On est oblige de calculer les min-max lors du remplissage
256 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
257 for(sa_size_t k=0; k<NVar(); k++) {
258 double x = data[k];
259 if (x < mMin[k]) mMin[k] = x;
260 if (x > mMax[k]) mMax[k] = x;
261 mMinMaxNEnt[k]++;
262 }
263 return BaseDataTable::AddLine(data);
264}
265
266sa_size_t SwPPFDataTable::AddLine(const MuTyV * data)
267{
268 // On est oblige de calculer les min-max lors du remplissage
269 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
270 for(sa_size_t k=0; k<NVar(); k++) {
271 double x = (double)data[k];
272 if (x < mMin[k]) mMin[k] = x;
273 if (x > mMax[k]) mMax[k] = x;
274 mMinMaxNEnt[k]++;
275 }
276 return BaseDataTable::AddLine(data);
277}
278
279/*!
280 \class SOPHYA::ObjFileIO<SwPPFDataTable>
281 \ingroup HiStats
282 Persistence (serialisation) handler for class SwPPFDataTable
283*/
284/* --Methode-- */
285DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
286void 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-- */
357DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
358void 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 }
439return;
440}
441
442#ifdef __CXX_PRAGMA_TEMPLATES__
443#pragma define_template ObjFileIO<SwPPFDataTable>
444#endif
445
446#if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
447template class ObjFileIO<SwPPFDataTable>;
448#endif
Note: See TracBrowser for help on using the repository browser.