src/SALOMEDS/SALOMEDS_AttributeTableOfString_i.cxx

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