| 1 | #include "datatable.h"
|
|---|
| 2 | #include "swppfdtable.h"
|
|---|
| 3 | #include "sopnamsp.h"
|
|---|
| 4 | #include "pexceptions.h"
|
|---|
| 5 | #include "fiosegdb.h"
|
|---|
| 6 |
|
|---|
| 7 |
|
|---|
| 8 |
|
|---|
| 9 | /*!
|
|---|
| 10 | \class SOPHYA::ObjFileIO<BaseDataTable>
|
|---|
| 11 | \ingroup HiStats
|
|---|
| 12 | Persistence (serialisation) handler for class DataTable classes
|
|---|
| 13 | */
|
|---|
| 14 | /* --Methode-- */
|
|---|
| 15 | DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
|
|---|
| 16 | void ObjFileIO<BaseDataTable>::WriteSelf(POutPersist& s) const
|
|---|
| 17 | // Serialisation en ecriture du DataTable sur stream PPF
|
|---|
| 18 | {
|
|---|
| 19 | if (dobj == NULL)
|
|---|
| 20 | throw NullPtrError("ObjFileIO<BaseDataTable>::WriteSelf() NULL dobj pointer ");
|
|---|
| 21 | //------- On ecrit 3 uint_4 ....
|
|---|
| 22 | // [0]: Numero de version ;
|
|---|
| 23 | // [1] : bit1 non nul -> has info
|
|---|
| 24 | // [2] : =1 DataTable , =2 SwPPFDataTable
|
|---|
| 25 | // [3] : reserve
|
|---|
| 26 |
|
|---|
| 27 | DataTable* dt = dynamic_cast< DataTable *> (dobj);
|
|---|
| 28 | SwPPFDataTable* swdt = dynamic_cast< SwPPFDataTable *> (dobj);
|
|---|
| 29 | if ( (dt == NULL) && (swdt == NULL) )
|
|---|
| 30 | throw IOExc("ObjFileIO<BaseDataTable>::WriteSelf() object not a DataTable or SwPPFDataTable");
|
|---|
| 31 | if ( swdt && (swdt->mSwOut != &s) )
|
|---|
| 32 | throw IOExc("ObjFileIO<SwPPFDataTable>::WriteSelf() (obj=SwPPFDataTable) OutputStream <> SwapStream");
|
|---|
| 33 | uint_4 itab[4];
|
|---|
| 34 | itab[0] = 1; // Numero de version a 1
|
|---|
| 35 | itab[1] = itab[2] = itab[3] = 0;
|
|---|
| 36 | if (dobj->mInfo) itab[1] = 1;
|
|---|
| 37 | if (dt != NULL) itab[2] = 1;
|
|---|
| 38 | else if (swdt != NULL) itab[2] = 2;
|
|---|
| 39 | s.Put(itab, 4);
|
|---|
| 40 |
|
|---|
| 41 | //-------- Ecriture de segment size, nb de colonnes, nb de lignes ...
|
|---|
| 42 | // [0] : SegmentSize() [1] : NVar()
|
|---|
| 43 | // [2] : NEntry() [3] : NbSegments()
|
|---|
| 44 | // [4] : reserve utilisation future
|
|---|
| 45 | uint_8 ltab[5];
|
|---|
| 46 | ltab[0] = dobj->SegmentSize();
|
|---|
| 47 | ltab[1] = dobj->NVar();
|
|---|
| 48 | ltab[2] = dobj->NEntry();
|
|---|
| 49 | ltab[3] = dobj->NbSegments();
|
|---|
| 50 | ltab[4] = 0;
|
|---|
| 51 | s.Put(ltab, 5);
|
|---|
| 52 |
|
|---|
| 53 | //------ Ecriture du nom et type des colonnes
|
|---|
| 54 | for(sa_size_t k=0; k<dobj->NVar(); k++) {
|
|---|
| 55 | uint_2 typ = dobj->mNames[k].type;
|
|---|
| 56 | s.Put(typ);
|
|---|
| 57 | s.Put(dobj->mNames[k].nom);
|
|---|
| 58 | }
|
|---|
| 59 | // ------- Ecriture des tableaux min,max et n_minmax
|
|---|
| 60 | for(uint_8 k=0; k<ltab[1]; k++) {
|
|---|
| 61 | s.Put(dobj->mMin[k]);
|
|---|
| 62 | s.Put(dobj->mMax[k]);
|
|---|
| 63 | s.Put(dobj->mMinMaxNEnt[k]);
|
|---|
| 64 | }
|
|---|
| 65 | //------- Ecriture du DVList Info() associe, si existant
|
|---|
| 66 | if (dobj->mInfo) s << (*(dobj->mInfo));
|
|---|
| 67 |
|
|---|
| 68 | //------- Ecriture des blocs de donnees Sw/SegDataBlock<T>
|
|---|
| 69 | if (dt) { // C'est un DataTable
|
|---|
| 70 | //.... Ecriture des SegDataBlock<T>
|
|---|
| 71 | for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
|
|---|
| 72 | sa_size_t sk = dobj->mNames[kk].ser;
|
|---|
| 73 | switch (dobj->mNames[kk].type) {
|
|---|
| 74 | case BaseDataTable::IntegerField :
|
|---|
| 75 | s << dt->mICols[sk];
|
|---|
| 76 | break;
|
|---|
| 77 | case BaseDataTable::LongField :
|
|---|
| 78 | s << dt->mLCols[sk];
|
|---|
| 79 | break;
|
|---|
| 80 | case BaseDataTable::FloatField :
|
|---|
| 81 | s << dt->mFCols[sk];
|
|---|
| 82 | break;
|
|---|
| 83 | case BaseDataTable::DoubleField :
|
|---|
| 84 | s << dt->mDCols[sk];
|
|---|
| 85 | break;
|
|---|
| 86 | case BaseDataTable::ComplexField :
|
|---|
| 87 | s << dt->mYCols[sk];
|
|---|
| 88 | break;
|
|---|
| 89 | case BaseDataTable::DoubleComplexField :
|
|---|
| 90 | s << dt->mZCols[sk];
|
|---|
| 91 | break;
|
|---|
| 92 | case BaseDataTable::StringField :
|
|---|
| 93 | s << dt->mSCols[sk];
|
|---|
| 94 | break;
|
|---|
| 95 | default:
|
|---|
| 96 | throw IOExc("ObjFileIO<BaseDataTable>::WriteSelf() (DataTable) unknown column type ");
|
|---|
| 97 | break;
|
|---|
| 98 | }
|
|---|
| 99 | }
|
|---|
| 100 | }
|
|---|
| 101 | else if (swdt) { // C'est un SwPPFDataTable
|
|---|
| 102 | //.... Ecriture des tables de positionnement de SwSegDataBlock<T>
|
|---|
| 103 | for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
|
|---|
| 104 | sa_size_t sk = dobj->mNames[kk].ser;
|
|---|
| 105 | switch (dobj->mNames[kk].type) {
|
|---|
| 106 | case BaseDataTable::IntegerField :
|
|---|
| 107 | s.PutPosTagTable(swdt->mICols[sk].GetSwapPosTagTable());
|
|---|
| 108 | break;
|
|---|
| 109 | case BaseDataTable::LongField :
|
|---|
| 110 | s.PutPosTagTable(swdt->mLCols[sk].GetSwapPosTagTable());
|
|---|
| 111 | break;
|
|---|
| 112 | case BaseDataTable::FloatField :
|
|---|
| 113 | s.PutPosTagTable(swdt->mFCols[sk].GetSwapPosTagTable());
|
|---|
| 114 | break;
|
|---|
| 115 | case BaseDataTable::DoubleField :
|
|---|
| 116 | s.PutPosTagTable(swdt->mDCols[sk].GetSwapPosTagTable());
|
|---|
| 117 | break;
|
|---|
| 118 | case BaseDataTable::ComplexField :
|
|---|
| 119 | s.PutPosTagTable(swdt->mYCols[sk].GetSwapPosTagTable());
|
|---|
| 120 | break;
|
|---|
| 121 | case BaseDataTable::DoubleComplexField :
|
|---|
| 122 | s.PutPosTagTable(swdt->mZCols[sk].GetSwapPosTagTable());
|
|---|
| 123 | break;
|
|---|
| 124 | case BaseDataTable::StringField :
|
|---|
| 125 | s.PutPosTagTable(swdt->mSCols[sk].GetSwapPosTagTable());
|
|---|
| 126 | break;
|
|---|
| 127 | default:
|
|---|
| 128 | throw IOExc("ObjFileIO<BaseDataTable>::WriteSelf() (SwPPFDataTable) unknown column type ");
|
|---|
| 129 | break;
|
|---|
| 130 | }
|
|---|
| 131 | }
|
|---|
| 132 | }
|
|---|
| 133 | return;
|
|---|
| 134 | }
|
|---|
| 135 |
|
|---|
| 136 | /* --Methode-- */
|
|---|
| 137 | DECL_TEMP_SPEC /* equivalent a template <> , pour SGI-CC en particulier */
|
|---|
| 138 | void ObjFileIO<BaseDataTable>::ReadSelf(PInPersist& s)
|
|---|
| 139 | // Serialisation en lecture du DataTable sur stream PPF
|
|---|
| 140 | {
|
|---|
| 141 | // ------- On lit les 3 premiers uint_4
|
|---|
| 142 | // [0]: Numero de version ;
|
|---|
| 143 | // [1] : bit1 non nul -> has info
|
|---|
| 144 | // [2] : =1 DataTable , =2 SwPPFDataTable
|
|---|
| 145 | // [3] : reserve
|
|---|
| 146 | uint_4 itab[4] = {0,0,0,0};
|
|---|
| 147 | s.Get(itab, 4);
|
|---|
| 148 | bool hadinfo = false;
|
|---|
| 149 | if ((itab[1]&1) == 1) hadinfo = true;
|
|---|
| 150 | if ((itab[2] != 1) && (itab[2] != 2))
|
|---|
| 151 | throw IOExc("ObjFileIO<BaseDataTable>::ReadSelf(): (itab[2]=type=1 or 2) supported only");
|
|---|
| 152 |
|
|---|
| 153 | // -------- Lecture de segment size, nb de colonnes, nb de lignes ...
|
|---|
| 154 | // [0] : SegmentSize() [1] : NVar()
|
|---|
| 155 | // [2] : NEntry() [3] : NbSegments()
|
|---|
| 156 | uint_8 ltab[5] = {0,0,0,0,0};
|
|---|
| 157 | s.Get(ltab, 5);
|
|---|
| 158 | if (dobj == NULL) {
|
|---|
| 159 | if (itab[2] == 1) dobj = new DataTable(ltab[0]);
|
|---|
| 160 | else if (itab[2] == 2) dobj = new SwPPFDataTable(s, ltab[0]);
|
|---|
| 161 | }
|
|---|
| 162 | else {
|
|---|
| 163 | dobj->Clear();
|
|---|
| 164 | dobj->mSegSz = ltab[0];
|
|---|
| 165 | SwPPFDataTable* swdtc = dynamic_cast< SwPPFDataTable *> (dobj);
|
|---|
| 166 | // Copie brutale en utilisant l'operateur =
|
|---|
| 167 | if (swdtc && (itab[2] == 2)) *swdtc = SwPPFDataTable(s, ltab[0]);
|
|---|
| 168 | }
|
|---|
| 169 |
|
|---|
| 170 | DataTable* dt = dynamic_cast< DataTable *> (dobj);
|
|---|
| 171 | SwPPFDataTable* swdt = dynamic_cast< SwPPFDataTable *> (dobj);
|
|---|
| 172 | if ( (dt == NULL) && (swdt == NULL) )
|
|---|
| 173 | throw IOExc("ObjFileIO<BaseDataTable>::ReadSelf() object not a DataTable or SwPPFDataTable");
|
|---|
| 174 | if ( (itab[2] == 1) && (dt == NULL) )
|
|---|
| 175 | throw IOExc("ObjFileIO<BaseDataTable>::ReadSelf() object not a DataTable and itab[2]=1");
|
|---|
| 176 | if ( (itab[2] == 2) && (swdt == NULL) )
|
|---|
| 177 | throw IOExc("ObjFileIO<BaseDataTable>::ReadSelf() object not a DataTable and itab[2]=1");
|
|---|
| 178 |
|
|---|
| 179 | // -------- Lecture nom/type colonnes et allocation des colonnes
|
|---|
| 180 | uint_2 typ;
|
|---|
| 181 | string cnom;
|
|---|
| 182 | for(uint_8 k=0; k<ltab[1]; k++) {
|
|---|
| 183 | s.Get(typ);
|
|---|
| 184 | s.Get(cnom);
|
|---|
| 185 | BaseDataTable::FieldType ft = (BaseDataTable::FieldType)typ;
|
|---|
| 186 | dobj->AddColumn(ft, cnom);
|
|---|
| 187 | }
|
|---|
| 188 | // ------- Lecture des tableaux min,max et n_minmax
|
|---|
| 189 | for(uint_8 k=0; k<ltab[1]; k++) {
|
|---|
| 190 | s.Get(dobj->mMin[k]);
|
|---|
| 191 | s.Get(dobj->mMax[k]);
|
|---|
| 192 | s.Get(dobj->mMinMaxNEnt[k]);
|
|---|
| 193 | }
|
|---|
| 194 | // ------- Lecture du DVList Info() associe, si necessaire
|
|---|
| 195 | if (hadinfo) { // Lecture eventuelle du DVList Info
|
|---|
| 196 | if (dobj->mInfo == NULL) dobj->mInfo = new DVList;
|
|---|
| 197 | s >> (*(dobj->mInfo));
|
|---|
| 198 | }
|
|---|
| 199 | // ------- Mise a jour des champs Nb d'entrees, nb segments ...
|
|---|
| 200 | dobj->mNEnt = ltab[2];
|
|---|
| 201 | dobj->mNSeg = ltab[3];
|
|---|
| 202 | // ------- Lecture des donnees Sw/SegDataBlock<T> ou Sw
|
|---|
| 203 | if (itab[2] == 1) { // On lit un DataTable
|
|---|
| 204 | // .... Lecture des SegDataBlock<T>
|
|---|
| 205 | for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
|
|---|
| 206 | sa_size_t sk = dobj->mNames[kk].ser;
|
|---|
| 207 | switch (dobj->mNames[kk].type) {
|
|---|
| 208 | case BaseDataTable::IntegerField :
|
|---|
| 209 | s >> dt->mICols[sk];
|
|---|
| 210 | break;
|
|---|
| 211 | case BaseDataTable::LongField :
|
|---|
| 212 | s >> dt->mLCols[sk];
|
|---|
| 213 | break;
|
|---|
| 214 | case BaseDataTable::FloatField :
|
|---|
| 215 | s >> dt->mFCols[sk];
|
|---|
| 216 | break;
|
|---|
| 217 | case BaseDataTable::DoubleField :
|
|---|
| 218 | s >> dt->mDCols[sk];
|
|---|
| 219 | break;
|
|---|
| 220 | case BaseDataTable::ComplexField :
|
|---|
| 221 | s >> dt->mYCols[sk];
|
|---|
| 222 | break;
|
|---|
| 223 | case BaseDataTable::DoubleComplexField :
|
|---|
| 224 | s >> dt->mZCols[sk];
|
|---|
| 225 | break;
|
|---|
| 226 | case BaseDataTable::StringField :
|
|---|
| 227 | s >> dt->mSCols[sk];
|
|---|
| 228 | break;
|
|---|
| 229 | default:
|
|---|
| 230 | throw IOExc("ObjFileIO<BaseDataTable>::ReadSelf() : unknown column type ");
|
|---|
| 231 | break;
|
|---|
| 232 | }
|
|---|
| 233 | }
|
|---|
| 234 | }
|
|---|
| 235 | else if (itab[2] == 2) { // C'est un SwPPFDataTable
|
|---|
| 236 | // .... Lecture des tag de positionnement des SwSegDataBlock<T>
|
|---|
| 237 | vector<int_8> swpos;
|
|---|
| 238 | for (size_t kk=0; kk<dobj->mNames.size(); kk++) {
|
|---|
| 239 | sa_size_t sk = dobj->mNames[kk].ser;
|
|---|
| 240 | switch (dobj->mNames[kk].type) {
|
|---|
| 241 | case BaseDataTable::IntegerField :
|
|---|
| 242 | swpos.clear();
|
|---|
| 243 | s.GetPosTagTable(swpos);
|
|---|
| 244 | swdt->mICols[sk] = SwSegDataBlock<int_4>(swdt->mISwapper, swpos, swdt->SegmentSize());
|
|---|
| 245 | break;
|
|---|
| 246 | case BaseDataTable::LongField :
|
|---|
| 247 | swpos.clear();
|
|---|
| 248 | s.GetPosTagTable(swpos);
|
|---|
| 249 | swdt->mLCols[sk] = SwSegDataBlock<int_8>(swdt->mLSwapper, swpos, swdt->SegmentSize());
|
|---|
| 250 | break;
|
|---|
| 251 | case BaseDataTable::FloatField :
|
|---|
| 252 | swpos.clear();
|
|---|
| 253 | s.GetPosTagTable(swpos);
|
|---|
| 254 | swdt->mFCols[sk] = SwSegDataBlock<r_4>(swdt->mFSwapper, swpos, swdt->SegmentSize());
|
|---|
| 255 | break;
|
|---|
| 256 | case BaseDataTable::DoubleField :
|
|---|
| 257 | swpos.clear();
|
|---|
| 258 | s.GetPosTagTable(swpos);
|
|---|
| 259 | swdt->mDCols[sk] = SwSegDataBlock<r_8>(swdt->mDSwapper, swpos, swdt->SegmentSize());
|
|---|
| 260 | break;
|
|---|
| 261 | case BaseDataTable::ComplexField :
|
|---|
| 262 | swpos.clear();
|
|---|
| 263 | s.GetPosTagTable(swpos);
|
|---|
| 264 | swdt->mYCols[sk] = SwSegDataBlock< complex<r_4> >(swdt->mYSwapper, swpos, swdt->SegmentSize());
|
|---|
| 265 | break;
|
|---|
| 266 | case BaseDataTable::DoubleComplexField :
|
|---|
| 267 | swpos.clear();
|
|---|
| 268 | s.GetPosTagTable(swpos);
|
|---|
| 269 | swdt->mZCols[sk] = SwSegDataBlock< complex<r_8> >(swdt->mZSwapper, swpos, swdt->SegmentSize());
|
|---|
| 270 | break;
|
|---|
| 271 | case BaseDataTable::StringField :
|
|---|
| 272 | swpos.clear();
|
|---|
| 273 | s.GetPosTagTable(swpos);
|
|---|
| 274 | swdt->mSCols[sk] = SwSegDataBlock<string>(swdt->mSSwapper, swpos, swdt->SegmentSize());
|
|---|
| 275 | break;
|
|---|
| 276 | default:
|
|---|
| 277 | throw IOExc("ObjFileIO<SwPPFDataTable>::ReadSelf() : unknown column type ");
|
|---|
| 278 | break;
|
|---|
| 279 | }
|
|---|
| 280 | }
|
|---|
| 281 | }
|
|---|
| 282 | return;
|
|---|
| 283 | }
|
|---|
| 284 |
|
|---|
| 285 | #ifdef __CXX_PRAGMA_TEMPLATES__
|
|---|
| 286 | #pragma define_template ObjFileIO<BaseDataTable>
|
|---|
| 287 | #endif
|
|---|
| 288 |
|
|---|
| 289 | #if defined(ANSI_TEMPLATES) || defined(GNU_TEMPLATES)
|
|---|
| 290 | template class ObjFileIO<BaseDataTable>;
|
|---|
| 291 | #endif
|
|---|
![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
