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

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

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
File size: 7.6 KB
Line 
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 mSwOut(&os), mSwIn(NULL),
49 mISwapper(os), mLSwapper(os), mFSwapper(os), mDSwapper(os), mSSwapper(os)
50{
51}
52//! Protected constructor for creation from a swap stream
53SwPPFDataTable::SwPPFDataTable(PInPersist & is, sa_size_t segsz)
54 : BaseDataTable(segsz) ,
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);
65}
66
67//! copy constructor - shares the data
68SwPPFDataTable::SwPPFDataTable(SwPPFDataTable const & a)
69 : BaseDataTable(a.SegmentSize()),
70 mSwOut(NULL), mSwIn(NULL)
71{
72 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 }
85}
86
87void SwPPFDataTable::Share(SwPPFDataTable const & a)
88{
89 // Recopie (attention !) brutale des swappers et les streams associes
90 mISwapper = a.mISwapper;
91 mLSwapper = a.mLSwapper;
92 mFSwapper = a.mFSwapper;
93 mDSwapper = a.mDSwapper;
94 mSSwapper = a.mSSwapper;
95
96 mSwOut = a.mSwOut;
97 mSwIn = a.mSwIn;
98 if (mSwIn) mSwIn->refcnt++; // comptage de reference pour le stream input
99
100 // On recopie la taille de segment
101 mSegSz = a.SegmentSize();
102 if (a.NVar() == 0) return; // Table sans colonne
103
104 // On copie la structure de table
105 CopyStructure(a);
106
107 //
108 // Update nombre d'entree, ...
109 mNEnt = a.mNEnt;
110 mNSeg = a.mNSeg;
111 if (a.mInfo) mInfo = new DVList(*(a.mInfo));
112
113 // mis a jour des tableax min-max
114 mMin = a.mMin;
115 mMax = a.mMax;
116 mMinMaxNEnt = a.mMinMaxNEnt;
117
118 // Et on partage les donnees des colonnes
119 for (size_t kk=0; kk<mNames.size(); kk++) {
120 sa_size_t sk = mNames[kk].ser;
121 sa_size_t ska = a.mNames[kk].ser;
122 switch (mNames[kk].type) {
123 case IntegerField :
124 mICols[sk] = a.mICols[ska];
125 break;
126 case LongField :
127 mLCols[sk] = a.mLCols[ska];
128 break;
129 case FloatField :
130 mFCols[sk] = a.mFCols[ska];
131 break;
132 case DoubleField :
133 mDCols[sk] = a.mDCols[ska];
134 break;
135 case StringField :
136 mSCols[sk] = a.mSCols[ska];
137 break;
138 default:
139 throw ForbiddenError("SwPPFDataTable::Share() : unknown column type ");
140 break;
141 }
142 }
143}
144void SwPPFDataTable::SwapOutAll() const
145{
146 // Et on vide les buffers de swap
147 for (size_t kk=0; kk<mNames.size(); kk++) {
148 sa_size_t sk = mNames[kk].ser;
149 switch (mNames[kk].type) {
150 case IntegerField :
151 mICols[sk].SwapOutBuffer();
152 break;
153 case LongField :
154 mLCols[sk].SwapOutBuffer();
155 break;
156 case FloatField :
157 mFCols[sk].SwapOutBuffer();
158 break;
159 case DoubleField :
160 mDCols[sk].SwapOutBuffer();
161 break;
162 case StringField :
163 mSCols[sk].SwapOutBuffer();
164 break;
165 default:
166 throw ForbiddenError("SwPPFDataTable::Share() : unknown column type ");
167 break;
168 }
169 }
170}
171
172void SwPPFDataTable::Clear()
173{
174 if ( (NVar() == 0) && (NEntry() == 0)) return;
175 mNEnt = 0;
176 mNSeg = 0;
177 if (mVarD) delete[] mVarD;
178 mVarD = NULL;
179 if (mVarMTV) delete[] mVarMTV;
180 mVarMTV = NULL;
181 mNames.clear();
182 if (mInfo) delete mInfo;
183 mInfo = NULL;
184 mMin.clear();
185 mMax.clear();
186 mMinMaxNEnt.clear();
187 mIColsP.clear();
188 mLColsP.clear();
189 mFColsP.clear();
190 mDColsP.clear();
191 mSColsP.clear();
192
193 mIColIdx.clear();
194 mLColIdx.clear();
195 mFColIdx.clear();
196 mDColIdx.clear();
197 mSColIdx.clear();
198
199 mICols.clear();
200 mLCols.clear();
201 mFCols.clear();
202 mDCols.clear();
203 mSCols.clear();
204}
205
206
207sa_size_t SwPPFDataTable::AddColumn(FieldType ft, string const & cnom)
208{
209 if (NEntry() > 0)
210 throw ParmError("SwPPFDataTable::AddColumn() Table contains already data ");
211 CheckColName(cnom);
212 sa_size_t ser;
213 sa_size_t idx = NVar();
214 switch (ft) {
215 case IntegerField :
216 ser = mICols.size();
217 mICols.push_back(SwSegDataBlock<int_4>(mISwapper, mSegSz));
218 mIColIdx.push_back(idx);
219 mIColsP.push_back(NULL);
220 for(sa_size_t kk=0; kk<mICols.size(); kk++)
221 mIColsP[kk] = &(mICols[kk]);
222 break;
223 case LongField :
224 ser = mLCols.size();
225 mLCols.push_back(SwSegDataBlock<int_8>(mLSwapper, mSegSz));
226 mLColIdx.push_back(idx);
227 mLColsP.push_back(NULL);
228 for(sa_size_t kk=0; kk<mLCols.size(); kk++)
229 mLColsP[kk] = &(mLCols[kk]);
230 break;
231 case FloatField :
232 ser = mFCols.size();
233 mFCols.push_back(SwSegDataBlock<r_4>(mFSwapper, mSegSz));
234 mFColIdx.push_back(idx);
235 mFColsP.push_back(NULL);
236 for(sa_size_t kk=0; kk<mFCols.size(); kk++)
237 mFColsP[kk] = &(mFCols[kk]);
238 break;
239 case DoubleField :
240 ser = mDCols.size();
241 mDCols.push_back(SwSegDataBlock<r_8>( mDSwapper,mSegSz));
242 mDColIdx.push_back(idx);
243 mDColsP.push_back(NULL);
244 for(sa_size_t kk=0; kk<mDCols.size(); kk++)
245 mDColsP[kk] = &(mDCols[kk]);
246 break;
247 case StringField :
248 ser = mDCols.size();
249 mSCols.push_back(SwSegDataBlock<string>(mSSwapper, mSegSz));
250 mSColIdx.push_back(idx);
251 mSColsP.push_back(NULL);
252 for(sa_size_t kk=0; kk<mSCols.size(); kk++)
253 mSColsP[kk] = &(mSCols[kk]);
254 break;
255 default:
256 throw ParmError("SwPPFDataTable::AddColumn() unknown field type ");
257 break;
258 }
259 colst col;
260 col.nom = cnom;
261 col.type = ft;
262 col.ser = ser;
263 mNames.push_back(col);
264 // On est oblige de calculer les min-max lors du remplissage
265 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
266 mMin.push_back(0.);
267 mMax.push_back(0.);
268 mMinMaxNEnt.push_back(0);
269
270 return NVar();
271}
272
273sa_size_t SwPPFDataTable::AddLine(const r_8* data)
274{
275 // On est oblige de calculer les min-max lors du remplissage
276 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
277 for(sa_size_t k=0; k<NVar(); k++) {
278 double x = data[k];
279 if (x < mMin[k]) mMin[k] = x;
280 if (x > mMax[k]) mMax[k] = x;
281 mMinMaxNEnt[k]++;
282 }
283 return BaseDataTable::AddLine(data);
284}
285
286sa_size_t SwPPFDataTable::AddLine(const MuTyV * data)
287{
288 // On est oblige de calculer les min-max lors du remplissage
289 // On ne peut pas en effet 'relire' le swap pendant l'ecriture
290 for(sa_size_t k=0; k<NVar(); k++) {
291 double x = (double)data[k];
292 if (x < mMin[k]) mMin[k] = x;
293 if (x > mMax[k]) mMax[k] = x;
294 mMinMaxNEnt[k]++;
295 }
296 return BaseDataTable::AddLine(data);
297}
298
Note: See TracBrowser for help on using the repository browser.