src/SALOMEDS/SALOMEDS_AttributeTableOfString_i.cxx

   1 //  SALOME SALOMEDS : data structure of SALOME and sources of Salome data server
   2 //
   3 //  Copyright (C) 2003  CEA/DEN, EDF R&D
   4 //
   5 //
   6 //
   7 //  File   : SALOMEDS_AttributeTableOfString_i.cxx
   8 //  Author : Sergey Ruin
   9 //  Module : SALOME
  10
  11 #include <TCollection_ExtendedString.hxx>
  12 #include <TCollection_AsciiString.hxx>
  13 #include <TColStd_HSequenceOfExtendedString.hxx>
  14
  15 #include <Standard_Failure.hxx>
  16
  17 #include <strstream>
  18 #include <string>
  19
  20 #include "SALOMEDS_AttributeTableOfString_i.hxx"
  21 #include "SALOMEDS.hxx"
  22
  23 #include "Utils_ExceptHandlers.hxx"
  24
  25 UNEXPECT_CATCH(ATS_IncorrectIndex, SALOMEDS::AttributeTableOfString::IncorrectIndex);
  26 UNEXPECT_CATCH(ATS_IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectArgumentLength);
  27
  28 using namespace std;
  29 #define SEPARATOR '\1'
  30
  31 static TCollection_ExtendedString getUnit(TCollection_ExtendedString theString)
  32 {
  33   TCollection_ExtendedString aString(theString);
  34   int aPos = aString.Search(SEPARATOR);
  35   if(aPos <= 0 || aPos == aString.Length() ) return TCollection_ExtendedString();
  36   return aString.Split(aPos);
  37 }
  38
  39 static TCollection_ExtendedString getTitle(TCollection_ExtendedString theString)
  40 {
  41   TCollection_ExtendedString aString(theString);
  42   int aPos = aString.Search(SEPARATOR);
  43   if(aPos < 1) return aString;
  44   if(aPos == 1) return TCollection_ExtendedString();
  45   aString.Split(aPos-1);
  46   return aString;
  47 }
  48
  49 void SALOMEDS_AttributeTableOfString_i::SetTitle(const char* theTitle) {
  50   SALOMEDS::Locker lock;
  51
  52   CheckLocked();
  53   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  54   CORBA::String_var aStr = CORBA::string_dup(theTitle);
  55   aTable->SetTitle(TCollection_ExtendedString(aStr));
  56 }
  57
  58 char* SALOMEDS_AttributeTableOfString_i::GetTitle() {
  59   SALOMEDS::Locker lock;
  60
  61   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  62   CORBA::String_var c_s = CORBA::string_dup(TCollection_AsciiString(aTable->GetTitle()).ToCString());
  63   return c_s._retn();
  64 }
  65
  66 void SALOMEDS_AttributeTableOfString_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
  67      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
  68 {
  69   SALOMEDS::Locker lock;
  70
  71   Unexpect aCatch(ATS_IncorrectIndex);
  72   CheckLocked();
  73   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  74   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
  75   CORBA::String_var aStr = CORBA::string_dup(theTitle);
  76   TCollection_ExtendedString aTitle(aStr);
  77   TCollection_ExtendedString aUnit = getUnit(aTable->GetRowTitle(theIndex));
  78   if(aUnit.Length() > 0) {
  79     aTitle += SEPARATOR;
  80     aTitle += aUnit;
  81   }
  82
  83   aTable->SetRowTitle(theIndex, aTitle);
  84 }
  85
  86 void SALOMEDS_AttributeTableOfString_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
  87      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
  88 {
  89   SALOMEDS::Locker lock;
  90
  91   Unexpect aCatch(ATS_IncorrectArgumentLength);
  92   CheckLocked();
  93   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  94   if (theTitles.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
  95   for (int i = 0; i < theTitles.length(); i++) {
  96     SetRowTitle(i + 1, CORBA::string_dup(theTitles[i]));
  97   }
  98 }
  99
 100 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRowTitles() {
 101   SALOMEDS::Locker lock;
 102
 103   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 104   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
 105   aTitles->length(aTable->GetNbRows());
 106   for(int i = 0; i < aTitles->length(); i++)
 107     aTitles[i] = CORBA::string_dup(TCollection_AsciiString(getTitle(aTable->GetRowTitle(i + 1))).ToCString());
 108   return aTitles._retn();
 109 }
 110
 111 void SALOMEDS_AttributeTableOfString_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
 112      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 113 {
 114   SALOMEDS::Locker lock;
 115
 116   Unexpect aCatch(ATS_IncorrectIndex);
 117   CheckLocked();
 118   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 119   if (theIndex <= 0 || theIndex > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 120   CORBA::String_var aStr = CORBA::string_dup(theTitle);
 121   aTable->SetColumnTitle(theIndex, TCollection_ExtendedString(aStr));
 122 }
 123
 124 void SALOMEDS_AttributeTableOfString_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
 125      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 126 {
 127   SALOMEDS::Locker lock;
 128
 129   Unexpect aCatch(ATS_IncorrectArgumentLength);
 130   CheckLocked();
 131   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 132   if (theTitles.length() != aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
 133   for (int i = 0; i < theTitles.length(); i++) {
 134     SetColumnTitle(i + 1, CORBA::string_dup(theTitles[i]));
 135   }
 136 }
 137
 138 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetColumnTitles() {
 139   SALOMEDS::Locker lock;
 140
 141   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 142   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
 143   aTitles->length(aTable->GetNbColumns());
 144   for(int i = 0; i < aTitles->length(); i++)
 145     aTitles[i] = CORBA::string_dup(TCollection_AsciiString(aTable->GetColumnTitle(i + 1)).ToCString());
 146   return aTitles._retn();
 147 }
 148
 149 //Units support
 150 void SALOMEDS_AttributeTableOfString_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
 151      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 152 {
 153   SALOMEDS::Locker lock;
 154
 155   Unexpect aCatch(ATS_IncorrectIndex);
 156   CheckLocked();
 157   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 158   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 159   CORBA::String_var aStr = CORBA::string_dup(theUnit);
 160   TCollection_ExtendedString aTitle = getTitle(aTable->GetRowTitle(theIndex));
 161   TCollection_ExtendedString aUnit(aStr);
 162   aTitle += SEPARATOR;
 163   aTitle += aUnit;
 164   aTable->SetRowTitle(theIndex, aTitle);
 165 }
 166
 167 void SALOMEDS_AttributeTableOfString_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
 168      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 169 {
 170   SALOMEDS::Locker lock;
 171
 172   Unexpect aCatch(ATS_IncorrectArgumentLength);
 173   CheckLocked();
 174   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 175   if (theUnits.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
 176   for (int i = 0; i < theUnits.length(); i++) {
 177     SetRowUnit(i + 1, CORBA::string_dup(theUnits[i]));
 178   }
 179 }
 180
 181 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRowUnits() {
 182   SALOMEDS::Locker lock;
 183
 184   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 185   SALOMEDS::StringSeq_var aUnits = new SALOMEDS::StringSeq;
 186   aUnits->length(aTable->GetNbRows());
 187   for(int i = 0; i < aUnits->length(); i++)
 188     aUnits[i] = CORBA::string_dup(TCollection_AsciiString(getUnit(aTable->GetRowTitle(i + 1))).ToCString());
 189   return aUnits._retn();
 190 }
 191
 192
 193 CORBA::Long SALOMEDS_AttributeTableOfString_i::GetNbRows() {
 194   SALOMEDS::Locker lock;
 195
 196   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->GetNbRows();
 197 }
 198 CORBA::Long SALOMEDS_AttributeTableOfString_i::GetNbColumns() {
 199   SALOMEDS::Locker lock;
 200
 201   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->GetNbColumns();
 202 }
 203
 204 void SALOMEDS_AttributeTableOfString_i::AddRow(const SALOMEDS::StringSeq& theData)
 205      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 206 {
 207   SALOMEDS::Locker lock;
 208
 209   Unexpect aCatch(ATS_IncorrectArgumentLength);
 210   CheckLocked();
 211   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 212
 213   Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
 214   for (int i = 0; i < theData.length(); i++) aRow->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 215   aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
 216 }
 217
 218 void SALOMEDS_AttributeTableOfString_i::SetRow(CORBA::Long theRow, const SALOMEDS::StringSeq& theData)
 219      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectIndex)
 220 {
 221   SALOMEDS::Locker lock;
 222
 223   Unexpect aCatch(ATS_IncorrectArgumentLength);
 224   CheckLocked();
 225   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 226
 227   Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
 228   for (int i = 0; i < theData.length(); i++) aRow->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 229   aTable->SetRowData(theRow, aRow);
 230 }
 231
 232 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRow(CORBA::Long theRow)
 233      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 234 {
 235   SALOMEDS::Locker lock;
 236
 237   Unexpect aCatch(ATS_IncorrectIndex);
 238   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 239   if (theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 240
 241   SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
 242   Handle(TColStd_HSequenceOfExtendedString) aRow = aTable->GetRowData(theRow);
 243   CorbaSeq->length(aRow->Length());
 244   for (int i = 0; i < aRow->Length(); i++) {
 245     CorbaSeq[i] = CORBA::string_dup((TCollection_AsciiString(aRow->Value(i + 1))).ToCString());
 246   }
 247   return CorbaSeq._retn();
 248 }
 249
 250 void SALOMEDS_AttributeTableOfString_i::AddColumn(const SALOMEDS::StringSeq& theData)
 251      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 252 {
 253   SALOMEDS::Locker lock;
 254
 255   Unexpect aCatch(ATS_IncorrectArgumentLength);
 256   CheckLocked();
 257   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 258
 259   Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
 260   for (int i = 0; i < theData.length(); i++) aColumn->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 261   aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
 262 }
 263
 264 void SALOMEDS_AttributeTableOfString_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::StringSeq& theData)
 265      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectIndex)
 266 {
 267   SALOMEDS::Locker lock;
 268
 269   Unexpect aCatch(ATS_IncorrectArgumentLength);
 270   CheckLocked();
 271   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 272
 273   Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
 274   for (int i = 0; i < theData.length(); i++) aColumn->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 275   aTable->SetColumnData(theColumn, aColumn);
 276 }
 277
 278 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetColumn(CORBA::Long theColumn)
 279      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 280 {
 281   SALOMEDS::Locker lock;
 282
 283   Unexpect aCatch(ATS_IncorrectIndex);
 284   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 285   if (theColumn <= 0 || theColumn > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 286
 287   SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
 288   Handle(TColStd_HSequenceOfExtendedString) aColumn = aTable->GetColumnData(theColumn);
 289   CorbaSeq->length(aColumn->Length());
 290   for (int i = 0; i < aColumn->Length(); i++) {
 291     CorbaSeq[i] = CORBA::string_dup((TCollection_AsciiString(aColumn->Value(i + 1))).ToCString());
 292   }
 293   return CorbaSeq._retn();
 294 }
 295
 296 void SALOMEDS_AttributeTableOfString_i::PutValue(const char* theValue, CORBA::Long theRow, CORBA::Long theColumn)
 297      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 298 {
 299   SALOMEDS::Locker lock;
 300
 301   Unexpect aCatch(ATS_IncorrectIndex);
 302   CheckLocked();
 303   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 304   char* aValue = CORBA::string_dup(theValue);
 305
 306   aTable->PutValue(aValue, theRow, theColumn);
 307 }
 308
 309 CORBA::Boolean SALOMEDS_AttributeTableOfString_i::HasValue(CORBA::Long theRow, CORBA::Long theColumn) {
 310   SALOMEDS::Locker lock;
 311
 312   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->HasValue(theRow, theColumn);
 313 }
 314
 315 char* SALOMEDS_AttributeTableOfString_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
 316      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 317 {
 318   SALOMEDS::Locker lock;
 319
 320   Unexpect aCatch(ATS_IncorrectIndex);
 321   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 322   if (theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 323
 324   TCollection_AsciiString aValue;
 325
 326   try {
 327     aValue = aTable->GetValue(theRow, theColumn);
 328   }
 329   catch(Standard_Failure) {
 330     throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 331   }
 332
 333   return CORBA::string_dup(aValue.ToCString());
 334 }
 335
 336
 337 SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::GetRowSetIndices(CORBA::Long theRow)
 338 {
 339   SALOMEDS::Locker lock;
 340
 341   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 342
 343   if(theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 344
 345   SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
 346   Handle(TColStd_HSequenceOfInteger) aSeq = aTable->GetSetRowIndices(theRow);
 347   CorbaSeq->length(aSeq->Length());
 348   for (int i = 0; i < aSeq->Length(); i++) {
 349     CorbaSeq[i] = aSeq->Value(i + 1);
 350   }
 351   return CorbaSeq._retn();
 352 }
 353
 354
 355 void SALOMEDS_AttributeTableOfString_i::SetNbColumns(CORBA::Long theNbColumns)
 356 {
 357   SALOMEDS::Locker lock;
 358
 359   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 360   aTable->SetNbColumns(theNbColumns);
 361 }
 362
 363 bool SALOMEDS_AttributeTableOfString_i::ReadFromFile(const SALOMEDS::TMPFile& theStream)
 364 {
 365   SALOMEDS::Locker lock;
 366
 367   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 368
 369   istrstream aStream((char*)&theStream[0], theStream.length());
 370   return aTable->RestoreFromString(aStream);
 371 }
 372
 373 SALOMEDS::TMPFile*  SALOMEDS_AttributeTableOfString_i::SaveToFile()
 374 {
 375   SALOMEDS::Locker lock;
 376
 377   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 378
 379   ostrstream ostr;
 380   aTable->ConvertToString(ostr);
 381   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)ostr.rdbuf()->str();
 382   unsigned long aSize = ostr.pcount();
 383   SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(aSize, aSize, anOctetBuf, 1);
 384   return aStreamFile._retn();
 385 }
 386
 387 char* SALOMEDS_AttributeTableOfString_i::Store() {
 388   SALOMEDS::Locker lock;
 389
 390   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 391
 392   ostrstream ostr;
 393   aTable->ConvertToString(ostr);
 394   string aString = ostr.rdbuf()->str();
 395
 396   CORBA::String_var aBuffer = CORBA::string_dup(aString.c_str());
 397   return aBuffer._retn();
 398 }
 399
 400 void SALOMEDS_AttributeTableOfString_i::Restore(const char* value) {
 401   SALOMEDS::Locker lock;
 402
 403   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 404
 405   istrstream aStream(value, strlen(value));
 406   aTable->RestoreFromString(aStream);
 407 }