src/SALOMEDS/SALOMEDS_TableOfRealAttribute.cxx

   1 using namespace std;
   2 //  File      : SALOMEDS_TableOfRealAttribute.cxx
   3 //  Created   : Tue Oct  8 10:13:30 2002
   4 //  Author    : Michael Ponikarov
   5 //  Project   : SALOME
   6 //  Module    : SALOMEDS
   7 //  Copyright : Open CASCADE
   8 //  Modified by: Sergey Ruin
   9 //  $Header$
  10
  11 #include <SALOMEDS_TableOfRealAttribute.ixx>
  12 #include <Standard_Failure.hxx>
  13 #include <TColStd_DataMapIteratorOfDataMapOfIntegerReal.hxx>
  14
  15 #include <string>
  16 #include <stdio.h>
  17
  18 const Standard_GUID& SALOMEDS_TableOfRealAttribute::GetID()
  19 {
  20   static Standard_GUID SALOMEDS_TableOfRealAttributeID ("128371A1-8F52-11d6-A8A3-0001021E8C7F");
  21   return SALOMEDS_TableOfRealAttributeID;
  22 }
  23
  24 Handle(SALOMEDS_TableOfRealAttribute) SALOMEDS_TableOfRealAttribute::Set(const TDF_Label& label)
  25 {
  26   Handle(SALOMEDS_TableOfRealAttribute) anAttr;
  27   if (!label.FindAttribute(SALOMEDS_TableOfRealAttribute::GetID(),anAttr)) {
  28     anAttr = new SALOMEDS_TableOfRealAttribute();
  29     label.AddAttribute(anAttr);
  30   }
  31   return anAttr;
  32 }
  33
  34 SALOMEDS_TableOfRealAttribute::SALOMEDS_TableOfRealAttribute() {
  35   myRows = new TColStd_HSequenceOfExtendedString();
  36   myCols = new TColStd_HSequenceOfExtendedString();
  37   myNbRows = 0;
  38   myNbColumns = 0;
  39 }
  40
  41 void SALOMEDS_TableOfRealAttribute::SetNbColumns(const Standard_Integer theNbColumns)
  42 {
  43   Backup();
  44
  45   TColStd_DataMapOfIntegerReal aMap;
  46   aMap = myTable;
  47   myTable.Clear();
  48
  49   TColStd_DataMapIteratorOfDataMapOfIntegerReal anIterator(aMap);
  50   for(; anIterator.More(); anIterator.Next()) {
  51     int aRow = (int)(anIterator.Key()/myNbColumns) + 1;
  52     int aCol = (int)(anIterator.Key() - myNbColumns*(aRow-1));
  53     if(aCol == 0) { aCol = myNbColumns; aRow--; }
  54     if(aCol > theNbColumns) continue;
  55     int aKey = (aRow-1)*theNbColumns+aCol;
  56     myTable.Bind(aKey, anIterator.Value());
  57   }
  58
  59   myNbColumns = theNbColumns;
  60
  61   while (myCols->Length() < myNbColumns) { // append empty columns titles
  62     myCols->Append(TCollection_ExtendedString(""));
  63   }
  64 }
  65
  66 void SALOMEDS_TableOfRealAttribute::SetTitle(const TCollection_ExtendedString& theTitle) {
  67   Backup();
  68   myTitle = theTitle;
  69 }
  70
  71 TCollection_ExtendedString SALOMEDS_TableOfRealAttribute::GetTitle() const {
  72   return myTitle;
  73 }
  74
  75 void SALOMEDS_TableOfRealAttribute::SetRowData(const Standard_Integer theRow,
  76                                                   const Handle(TColStd_HSequenceOfReal)& theData)
  77 {
  78   if(theData->Length() > myNbColumns) SetNbColumns(theData->Length());
  79
  80   Backup();
  81
  82   while (myRows->Length() < theRow) { // append new row titles
  83     myRows->Append(TCollection_ExtendedString(""));
  84   }
  85
  86   Standard_Integer i, aShift = (theRow-1)*myNbColumns, aLength = theData->Length();
  87   for(i = 1; i <= aLength; i++) {
  88     myTable.Bind(aShift + i, theData->Value(i));
  89   }
  90
  91   if(theRow > myNbRows) myNbRows = theRow;
  92 }
  93
  94 Handle(TColStd_HSequenceOfReal) SALOMEDS_TableOfRealAttribute::GetRowData(const Standard_Integer theRow)
  95 {
  96   Handle(TColStd_HSequenceOfReal) aSeq = new TColStd_HSequenceOfReal();
  97   Standard_Integer i, aShift = (theRow-1)*myNbColumns;
  98   for(i = 1; i <= myNbColumns; i++) {
  99      if(myTable.IsBound(aShift+i))
 100        aSeq->Append(myTable.Find(aShift+i));
 101      else
 102        aSeq->Append(0.);
 103   }
 104
 105   return aSeq;
 106 }
 107
 108 void SALOMEDS_TableOfRealAttribute::SetRowTitle(const Standard_Integer theRow,
 109                                                    const TCollection_ExtendedString& theTitle) {
 110   Backup();
 111   myRows->SetValue(theRow,theTitle);
 112 }
 113
 114 TCollection_ExtendedString SALOMEDS_TableOfRealAttribute::GetRowTitle(const Standard_Integer theRow) const {
 115   return myRows->Value(theRow);
 116 }
 117
 118
 119 void SALOMEDS_TableOfRealAttribute::SetColumnData(const Standard_Integer theColumn,
 120                                                      const Handle(TColStd_HSequenceOfReal)& theData)
 121 {
 122   if(theColumn > myNbColumns) SetNbColumns(theColumn);
 123
 124   Backup();
 125
 126   Standard_Integer i, aLength = theData->Length();
 127   for(i = 1; i <= aLength; i++) {
 128     myTable.Bind(myNbColumns*(i-1)+theColumn, theData->Value(i));
 129   }
 130
 131   if(aLength > myNbRows) {
 132     myNbRows = aLength;
 133     while (myRows->Length() < myNbRows) { // append empty row titles
 134       myRows->Append(TCollection_ExtendedString(""));
 135     }
 136   }
 137 }
 138
 139
 140 Handle(TColStd_HSequenceOfReal) SALOMEDS_TableOfRealAttribute::GetColumnData(const Standard_Integer theColumn)
 141 {
 142   Handle(TColStd_HSequenceOfReal) aSeq = new TColStd_HSequenceOfReal;
 143
 144   Standard_Integer i, anIndex;
 145   for(i = 1; i <= myNbRows; i++) {
 146     anIndex = myNbColumns*(i-1) + theColumn;
 147     if(myTable.IsBound(anIndex))
 148       aSeq->Append(myTable.Find(anIndex));
 149     else
 150       aSeq->Append(0.);
 151   }
 152
 153   return aSeq;
 154 }
 155
 156 void SALOMEDS_TableOfRealAttribute::SetColumnTitle(const Standard_Integer theColumn,
 157                                                       const TCollection_ExtendedString& theTitle) {
 158   Backup();
 159   while(myCols->Length() < theColumn) myCols->Append(TCollection_ExtendedString(""));
 160   myCols->SetValue(theColumn,theTitle);
 161 }
 162
 163 TCollection_ExtendedString SALOMEDS_TableOfRealAttribute::GetColumnTitle(const Standard_Integer theColumn) const {
 164   if(myCols.IsNull()) return "";
 165   if(myCols->Length() < theColumn) return "";
 166   return myCols->Value(theColumn);
 167 }
 168
 169
 170 Standard_Integer SALOMEDS_TableOfRealAttribute::GetNbRows() const
 171 {
 172   return myNbRows;
 173 }
 174
 175 Standard_Integer SALOMEDS_TableOfRealAttribute::GetNbColumns() const
 176 {
 177   return myNbColumns;
 178 }
 179
 180 void SALOMEDS_TableOfRealAttribute::PutValue(const Standard_Real theValue,
 181                                              const Standard_Integer theRow,
 182                                              const Standard_Integer theColumn)
 183 {
 184   if(theColumn > myNbColumns) SetNbColumns(theColumn);
 185
 186   Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn;
 187   myTable.Bind(anIndex, theValue);
 188
 189   if(theRow > myNbRows) {
 190     while (myRows->Length() < theRow) { // append empty row titles
 191       myRows->Append(TCollection_ExtendedString(""));
 192     }
 193     myNbRows = theRow;
 194   }
 195 }
 196
 197 Standard_Boolean SALOMEDS_TableOfRealAttribute::HasValue(const Standard_Integer theRow,
 198                                                          const Standard_Integer theColumn)
 199 {
 200   Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn;
 201   return myTable.IsBound(anIndex);
 202 }
 203
 204 Standard_Real SALOMEDS_TableOfRealAttribute::GetValue(const Standard_Integer theRow,
 205                                                       const Standard_Integer theColumn)
 206 {
 207   Standard_Integer anIndex = (theRow-1)*myNbColumns + theColumn;
 208   if(myTable.IsBound(anIndex)) return myTable.Find(anIndex);
 209
 210   Standard_Failure::Raise("Invalid cell index");
 211   return 0.;
 212 }
 213
 214 const Standard_GUID& SALOMEDS_TableOfRealAttribute::ID() const
 215 {
 216   return GetID();
 217 }
 218
 219 void SALOMEDS_TableOfRealAttribute::Restore(const Handle(TDF_Attribute)& with)
 220 {
 221   Standard_Integer anIndex;
 222   Handle(SALOMEDS_TableOfRealAttribute) aTable = Handle(SALOMEDS_TableOfRealAttribute)::DownCast(with);
 223
 224   myTable.Clear();
 225   myCols->Clear();
 226   myRows->Clear();
 227
 228   myTable = aTable->myTable;
 229   myNbRows = aTable->myNbRows;
 230   myNbColumns = aTable->myNbColumns;
 231   myTitle = aTable->myTitle;
 232
 233   for(anIndex = 1; anIndex <= aTable->GetNbRows();anIndex++) {
 234     SetRowTitle(anIndex,aTable->GetRowTitle(anIndex));
 235   }
 236   for(anIndex = 1; anIndex <= aTable->GetNbColumns(); anIndex++)
 237     SetColumnTitle(anIndex, aTable->GetColumnTitle(anIndex));
 238 }
 239
 240 Handle(TDF_Attribute) SALOMEDS_TableOfRealAttribute::NewEmpty() const
 241 {
 242   return new SALOMEDS_TableOfRealAttribute();
 243 }
 244
 245 void SALOMEDS_TableOfRealAttribute::Paste(const Handle(TDF_Attribute)& into,
 246                                              const Handle(TDF_RelocationTable)&) const
 247 {
 248   Standard_Integer anIndex;
 249   Handle(SALOMEDS_TableOfRealAttribute) aTable = Handle(SALOMEDS_TableOfRealAttribute)::DownCast(into);
 250
 251   aTable->myTable.Clear();
 252   aTable->myCols->Clear();
 253   aTable->myRows->Clear();
 254
 255   aTable->myTable = myTable;
 256   aTable->myTitle = myTitle;
 257   aTable->myNbRows = myNbRows;
 258   aTable->myNbColumns = myNbColumns;
 259
 260   for(anIndex = 1; anIndex <= GetNbRows();anIndex++) {
 261     aTable->SetRowTitle(anIndex,GetRowTitle(anIndex));
 262   }
 263   for(anIndex = 1; anIndex <= GetNbColumns(); anIndex++)
 264     aTable->SetColumnTitle(anIndex, GetColumnTitle(anIndex));
 265 }
 266
 267
 268 Handle_TColStd_HSequenceOfInteger SALOMEDS_TableOfRealAttribute::GetSetRowIndices(const Standard_Integer theRow)
 269 {
 270   Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
 271
 272   Standard_Integer i, aShift = myNbColumns*(theRow-1);
 273   for(i = 1; i <= myNbColumns; i++) {
 274     if(myTable.IsBound(aShift + i)) aSeq->Append(i);
 275   }
 276
 277   return aSeq;
 278 }
 279
 280 Handle_TColStd_HSequenceOfInteger SALOMEDS_TableOfRealAttribute::GetSetColumnIndices(const Standard_Integer theColumn)
 281 {
 282   Handle(TColStd_HSequenceOfInteger) aSeq = new TColStd_HSequenceOfInteger;
 283
 284   Standard_Integer i, anIndex;
 285   for(i = 1; i <= myNbRows; i++) {
 286     anIndex = myNbColumns*(i-1)+theColumn;
 287     if(myTable.IsBound(anIndex)) aSeq->Append(i);
 288   }
 289
 290   return aSeq;
 291 }
 292
 293
 294
 295 void SALOMEDS_TableOfRealAttribute::ConvertToString(ostrstream& theStream)
 296 {
 297   int i, j, l;
 298
 299
 300   //Title
 301   l = myTitle.Length();
 302   theStream << l << "\n";
 303   for(i=1; i<=l; i++)
 304     theStream << myTitle.Value(i) << "\n";
 305
 306   //Nb rows
 307   theStream << myNbRows << "\n";
 308
 309   //Rows titles
 310   for(i=1; i<=myNbRows; i++) {
 311     l = myRows->Value(i).Length();
 312     theStream << l << "\n";
 313     for(j=1; j<=l; j++)
 314       theStream << myRows->Value(i).Value(j) << "\n";
 315   }
 316
 317   //Nb columns
 318   theStream << myNbColumns << "\n";
 319
 320   //Columns titles
 321   for(i=1; i<=myNbColumns; i++) {
 322     l = myCols->Value(i).Length();
 323     theStream << l << "\n";
 324     for(j=1; j<=l; j++)
 325       theStream << myCols->Value(i).Value(j) << "\n";
 326   }
 327
 328   //Store the table values
 329   l = myTable.Extent();
 330   theStream << l << "\n";
 331   char *aBuffer = new char[128];
 332   TColStd_DataMapIteratorOfDataMapOfIntegerReal anIterator(myTable);
 333   for(; anIterator.More(); anIterator.Next()) {
 334     theStream << anIterator.Key() << "\n";
 335     sprintf(aBuffer, "%.64e", anIterator.Value());
 336     theStream << aBuffer << "\n";
 337   }
 338
 339   delete []aBuffer;
 340
 341   return;
 342 }
 343
 344 bool SALOMEDS_TableOfRealAttribute::RestoreFromString(istrstream& theStream)
 345 {
 346   Backup();
 347
 348   int i, j, l;
 349
 350   Standard_ExtCharacter anExtChar;
 351   TCollection_ExtendedString aStr;
 352
 353   //Title
 354   theStream >> l;
 355
 356   myTitle = TCollection_ExtendedString(l, 0);
 357   for(i=1; i<=l; i++) {
 358     theStream >> anExtChar;
 359     myTitle.SetValue(i, anExtChar);
 360   }
 361
 362   //Nb rows
 363   theStream >> myNbRows;
 364
 365   //Rows titles
 366   myRows->Clear();
 367   for(i=1; i<=myNbRows; i++) {
 368     theStream >> l;
 369     aStr = TCollection_ExtendedString(l,0);
 370     for(j=1; j<=l; j++) {
 371       theStream >> anExtChar;
 372       aStr.SetValue(j, anExtChar);
 373     }
 374     myRows->Append(aStr);
 375   }
 376
 377   //Nb columns
 378   theStream >> myNbColumns;
 379
 380   //Columns titles
 381   myCols->Clear();
 382   for(i=1; i<=myNbColumns; i++) {
 383     theStream >> l;
 384     aStr = TCollection_ExtendedString(l,0);
 385     for(j=1; j<=l; j++) {
 386       theStream >> anExtChar;
 387       aStr.SetValue(j, anExtChar);
 388     }
 389     myCols->Append(aStr);
 390   }
 391
 392   //Restore the table values
 393   theStream >> l;
 394   myTable.Clear();
 395   for(i=1; i<=l; i++) {
 396     Standard_Integer aKey;
 397     Standard_Real aValue;
 398     theStream >> aKey;
 399     theStream >> aValue;
 400     myTable.Bind(aKey, aValue);
 401   }
 402
 403   return true;
 404 }