]> SALOME platform Git repositories - modules/kernel.git/blob - src/SALOMEDS/SALOMEDS_AttributeTableOfReal_i.cxx
Salome HOME
Join modifications from BR_Dev_For_4_0 tag V4_1_1.
[modules/kernel.git] / src / SALOMEDS / SALOMEDS_AttributeTableOfReal_i.cxx
1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
3 // 
4 // This library is free software; you can redistribute it and/or
5 // modify it under the terms of the GNU Lesser General Public
6 // License as published by the Free Software Foundation; either 
7 // version 2.1 of the License.
8 // 
9 // This library is distributed in the hope that it will be useful 
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
12 // Lesser General Public License for more details.
13 //
14 // You should have received a copy of the GNU Lesser General Public  
15 // License along with this library; if not, write to the Free Software 
16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 //
18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 //
20 //  File   : SALOMEDS_AttributeTableOfReal_i.cxx
21 //  Author : Sergey RUIN
22 //  Module : SALOME
23
24
25 #include "SALOMEDS_AttributeTableOfReal_i.hxx"
26 #include "SALOMEDS.hxx"
27
28 #include <strstream>
29 #include <string>
30 #include <vector>
31
32 using namespace std;
33
34 #include "Utils_ExceptHandlers.hxx"
35 UNEXPECT_CATCH(ATR_IncorrectIndex, SALOMEDS::AttributeTableOfReal::IncorrectIndex);
36 UNEXPECT_CATCH(ATR_IncorrectArgumentLength, SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength);
37
38 void SALOMEDS_AttributeTableOfReal_i::SetTitle(const char* theTitle) 
39 {
40   SALOMEDS::Locker lock;     
41   CheckLocked();
42   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
43   CORBA::String_var aStr = CORBA::string_dup(theTitle);
44   aTable->SetTitle(string(aStr));
45 }
46
47 char* SALOMEDS_AttributeTableOfReal_i::GetTitle() 
48 {
49   SALOMEDS::Locker lock; 
50   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
51   CORBA::String_var c_s = CORBA::string_dup(aTable->GetTitle().c_str());
52   return c_s._retn();
53 }
54
55 void SALOMEDS_AttributeTableOfReal_i::SetRowTitle(CORBA::Long theIndex, const char* theTitle)
56      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
57 {
58   SALOMEDS::Locker lock; 
59   Unexpect aCatch (ATR_IncorrectIndex);
60   CheckLocked();
61   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
62   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
63   aTable->SetRowTitle(theIndex, string(theTitle));
64 }
65
66 void SALOMEDS_AttributeTableOfReal_i::SetRowTitles(const SALOMEDS::StringSeq& theTitles)
67      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength)
68 {
69   SALOMEDS::Locker lock; 
70   Unexpect aCatch (ATR_IncorrectArgumentLength);
71   CheckLocked();
72   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
73   if (theTitles.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength();
74   for (int i = 0; i < theTitles.length(); i++) {
75     aTable->SetRowTitle(i + 1, (char*)theTitles[i].in());
76   }
77 }
78
79 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfReal_i::GetRowTitles() 
80 {
81   SALOMEDS::Locker lock; 
82   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
83   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
84   aTitles->length(aTable->GetNbRows());
85   for(int i = 0; i < aTitles->length(); i++)
86     aTitles[i] = CORBA::string_dup(aTable->GetRowTitle(i + 1).c_str());
87   return aTitles._retn();
88 }
89
90 void SALOMEDS_AttributeTableOfReal_i::SetColumnTitle(CORBA::Long theIndex, const char* theTitle)
91      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
92 {
93   SALOMEDS::Locker lock; 
94   Unexpect aCatch (ATR_IncorrectIndex);
95   CheckLocked();
96   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
97   if (theIndex <= 0 || theIndex > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
98   CORBA::String_var aStr = CORBA::string_dup(theTitle);
99   aTable->SetColumnTitle(theIndex, string(aStr));
100 }
101
102 void SALOMEDS_AttributeTableOfReal_i::SetColumnTitles(const SALOMEDS::StringSeq& theTitles)
103      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength)
104 {
105   SALOMEDS::Locker lock; 
106   Unexpect aCatch(ATR_IncorrectArgumentLength);
107   CheckLocked();
108   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
109   if (theTitles.length() != aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength();
110   for (int i = 0; i < theTitles.length(); i++) {
111     aTable->SetColumnTitle(i + 1, (char*)theTitles[i].in());
112   }
113 }
114
115 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfReal_i::GetColumnTitles() 
116 {
117   SALOMEDS::Locker lock; 
118   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
119   SALOMEDS::StringSeq_var aTitles = new SALOMEDS::StringSeq;
120   aTitles->length(aTable->GetNbColumns());
121   for(int i = 0; i < aTitles->length(); i++)
122     aTitles[i] = CORBA::string_dup(aTable->GetColumnTitle(i + 1).c_str());
123   return aTitles._retn();
124 }
125
126 //Units support
127 void SALOMEDS_AttributeTableOfReal_i::SetRowUnit(CORBA::Long theIndex, const char* theUnit)
128      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
129 {
130   SALOMEDS::Locker lock; 
131   Unexpect aCatch (ATR_IncorrectIndex);
132   CheckLocked();
133   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
134   if (theIndex <= 0 || theIndex > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
135   aTable->SetRowUnit(theIndex, string(theUnit));
136 }
137
138 void SALOMEDS_AttributeTableOfReal_i::SetRowUnits(const SALOMEDS::StringSeq& theUnits)
139      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength)
140 {
141   SALOMEDS::Locker lock; 
142   Unexpect aCatch (ATR_IncorrectArgumentLength);
143   CheckLocked();
144   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
145   if (theUnits.length() != aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength();
146   for (int i = 0; i < theUnits.length(); i++) {
147     aTable->SetRowUnit(i + 1, (char*)theUnits[i].in());
148   }
149 }
150
151 SALOMEDS::StringSeq* SALOMEDS_AttributeTableOfReal_i::GetRowUnits() 
152 {
153   SALOMEDS::Locker lock; 
154   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
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(aTable->GetRowUnit(i + 1).c_str());
159   return aUnits._retn();
160 }
161
162
163 CORBA::Long SALOMEDS_AttributeTableOfReal_i::GetNbRows() 
164 {
165   SALOMEDS::Locker lock; 
166   return dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl)->GetNbRows();
167 }
168
169 CORBA::Long SALOMEDS_AttributeTableOfReal_i::GetNbColumns() 
170 {
171   SALOMEDS::Locker lock; 
172   return dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl)->GetNbColumns();
173 }
174
175 void SALOMEDS_AttributeTableOfReal_i::AddRow(const SALOMEDS::DoubleSeq& theData)
176      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength)
177 {
178   SALOMEDS::Locker lock; 
179   Unexpect aCatch(ATR_IncorrectArgumentLength);
180   CheckLocked();
181   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
182   
183   vector<double> aRow;
184   for (int i = 0; i < theData.length(); i++) aRow.push_back(theData[i]);
185   aTable->SetRowData(aTable->GetNbRows() + 1, aRow);
186 }
187
188 void SALOMEDS_AttributeTableOfReal_i::SetRow(CORBA::Long theRow, const SALOMEDS::DoubleSeq& theData)
189      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength, SALOMEDS::AttributeTableOfReal::IncorrectIndex)
190 {
191   SALOMEDS::Locker lock; 
192   Unexpect aCatch(ATR_IncorrectArgumentLength);
193   CheckLocked();
194   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
195   
196   vector<double> aRow;
197   for (int i = 0; i < theData.length(); i++) aRow.push_back(theData[i]);
198   aTable->SetRowData(theRow, aRow);
199 }
200
201 SALOMEDS::DoubleSeq* SALOMEDS_AttributeTableOfReal_i::GetRow(CORBA::Long theRow)
202      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
203 {
204   SALOMEDS::Locker lock; 
205   Unexpect aCatch(ATR_IncorrectIndex);
206   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
207   if (theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
208
209   SALOMEDS::DoubleSeq_var CorbaSeq = new SALOMEDS::DoubleSeq;
210   vector<double> aRow = aTable->GetRowData(theRow);
211   CorbaSeq->length(aRow.size());
212   for (int i = 0; i < aRow.size(); i++) {
213     CorbaSeq[i] = aRow[i];
214   }
215   return CorbaSeq._retn();
216 }
217
218 void SALOMEDS_AttributeTableOfReal_i::AddColumn(const SALOMEDS::DoubleSeq& theData)
219      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength)
220 {
221   SALOMEDS::Locker lock; 
222   Unexpect aCatch(ATR_IncorrectArgumentLength);
223   CheckLocked();
224   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
225   
226   vector<double> aColumn;
227   for (int i = 0; i < theData.length(); i++) aColumn.push_back(theData[i]);
228   aTable->SetColumnData(aTable->GetNbColumns() + 1, aColumn);
229 }
230
231 void SALOMEDS_AttributeTableOfReal_i::SetColumn(CORBA::Long theColumn, const SALOMEDS::DoubleSeq& theData)
232      throw (SALOMEDS::AttributeTableOfReal::IncorrectArgumentLength, SALOMEDS::AttributeTableOfReal::IncorrectIndex)
233 {
234   SALOMEDS::Locker lock; 
235   Unexpect aCatch(ATR_IncorrectArgumentLength);
236   CheckLocked();
237   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
238   
239   vector<double> aColumn;
240   for (int i = 0; i < theData.length(); i++) aColumn.push_back(theData[i]);
241   aTable->SetColumnData(theColumn, aColumn);
242 }
243
244 SALOMEDS::DoubleSeq* SALOMEDS_AttributeTableOfReal_i::GetColumn(CORBA::Long theColumn)
245      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
246 {
247   SALOMEDS::Locker lock; 
248   Unexpect aCatch(ATR_IncorrectIndex);
249   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
250   if (theColumn <= 0 || theColumn > aTable->GetNbColumns()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
251
252   SALOMEDS::DoubleSeq_var CorbaSeq = new SALOMEDS::DoubleSeq;
253   vector<double> aColumn = aTable->GetColumnData(theColumn);
254   CorbaSeq->length(aColumn.size());
255   for (int i = 0; i < aColumn.size(); i++) {
256     CorbaSeq[i] = aColumn[i];
257   }
258   return CorbaSeq._retn();
259 }
260
261 void SALOMEDS_AttributeTableOfReal_i::PutValue(CORBA::Double theValue, CORBA::Long theRow, CORBA::Long theColumn)
262      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
263 {
264   SALOMEDS::Locker lock; 
265   Unexpect aCatch(ATR_IncorrectIndex);
266   CheckLocked();
267   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
268
269   aTable->PutValue(theValue, theRow, theColumn);
270 }
271
272 CORBA::Boolean SALOMEDS_AttributeTableOfReal_i::HasValue(CORBA::Long theRow, CORBA::Long theColumn) 
273 {
274   SALOMEDS::Locker lock; 
275   return dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl)->HasValue(theRow, theColumn);
276 }
277
278 CORBA::Double SALOMEDS_AttributeTableOfReal_i::GetValue(CORBA::Long theRow, CORBA::Long theColumn)
279      throw (SALOMEDS::AttributeTableOfReal::IncorrectIndex)
280 {
281   SALOMEDS::Locker lock; 
282   Unexpect aCatch(ATR_IncorrectIndex);
283   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
284   if (theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
285
286   CORBA::Double aValue;
287
288   try {
289     aValue = aTable->GetValue(theRow, theColumn);
290   }
291   catch(...) {
292     throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
293   }
294
295   return aValue;
296 }
297
298
299 SALOMEDS::LongSeq* SALOMEDS_AttributeTableOfReal_i::GetRowSetIndices(CORBA::Long theRow) 
300 {
301   SALOMEDS::Locker lock; 
302   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
303
304   if(theRow <= 0 || theRow > aTable->GetNbRows()) throw SALOMEDS::AttributeTableOfReal::IncorrectIndex();
305
306   SALOMEDS::LongSeq_var CorbaSeq = new SALOMEDS::LongSeq;
307   vector<int> aSeq = aTable->GetSetRowIndices(theRow);
308   int len = aSeq.size();
309   CorbaSeq->length(len);
310   for (int i = 0; i < len; i++) {
311     CorbaSeq[i] = aSeq[i];
312   }
313   return CorbaSeq._retn(); 
314 }
315
316
317 void SALOMEDS_AttributeTableOfReal_i::SetNbColumns(CORBA::Long theNbColumns)
318 {
319   SALOMEDS::Locker lock; 
320   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
321   aTable->SetNbColumns(theNbColumns);
322 }
323
324 bool SALOMEDS_AttributeTableOfReal_i::ReadFromFile(const SALOMEDS::TMPFile& theStream) 
325 {
326   SALOMEDS::Locker lock; 
327   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
328
329   string aStream((char*)&theStream[0], theStream.length());
330   aTable->Load(aStream);
331   return true;
332 }
333
334 SALOMEDS::TMPFile*  SALOMEDS_AttributeTableOfReal_i::SaveToFile()
335 {
336   SALOMEDS::Locker lock; 
337   SALOMEDSImpl_AttributeTableOfReal* aTable = dynamic_cast<SALOMEDSImpl_AttributeTableOfReal*>(_impl);
338
339   string aString = aTable->Save();
340   char* aBuffer = (char*)CORBA::string_dup(aString.c_str());
341   int aBufferSize = strlen((char*)aBuffer);
342
343   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)aBuffer;
344
345   SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(aBufferSize, aBufferSize, anOctetBuf, 1);
346
347   return aStreamFile._retn();
348 }