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