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
  14 #include "SALOMEDS_AttributeTableOfString_i.hxx"
  15 #include "SALOMEDS_SObject_i.hxx"
  16 #include <TColStd_HSequenceOfExtendedString.hxx>
  17
  18 #include <Standard_Failure.hxx>
  19 #include <Standard_ErrorHandler.hxx>
  20
  21 #include <strstream>
  22 #include <string>
  23
  24 #include "Utils_ExceptHandlers.hxx"
  25 using namespace std;
  26 UNEXPECT_CATCH(ATS_IncorrectIndex, SALOMEDS::AttributeTableOfString::IncorrectIndex);
  27 UNEXPECT_CATCH(ATS_IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectArgumentLength);
  28
  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
  50
  51 void SALOMEDS_AttributeTableOfString_i::SetTitle(const char* theTitle) {
  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   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  60   CORBA::String_var c_s = CORBA::string_dup(TCollection_AsciiString(aTable->GetTitle()).ToCString());
  61   return c_s._retn();
  62 }
  63
  64 void SALOMEDS_AttributeTableOfString_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
  65      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
  66 {
  67   Unexpect aCatch(ATS_IncorrectIndex);
  68   CheckLocked();
  69   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  70   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
  71   CORBA::String_var aStr = CORBA::string_dup(theTitle);
  72   TCollection_ExtendedString aTitle(aStr);
  73   TCollection_ExtendedString aUnit = getUnit(aTable->GetRowTitle(theIndex));
  74   if(aUnit.Length() > 0) {
  75     aTitle += SEPARATOR;
  76     aTitle += aUnit;
  77   }
  78
  79   aTable->SetRowTitle(theIndex, aTitle);
  80 }
  81
  82 void SALOMEDS_AttributeTableOfString_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
  83      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
  84 {
  85   Unexpect aCatch(ATS_IncorrectArgumentLength);
  86   CheckLocked();
  87   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  88   if (theTitles.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
  89   for (int i = 0; i < theTitles.length(); i++) {
  90     SetRowTitle(i + 1, CORBA::string_dup(theTitles[i]));
  91   }
  92 }
  93
  94 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRowTitles() {
  95   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
  96   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
  97   aTitles->length(aTable->GetNbRows());
  98   for(int i = 0; i < aTitles->length(); i++)
  99     aTitles[i] = CORBA::string_dup(TCollection_AsciiString(getTitle(aTable->GetRowTitle(i + 1))).ToCString());
 100   return aTitles._retn();
 101 }
 102
 103 void SALOMEDS_AttributeTableOfString_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
 104      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 105 {
 106   Unexpect aCatch(ATS_IncorrectIndex);
 107   CheckLocked();
 108   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 109   if (theIndex <= 0 || theIndex > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 110   CORBA::String_var aStr = CORBA::string_dup(theTitle);
 111   aTable->SetColumnTitle(theIndex, TCollection_ExtendedString(aStr));
 112 }
 113
 114 void SALOMEDS_AttributeTableOfString_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
 115      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 116 {
 117   Unexpect aCatch(ATS_IncorrectArgumentLength);
 118   CheckLocked();
 119   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 120   if (theTitles.length() != aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
 121   for (int i = 0; i < theTitles.length(); i++) {
 122     SetColumnTitle(i + 1, CORBA::string_dup(theTitles[i]));
 123   }
 124 }
 125
 126 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetColumnTitles() {
 127   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 128   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
 129   aTitles->length(aTable->GetNbColumns());
 130   for(int i = 0; i < aTitles->length(); i++)
 131     aTitles[i] = CORBA::string_dup(TCollection_AsciiString(aTable->GetColumnTitle(i + 1)).ToCString());
 132   return aTitles._retn();
 133 }
 134
 135 //Units support
 136 void SALOMEDS_AttributeTableOfString_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
 137      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 138 {
 139   Unexpect aCatch(ATS_IncorrectIndex);
 140   CheckLocked();
 141   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 142   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 143   CORBA::String_var aStr = CORBA::string_dup(theUnit);
 144   TCollection_ExtendedString aTitle = getTitle(aTable->GetRowTitle(theIndex));
 145   TCollection_ExtendedString aUnit(aStr);
 146   aTitle += SEPARATOR;
 147   aTitle += aUnit;
 148   aTable->SetRowTitle(theIndex, aTitle);
 149 }
 150
 151 void SALOMEDS_AttributeTableOfString_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
 152      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 153 {
 154   Unexpect aCatch(ATS_IncorrectArgumentLength);
 155   CheckLocked();
 156   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 157   if (theUnits.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectArgumentLength();
 158   for (int i = 0; i < theUnits.length(); i++) {
 159     SetRowUnit(i + 1, CORBA::string_dup(theUnits[i]));
 160   }
 161 }
 162
 163 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRowUnits() {
 164   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 165   SALOMEDS::StringSeq_var aUnits = new SALOMEDS::StringSeq;
 166   aUnits->length(aTable->GetNbRows());
 167   for(int i = 0; i < aUnits->length(); i++)
 168     aUnits[i] = CORBA::string_dup(TCollection_AsciiString(getUnit(aTable->GetRowTitle(i + 1))).ToCString());
 169   return aUnits._retn();
 170 }
 171
 172
 173 CORBA::Long SALOMEDS_AttributeTableOfString_i::GetNbRows() {
 174   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->GetNbRows();
 175 }
 176 CORBA::Long SALOMEDS_AttributeTableOfString_i::GetNbColumns() {
 177   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->GetNbColumns();
 178 }
 179
 180 void SALOMEDS_AttributeTableOfString_i::AddRow(const SALOMEDS::StringSeq& theData)
 181      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 182 {
 183   Unexpect aCatch(ATS_IncorrectArgumentLength);
 184   CheckLocked();
 185   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 186
 187   Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
 188   for (int i = 0; i < theData.length(); i++) aRow->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 189   aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
 190 }
 191
 192 void SALOMEDS_AttributeTableOfString_i::SetRow(CORBA::Long theRow, const SALOMEDS::StringSeq& theData)
 193      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectIndex)
 194 {
 195   Unexpect aCatch(ATS_IncorrectArgumentLength);
 196   CheckLocked();
 197   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 198
 199   Handle(TColStd_HSequenceOfExtendedString) aRow = new TColStd_HSequenceOfExtendedString;
 200   for (int i = 0; i < theData.length(); i++) aRow->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 201   aTable->SetRowData(theRow, aRow);
 202 }
 203
 204 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetRow(CORBA::Long theRow)
 205      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 206 {
 207   Unexpect aCatch(ATS_IncorrectIndex);
 208   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 209   if (theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 210
 211   SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
 212   Handle(TColStd_HSequenceOfExtendedString) aRow = aTable->GetRowData(theRow);
 213   CorbaSeq->length(aRow->Length());
 214   for (int i = 0; i < aRow->Length(); i++) {
 215     CorbaSeq[i] = CORBA::string_dup((TCollection_AsciiString(aRow->Value(i + 1))).ToCString());
 216   }
 217   return CorbaSeq._retn();
 218 }
 219
 220 void SALOMEDS_AttributeTableOfString_i::AddColumn(const SALOMEDS::StringSeq& theData)
 221      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength)
 222 {
 223   Unexpect aCatch(ATS_IncorrectArgumentLength);
 224   CheckLocked();
 225   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 226
 227   Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
 228   for (int i = 0; i < theData.length(); i++) aColumn->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 229   aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
 230 }
 231
 232 void SALOMEDS_AttributeTableOfString_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::StringSeq& theData)
 233      throw (SALOMEDS::AttributeTableOfString::IncorrectArgumentLength, SALOMEDS::AttributeTableOfString::IncorrectIndex)
 234 {
 235   Unexpect aCatch(ATS_IncorrectArgumentLength);
 236   CheckLocked();
 237   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 238
 239   Handle(TColStd_HSequenceOfExtendedString) aColumn = new TColStd_HSequenceOfExtendedString;
 240   for (int i = 0; i < theData.length(); i++) aColumn->Append(TCollection_AsciiString(CORBA::string_dup(theData[i])));
 241   aTable->SetColumnData(theColumn, aColumn);
 242 }
 243
 244 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfString_i::GetColumn(CORBA::Long theColumn)
 245      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 246 {
 247   Unexpect aCatch(ATS_IncorrectIndex);
 248   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 249   if (theColumn <= 0 || theColumn > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 250
 251   SALOMEDS::StringSeq_var CorbaSeq = new SALOMEDS::StringSeq;
 252   Handle(TColStd_HSequenceOfExtendedString) aColumn = aTable->GetColumnData(theColumn);
 253   CorbaSeq->length(aColumn->Length());
 254   for (int i = 0; i < aColumn->Length(); i++) {
 255     CorbaSeq[i] = CORBA::string_dup((TCollection_AsciiString(aColumn->Value(i + 1))).ToCString());
 256   }
 257   return CorbaSeq._retn();
 258 }
 259
 260 void SALOMEDS_AttributeTableOfString_i::PutValue(const char* theValue, CORBA::Long theRow, CORBA::Long theColumn)
 261      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 262 {
 263   Unexpect aCatch(ATS_IncorrectIndex);
 264   CheckLocked();
 265   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 266   char* aValue = CORBA::string_dup(theValue);
 267
 268   aTable->PutValue(aValue, theRow, theColumn);
 269 }
 270
 271 CORBA::Boolean SALOMEDS_AttributeTableOfString_i::HasValue(CORBA::Long theRow, CORBA::Long theColumn) {
 272   return Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr)->HasValue(theRow, theColumn);
 273 }
 274
 275 char* SALOMEDS_AttributeTableOfString_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
 276      throw (SALOMEDS::AttributeTableOfString::IncorrectIndex)
 277 {
 278   Unexpect aCatch(ATS_IncorrectIndex);
 279   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 280   if (theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 281
 282   TCollection_AsciiString aValue;
 283
 284   try {
 285     aValue = aTable->GetValue(theRow, theColumn);
 286   }
 287   catch(Standard_Failure) {
 288     throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 289   }
 290
 291   return CORBA::string_dup(aValue.ToCString());
 292 }
 293
 294
 295 SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfString_i::GetRowSetIndices(CORBA::Long theRow)
 296 {
 297   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 298
 299   if(theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfString::IncorrectIndex();
 300
 301   SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
 302   Handle(TColStd_HSequenceOfInteger) aSeq = aTable->GetSetRowIndices(theRow);
 303   CorbaSeq->length(aSeq->Length());
 304   for (int i = 0; i < aSeq->Length(); i++) {
 305     CorbaSeq[i] = aSeq->Value(i + 1);
 306   }
 307   return CorbaSeq._retn();
 308 }
 309
 310
 311 void SALOMEDS_AttributeTableOfString_i::SetNbColumns(CORBA::Long theNbColumns)
 312 {
 313   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 314   aTable->SetNbColumns(theNbColumns);
 315 }
 316
 317 bool SALOMEDS_AttributeTableOfString_i::ReadFromFile(const SALOMEDS::TMPFile& theStream)
 318 {
 319   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 320
 321   istrstream aStream((char*)&theStream[0], theStream.length());
 322   return aTable->RestoreFromString(aStream);
 323 }
 324
 325 SALOMEDS::TMPFile*  SALOMEDS_AttributeTableOfString_i::SaveToFile()
 326 {
 327   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 328
 329   ostrstream ostr;
 330   aTable->ConvertToString(ostr);
 331   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)ostr.rdbuf()->str();
 332   unsigned long aSize = ostr.pcount();
 333   SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(aSize, aSize, anOctetBuf, 1);
 334   return aStreamFile._retn();
 335 }
 336
 337 char* SALOMEDS_AttributeTableOfString_i::Store() {
 338   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 339
 340   ostrstream ostr;
 341   aTable->ConvertToString(ostr);
 342   string aString = ostr.rdbuf()->str();
 343
 344   CORBA::String_var aBuffer = CORBA::string_dup(aString.c_str());
 345   return aBuffer._retn();
 346 }
 347
 348 void SALOMEDS_AttributeTableOfString_i::Restore(const char* value) {
 349   Handle(SALOMEDS_TableOfStringAttribute) aTable = Handle(SALOMEDS_TableOfStringAttribute)::DownCast(_myAttr);
 350
 351   istrstream aStream(value, strlen(value));
 352   aTable->RestoreFromString(aStream);
 353 }