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