src/SALOMEDS/SALOMEDS_TableOfStringAttribute.cxx

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