]> SALOME platform Git repositories - modules/shaper.git/blob - src/Model/Model_AttributeTables.cpp
Salome HOME
Improve code coverage for elliptic arcs.
[modules/shaper.git] / src / Model / Model_AttributeTables.cpp
1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #include "Model_AttributeTables.h"
21
22 #include <ModelAPI_Data.h>
23 #include <ModelAPI_Object.h>
24
25 #include <TColStd_ListIteratorOfListOfInteger.hxx>
26 #include <TDataStd_RealArray.hxx>
27 #include <TDataStd_BooleanArray.hxx>
28 #include <TDataStd_IntegerArray.hxx>
29 #include <TDataStd_ExtStringArray.hxx>
30
31 #include <TColStd_HArray1OfReal.hxx>
32 #include <TColStd_HArray1OfByte.hxx>
33 #include <TColStd_HArray1OfInteger.hxx>
34 #include <TColStd_HArray1OfExtendedString.hxx>
35
36 #include <string>
37
38 // returns the array attribute GUID for the given type
39 #define MY_ARRAY_ID(type) \
40 ((type) == ModelAPI_AttributeTables::DOUBLE ? TDataStd_RealArray::GetID(): \
41 ((type) == ModelAPI_AttributeTables::BOOLEAN ? TDataStd_BooleanArray::GetID(): \
42 ((type) == ModelAPI_AttributeTables::INTEGER? TDataStd_IntegerArray::GetID(): \
43 TDataStd_ExtStringArray::GetID())))
44
45 int Model_AttributeTables::rows()
46 {
47   return myRows;
48 }
49
50 int Model_AttributeTables::columns()
51 {
52   return myCols;
53 }
54
55 int Model_AttributeTables::tables()
56 {
57   return myTables;
58 }
59
60 void Model_AttributeTables::setSize(const int theRows, const int theColumns, const int theTables)
61 {
62   if (theRows != myRows || theColumns != myCols || theTables != myTables) {
63     owner()->data()->sendAttributeUpdated(this);
64     int aSize = myRows * myCols * myTables;
65     int aNewSize = theRows * theColumns * theTables;
66     if (aSize == 0 && aNewSize == 0) {
67       // nothing to do
68     } else if (aNewSize == 0) {
69       // remove old array
70       myLab.ForgetAttribute(MY_ARRAY_ID(myType));
71     } else {
72       // prepare new arrays
73       Handle(TColStd_HArray1OfReal) anOldDouble, aNewDouble =
74         (myType == ModelAPI_AttributeTables::DOUBLE) ?
75         new TColStd_HArray1OfReal(0, aNewSize - 1) : Handle(TColStd_HArray1OfReal)();
76       bool* anOldBool = 0; // an not work with internal arrays because of different indexing
77       Handle(TDataStd_BooleanArray) aBoolArray; // an existing array
78       Handle(TColStd_HArray1OfInteger) anOldInt, aNewInt =
79         (myType == ModelAPI_AttributeTables::INTEGER) ?
80         new TColStd_HArray1OfInteger(0, aNewSize - 1) : Handle(TColStd_HArray1OfInteger)();
81       Handle(TColStd_HArray1OfExtendedString) anOldStr, aNewStr =
82         (myType == ModelAPI_AttributeTables::STRING) ?
83         new TColStd_HArray1OfExtendedString(0, aNewSize - 1) :
84         Handle(TColStd_HArray1OfExtendedString)();
85       if (aSize != 0) { // copy the previous values into new positions, otherwise default values
86         Handle(TDF_Attribute) anArray;
87         myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
88         switch(myType) {
89         case ModelAPI_AttributeTables::DOUBLE:
90           anOldDouble = Handle(TDataStd_RealArray)::DownCast(anArray)->Array();
91           break;
92         case ModelAPI_AttributeTables::BOOLEAN: {
93           anOldBool = new bool[aSize];
94           aBoolArray = Handle(TDataStd_BooleanArray)::DownCast(anArray);
95           for(int a = 0; a < aSize; a++)
96             anOldBool[a] = aBoolArray->Value(a);
97           aBoolArray->Init(0, aNewSize - 1);
98           break;
99         }
100         case ModelAPI_AttributeTables::INTEGER:
101           anOldInt = Handle(TDataStd_IntegerArray)::DownCast(anArray)->Array();
102           break;
103         case ModelAPI_AttributeTables::STRING:
104           anOldStr = Handle(TDataStd_ExtStringArray)::DownCast(anArray)->Array();
105           break;
106         }
107       } else if (myType == ModelAPI_AttributeTables::BOOLEAN) {
108         aBoolArray = TDataStd_BooleanArray::Set(myLab, 0, aNewSize - 1);
109       }
110       for(int aTable = 0; aTable < theTables; aTable++) {
111         for(int aColumn = 0; aColumn < theColumns; aColumn++) {
112           for(int aRow = 0; aRow < theRows; aRow++) {
113             int anOldIndex, anIndex = aTable * theRows * theColumns + aRow * theColumns + aColumn;
114             bool aRestore = aTable < myTables && aColumn < myCols && aRow < myRows;
115             if (aRestore)
116               anOldIndex = aTable * myRows * myCols + aRow * myCols + aColumn;
117             switch(myType) {
118             case ModelAPI_AttributeTables::DOUBLE: {
119               aNewDouble->SetValue(anIndex, aRestore ? anOldDouble->Value(anOldIndex) : 0.);
120               break;
121             }
122             case ModelAPI_AttributeTables::BOOLEAN: {
123               aBoolArray->SetValue(anIndex, aRestore ? anOldBool[anOldIndex] : Standard_False);
124               break;
125             }
126             case ModelAPI_AttributeTables::INTEGER: {
127               aNewInt->SetValue(anIndex, aRestore ? anOldInt->Value(anOldIndex) : 0);
128               break;
129             }
130             case ModelAPI_AttributeTables::STRING: {
131               aNewStr->SetValue(anIndex, aRestore ? anOldStr->Value(anOldIndex) : "");
132               break;
133             }
134             }
135           }
136         }
137       }
138       // store the new array
139       switch(myType) {
140       case ModelAPI_AttributeTables::DOUBLE:
141         TDataStd_RealArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewDouble);
142         break;
143       case ModelAPI_AttributeTables::BOOLEAN: // nothing to do: array was set in "else" of restore
144         break;
145       case ModelAPI_AttributeTables::INTEGER:
146         TDataStd_IntegerArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewInt);
147         break;
148       case ModelAPI_AttributeTables::STRING:
149         TDataStd_ExtStringArray::Set(myLab, 0, aNewSize - 1)->ChangeArray(aNewStr);
150         break;
151       }
152     }
153     // store the new sizes
154     myRows = theRows;
155     myCols = theColumns;
156     myTables = theTables;
157     myProp->Clear();
158     myProp->Append(int(myType)); // default
159     myProp->Append(myTables);
160     myProp->Append(myRows);
161     myProp->Append(myCols);
162     owner()->data()->sendAttributeUpdated(this);
163   }
164 }
165
166 void Model_AttributeTables::setType(ModelAPI_AttributeTables::ValueType theType)
167 {
168   if (myType != theType) {
169     // remove the old attr
170     int aSize = myRows * myCols * myTables;
171     if (aSize != 0) {
172       myLab.ForgetAttribute(MY_ARRAY_ID(myType));
173       myType = theType;
174       int aTables = myTables;
175       myTables = 0; // to let setSize know that there is no old array
176       setSize(myRows, myCols, aTables);
177     } else {
178       myType = theType;
179       owner()->data()->sendAttributeUpdated(this);
180     }
181   }
182 }
183
184 const ModelAPI_AttributeTables::ValueType& Model_AttributeTables::type() const
185 {
186   return myType;
187 }
188
189 void Model_AttributeTables::setValue(const ModelAPI_AttributeTables::Value theValue,
190   const int theRow, const int theColumn, const int theTable)
191 {
192   int anIndex = theTable * myRows * myCols + theRow * myCols + theColumn;
193   Handle(TDF_Attribute) anArray;
194   myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
195   switch(myType) {
196   case ModelAPI_AttributeTables::DOUBLE: {
197     Handle(TDataStd_RealArray)::DownCast(anArray)->SetValue(anIndex, theValue.myDouble);
198     break;
199   }
200   case ModelAPI_AttributeTables::BOOLEAN: {
201     Handle(TDataStd_BooleanArray)::DownCast(anArray)->SetValue(anIndex, theValue.myBool);
202     break;
203   }
204   case ModelAPI_AttributeTables::INTEGER: {
205     Handle(TDataStd_IntegerArray)::DownCast(anArray)->SetValue(anIndex, theValue.myInt);
206     break;
207   }
208   case ModelAPI_AttributeTables::STRING: {
209     Handle(TDataStd_ExtStringArray)::DownCast(anArray)->SetValue(anIndex, theValue.myStr.c_str());
210     break;
211   }
212   }
213   owner()->data()->sendAttributeUpdated(this);
214 }
215
216 ModelAPI_AttributeTables::Value Model_AttributeTables::value(
217   const int theRow, const int theColumn, const int theTable)
218 {
219   ModelAPI_AttributeTables::Value aResult;
220   int anIndex = theTable * myRows * myCols + theRow * myCols + theColumn;
221   Handle(TDF_Attribute) anArray;
222   myLab.FindAttribute(MY_ARRAY_ID(myType), anArray);
223   switch(myType) {
224   case ModelAPI_AttributeTables::DOUBLE: {
225     aResult.myDouble = Handle(TDataStd_RealArray)::DownCast(anArray)->Value(anIndex);
226     break;
227   }
228   case ModelAPI_AttributeTables::BOOLEAN: {
229     aResult.myBool = Handle(TDataStd_BooleanArray)::DownCast(anArray)->Value(anIndex) ==
230       Standard_True;
231     break;
232   }
233   case ModelAPI_AttributeTables::INTEGER: {
234     aResult.myInt = Handle(TDataStd_IntegerArray)::DownCast(anArray)->Value(anIndex);
235     break;
236   }
237   case ModelAPI_AttributeTables::STRING: {
238     aResult.myStr = TCollection_AsciiString(Handle(TDataStd_ExtStringArray)::DownCast(anArray)->
239       Value(anIndex)).ToCString();
240     break;
241   }
242   }
243   return aResult;
244 }
245
246 std::string Model_AttributeTables::valueStr(
247     const int theRow, const int theColumn, const int theTable)
248 {
249   std::ostringstream aStr;
250   switch(myType) {
251   case ModelAPI_AttributeTables::DOUBLE:
252     aStr<<value(theRow, theColumn, theTable).myDouble;
253     break;
254   case ModelAPI_AttributeTables::BOOLEAN:
255     aStr<<(value(theRow, theColumn, theTable).myBool ? "True" :"False");
256     break;
257   case ModelAPI_AttributeTables::INTEGER:
258     aStr<<value(theRow, theColumn, theTable).myInt;
259     break;
260   case ModelAPI_AttributeTables::STRING:
261     aStr<<value(theRow, theColumn, theTable).myStr;
262     break;
263   }
264   return aStr.str();
265 }
266
267 //==================================================================================================
268 Model_AttributeTables::Model_AttributeTables(TDF_Label& theLabel)
269 {
270   myLab = theLabel;
271   reinit();
272 }
273
274 void Model_AttributeTables::reinit()
275 {
276   // check the attribute could be already presented in this doc (after load document)
277   myIsInitialized =
278     myLab.FindAttribute(TDataStd_IntegerList::GetID(), myProp) == Standard_True;
279   if (!myIsInitialized) {
280     myProp = TDataStd_IntegerList::Set(myLab);
281     myProp->Append(int(Model_AttributeTables::DOUBLE)); // default
282     myProp->Append(0);
283     myProp->Append(0);
284     myProp->Append(0);
285   }
286   TColStd_ListIteratorOfListOfInteger aListIter(myProp->List());
287   myType = ModelAPI_AttributeTables::ValueType(aListIter.Value());
288   aListIter.Next();
289   myTables = aListIter.Value();
290   aListIter.Next();
291   myRows = aListIter.Value();
292   aListIter.Next();
293   myCols = aListIter.Value();
294 }