]> SALOME platform Git repositories - modules/shaper.git/blob - src/XAO/XAO_XaoExporter.cxx
Salome HOME
Task #2924 : Ability to remove a result. Disable ability to remove groups and fields...
[modules/shaper.git] / src / XAO / XAO_XaoExporter.cxx
1 // Copyright (C) 2013-2019  CEA/DEN, EDF R&D, OPEN CASCADE
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 // Author : Frederic Pons (OpenCascade)
20
21 #include <libxml/parser.h>
22
23 #include "XAO_XaoExporter.hxx"
24 #include "XAO_Xao.hxx"
25 #include "XAO_Geometry.hxx"
26 #include "XAO_Group.hxx"
27 #include "XAO_Field.hxx"
28 #include "XAO_Step.hxx"
29 #include "XAO_XaoUtils.hxx"
30
31 #ifdef WIN32
32 # define _separator_ '\\'
33 #else
34 # define _separator_ '/'
35 #endif
36
37 namespace XAO
38 {
39     const xmlChar* C_TAG_XAO = (xmlChar*)"XAO";
40     const xmlChar* C_ATTR_XAO_AUTHOR = (xmlChar*)"author";
41     const xmlChar* C_ATTR_XAO_VERSION = (xmlChar*)"version";
42
43     const xmlChar* C_TAG_GEOMETRY = (xmlChar*)"geometry";
44     const xmlChar* C_ATTR_GEOMETRY_NAME = (xmlChar*)"name";
45
46     const xmlChar* C_TAG_SHAPE = (xmlChar*)"shape";
47     const xmlChar* C_ATTR_SHAPE_FORMAT = (xmlChar*)"format";
48     const xmlChar* C_ATTR_SHAPE_FILE = (xmlChar*)"file";
49
50     const xmlChar* C_TAG_TOPOLOGY = (xmlChar*)"topology";
51     const xmlChar* C_TAG_VERTICES = (xmlChar*)"vertices";
52     const xmlChar* C_TAG_VERTEX = (xmlChar*)"vertex";
53     const xmlChar* C_TAG_EDGES = (xmlChar*)"edges";
54     const xmlChar* C_TAG_EDGE = (xmlChar*)"edge";
55     const xmlChar* C_TAG_FACES = (xmlChar*)"faces";
56     const xmlChar* C_TAG_FACE = (xmlChar*)"face";
57     const xmlChar* C_TAG_SOLIDS = (xmlChar*)"solids";
58     const xmlChar* C_TAG_SOLID = (xmlChar*)"solid";
59     const xmlChar* C_ATTR_COUNT = (xmlChar*)"count";
60     const xmlChar* C_ATTR_ELT_INDEX = (xmlChar*)"index";
61     const xmlChar* C_ATTR_ELT_NAME = (xmlChar*)"name";
62     const xmlChar* C_ATTR_ELT_REFERENCE = (xmlChar*)"reference";
63
64     const xmlChar* C_TAG_GROUPS = (xmlChar*)"groups";
65     const xmlChar* C_TAG_GROUP = (xmlChar*)"group";
66     const xmlChar* C_ATTR_GROUP_NAME = (xmlChar*)"name";
67     const xmlChar* C_ATTR_GROUP_DIM = (xmlChar*)"dimension";
68
69     const xmlChar* C_TAG_ELEMENT = (xmlChar*)"element";
70     const xmlChar* C_ATTR_ELEMENT_INDEX = (xmlChar*)"index";
71     const xmlChar* C_TAG_VALUE = (xmlChar*)"value";
72     const xmlChar* C_ATTR_VALUE_COMPONENT = (xmlChar*)"component";
73
74     const xmlChar* C_TAG_FIELDS = (xmlChar*)"fields";
75     const xmlChar* C_TAG_FIELD = (xmlChar*)"field";
76     const xmlChar* C_ATTR_FIELD_NAME = (xmlChar*)"name";
77     const xmlChar* C_ATTR_FIELD_TYPE = (xmlChar*)"type";
78     const xmlChar* C_ATTR_FIELD_DIMENSION = (xmlChar*)"dimension";
79     const xmlChar* C_TAG_COMPONENTS = (xmlChar*)"components";
80     const xmlChar* C_TAG_COMPONENT = (xmlChar*)"component";
81     const xmlChar* C_ATTR_COMPONENT_COLUMN = (xmlChar*)"column";
82     const xmlChar* C_ATTR_COMPONENT_NAME = (xmlChar*)"name";
83
84     const xmlChar* C_TAG_STEPS = (xmlChar*)"steps";
85     const xmlChar* C_TAG_STEP = (xmlChar*)"step";
86     const xmlChar* C_ATTR_STEP_NUMBER = (xmlChar*)"number";
87     const xmlChar* C_ATTR_STEP_STAMP = (xmlChar*)"stamp";
88 }
89
90 using namespace XAO;
91
92 namespace {
93     xmlDocPtr exportXMLDoc(Xao* xaoObject, const std::string& shapeFileName);
94     void exportGeometry(Geometry* xaoGeometry, xmlDocPtr doc, xmlNodePtr xao, const std::string& shapeFileName);
95     void exportGeometricElements(Geometry* xaoGeometry, xmlNodePtr topology,
96                                  XAO::Dimension dim, const xmlChar* colTag, const xmlChar* eltTag);
97     void exportGroups(Xao* xaoObject, xmlNodePtr xao);
98     void exportFields(Xao* xaoObject, xmlNodePtr xao);
99     void exportStep(Step* step, Field* field, xmlNodePtr nodeSteps);
100
101     void parseXMLDoc(xmlDocPtr doc, Xao* xaoObject);
102     void parseXaoNode(xmlDocPtr doc, xmlNodePtr xaoNode, Xao* xaoObject);
103     void parseGeometryNode(xmlDocPtr doc, xmlNodePtr geometryNode, Xao* xaoObject);
104     void parseShapeNode(xmlDocPtr doc, xmlNodePtr shapeNode, Geometry* geometry);
105     void parseTopologyNode(xmlNodePtr topologyNode, Geometry* geometry);
106     void parseVerticesNode(xmlNodePtr verticesNode, Geometry* geometry);
107     void parseEdgesNode(xmlNodePtr edgesNode, Geometry* geometry);
108     void parseFacesNode(xmlNodePtr facesNode, Geometry* geometry);
109     void parseSolidsNode(xmlNodePtr solidsNode, Geometry* geometry);
110     void parseGroupsNode(xmlNodePtr groupsNode, Xao* xaoObject);
111     void parseGroupNode(xmlNodePtr groupNode, Xao* xaoObject);
112
113     void parseFieldsNode(xmlNodePtr fieldsNode, Xao* xaoObject);
114     void parseFieldNode(xmlNodePtr fieldNode, Xao* xaoObject);
115     void parseStepNode(xmlNodePtr stepNode, Field* field);
116     void parseStepElementNode(xmlNodePtr eltNode, Step* step);
117
118     std::string readStringProp(xmlNodePtr node, const xmlChar* attribute,
119                                const bool& required, const std::string& defaultValue,
120                                const std::string& exception = std::string(""));
121     int readIntegerProp(xmlNodePtr node, const xmlChar* attribute,
122                         const bool& required, const int& defaultValue,
123                         const std::string& exception = std::string(""));
124
125     std::string readStringProp(xmlNodePtr node, const xmlChar* attribute,
126                                const bool& required, const std::string& defaultValue,
127                                const std::string& exception /*= std::string() */)
128   {
129     xmlChar* strAttr = xmlGetProp(node, attribute);
130     if (strAttr == NULL)
131     {
132         if (required)
133         {
134             if (exception.size() > 0)
135                 throw XAO_Exception(exception.c_str());
136
137             throw XAO_Exception(MsgBuilder() << "Line " << node->line << ": "
138                                              << "Property " << (char*)attribute << " is required.");
139         }
140
141         return defaultValue;
142     }
143
144     std::string res = (char*)strAttr;
145     xmlFree(strAttr);
146     return res;
147   }
148
149   int readIntegerProp(xmlNodePtr node, const xmlChar* attribute,
150                       const bool& required, const int& defaultValue,
151                       const std::string& exception /*= std::string() */)
152   {
153     xmlChar* strAttr = xmlGetProp(node, attribute);
154     if (strAttr == NULL)
155     {
156         if (required)
157         {
158             if (exception.size() > 0)
159                 throw XAO_Exception(exception.c_str());
160
161             throw XAO_Exception(MsgBuilder() << "Line " << node->line << ": "
162                                              << "Property " << (char*)attribute << " is required.");
163         }
164
165         return defaultValue;
166     }
167
168     int res = XaoUtils::stringToInt((char*)strAttr);
169     xmlFree(strAttr);
170     return res;
171   }
172
173   xmlDocPtr exportXMLDoc(Xao* xaoObject, const std::string& shapeFileName)
174   {
175     // Creating the Xml document
176     xmlDocPtr masterDocument = xmlNewDoc(BAD_CAST "1.0");
177     xmlNodePtr xao = xmlNewNode(0, C_TAG_XAO);
178     xmlDocSetRootElement(masterDocument, xao);
179
180     xmlNewProp(xao, C_ATTR_XAO_VERSION, BAD_CAST xaoObject->getVersion().c_str());
181     xmlNewProp(xao, C_ATTR_XAO_AUTHOR, BAD_CAST xaoObject->getAuthor().c_str());
182
183     if (xaoObject->getGeometry() != NULL)
184     {
185         exportGeometry(xaoObject->getGeometry(), masterDocument, xao, shapeFileName);
186     }
187
188     exportGroups(xaoObject, xao);
189     exportFields(xaoObject, xao);
190
191     return masterDocument;
192   }
193
194   void exportGeometricElements(Geometry* xaoGeometry,
195                                xmlNodePtr topology, XAO::Dimension dim, const xmlChar* colTag, const xmlChar* eltTag)
196   {
197     xmlNodePtr vertices = xmlNewChild(topology, 0, colTag, 0);
198     xmlNewProp(vertices, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(xaoGeometry->countElements(dim)).c_str());
199     GeometricElementList::iterator it = xaoGeometry->begin(dim);
200     for (; it != xaoGeometry->end(dim); it++)
201     {
202         int index = it->first;
203         GeometricElement elt = it->second;
204         xmlNodePtr vertex = xmlNewChild(vertices, 0, eltTag, 0);
205         xmlNewProp(vertex, C_ATTR_ELT_INDEX, BAD_CAST XaoUtils::intToString(index).c_str());
206         xmlNewProp(vertex, C_ATTR_ELT_NAME, BAD_CAST elt.getName().c_str());
207         xmlNewProp(vertex, C_ATTR_ELT_REFERENCE, BAD_CAST elt.getReference().c_str());
208     }
209   }
210
211   void exportGeometry(Geometry* xaoGeometry, xmlDocPtr doc, xmlNodePtr xao,
212                       const std::string& shapeFileName)
213   {
214     // Geometric part
215     xmlNodePtr geometry = xmlNewChild(xao, 0, C_TAG_GEOMETRY, 0);
216     xmlNewProp(geometry, C_ATTR_GEOMETRY_NAME, BAD_CAST xaoGeometry->getName().c_str());
217
218     xmlNodePtr shape = xmlNewChild(geometry, 0, C_TAG_SHAPE, 0);
219     xmlNewProp(shape, C_ATTR_SHAPE_FORMAT, BAD_CAST XaoUtils::shapeFormatToString(xaoGeometry->getFormat()).c_str());
220
221     if (shapeFileName == "")
222     {
223         // export the shape in the XAO file
224         std::string txtShape = xaoGeometry->getShapeString();
225         xmlNodePtr cdata = xmlNewCDataBlock(doc, BAD_CAST txtShape.c_str(), txtShape.size());
226         xmlAddChild(shape, cdata);
227     }
228     else
229     {
230         // export the shape in an external file
231         xmlNewProp(shape, C_ATTR_SHAPE_FILE, BAD_CAST shapeFileName.c_str());
232         xaoGeometry->writeShapeFile(shapeFileName);
233     }
234
235     xmlNodePtr topology = xmlNewChild(geometry, 0, C_TAG_TOPOLOGY, 0);
236
237     exportGeometricElements(xaoGeometry, topology, XAO::VERTEX, C_TAG_VERTICES, C_TAG_VERTEX);
238     exportGeometricElements(xaoGeometry, topology, XAO::EDGE, C_TAG_EDGES, C_TAG_EDGE);
239     exportGeometricElements(xaoGeometry, topology, XAO::FACE, C_TAG_FACES, C_TAG_FACE);
240     exportGeometricElements(xaoGeometry, topology, XAO::SOLID, C_TAG_SOLIDS, C_TAG_SOLID);
241   }
242
243   void exportGroups(Xao* xaoObject, xmlNodePtr xao)
244   {
245     xmlNodePtr groups = xmlNewChild(xao, 0, C_TAG_GROUPS, 0);
246     xmlNewProp(groups, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(xaoObject->countGroups()).c_str());
247
248     for (int i = 0; i < xaoObject->countGroups(); i++)
249     {
250         //Group* grp = (*it);
251         Group* grp = xaoObject->getGroup(i);
252         xmlNodePtr group = xmlNewChild(groups, 0, C_TAG_GROUP, 0);
253         xmlNewProp(group, C_ATTR_GROUP_NAME, BAD_CAST grp->getName().c_str());
254         xmlNewProp(group, C_ATTR_GROUP_DIM, BAD_CAST XaoUtils::dimensionToString(grp->getDimension()).c_str());
255         xmlNewProp(group, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(grp->count()).c_str());
256
257         for (std::set<int>::iterator it = grp->begin(); it != grp->end(); ++it)
258         {
259             int grpElt = (*it);
260             xmlNodePtr elt = xmlNewChild(group, 0, C_TAG_ELEMENT, 0);
261             xmlNewProp(elt, C_ATTR_ELEMENT_INDEX, BAD_CAST XaoUtils::intToString(grpElt).c_str());
262         }
263     }
264   }
265
266   void exportFields(Xao* xaoObject, xmlNodePtr xao)
267   {
268     xmlNodePtr fields = xmlNewChild(xao, 0, C_TAG_FIELDS, 0);
269     xmlNewProp(fields, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(xaoObject->countFields()).c_str());
270
271     for (int i = 0; i < xaoObject->countFields(); i++)
272     {
273         Field* field = xaoObject->getField(i);
274         xmlNodePtr nodeField = xmlNewChild(fields, 0, C_TAG_FIELD, 0);
275         xmlNewProp(nodeField, C_ATTR_FIELD_NAME, BAD_CAST field->getName().c_str());
276         xmlNewProp(nodeField, C_ATTR_FIELD_TYPE, BAD_CAST XaoUtils::fieldTypeToString(field->getType()).c_str());
277         xmlNewProp(nodeField, C_ATTR_FIELD_DIMENSION, BAD_CAST XaoUtils::dimensionToString(field->getDimension()).c_str());
278
279         int nbComponents = field->countComponents();
280         xmlNodePtr components = xmlNewChild(nodeField, 0, C_TAG_COMPONENTS, 0);
281         xmlNewProp(components, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(nbComponents).c_str());
282
283         for (int j = 0; j < nbComponents; j++)
284         {
285             xmlNodePtr nodeComponent = xmlNewChild(components, 0, C_TAG_COMPONENT, 0);
286             xmlNewProp(nodeComponent, C_ATTR_COMPONENT_COLUMN, BAD_CAST XaoUtils::intToString(j).c_str());
287             xmlNewProp(nodeComponent, C_ATTR_COMPONENT_NAME, BAD_CAST field->getComponentName(j).c_str());
288         }
289
290         int nbSteps = field->countSteps();
291         xmlNodePtr nodeSteps = xmlNewChild(nodeField, 0, C_TAG_STEPS, 0);
292         xmlNewProp(nodeSteps, C_ATTR_COUNT, BAD_CAST XaoUtils::intToString(nbSteps).c_str());
293         for (stepIterator itStep = field->begin(); itStep != field->end(); itStep++)
294         {
295             Step* step = *itStep;
296             exportStep(step, field, nodeSteps);
297         }
298     }
299   }
300
301   void exportStep(Step* step, Field* field, xmlNodePtr nodeSteps)
302   {
303     xmlNodePtr nodeStep = xmlNewChild(nodeSteps, 0, C_TAG_STEP, 0);
304     xmlNewProp(nodeStep, C_ATTR_STEP_NUMBER, BAD_CAST XaoUtils::intToString(step->getStep()).c_str());
305     if (step->getStamp() >= 0)
306     {
307         xmlNewProp(nodeStep, C_ATTR_STEP_STAMP, BAD_CAST XaoUtils::intToString(step->getStamp()).c_str());
308     }
309
310     for(int i = 0; i < step->countElements(); ++i)
311     {
312         xmlNodePtr nodeElt = xmlNewChild(nodeStep, 0, C_TAG_ELEMENT, 0);
313         xmlNewProp(nodeElt, C_ATTR_ELEMENT_INDEX, BAD_CAST XaoUtils::intToString(i).c_str());
314
315         for (int j = 0; j < step->countComponents(); ++j)
316         {
317             std::string content = step->getStringValue(i, j);
318             xmlNodePtr nodeValue = xmlNewChild(nodeElt, NULL, C_TAG_VALUE, BAD_CAST content.c_str());
319             xmlNewProp(nodeValue, C_ATTR_VALUE_COMPONENT, BAD_CAST XaoUtils::intToString(j).c_str());
320         }
321     }
322   }
323
324   void parseXMLDoc(xmlDocPtr doc, Xao* xaoObject)
325   {
326     // Get the root element node
327     xmlNodePtr root = xmlDocGetRootElement(doc);
328     if (xmlStrcmp(root->name , C_TAG_XAO) != 0)
329         throw XAO_Exception("Cannot read XAO file: invalid format XAO node not found");
330
331     parseXaoNode(doc, root, xaoObject);
332
333     xmlFreeDoc(doc);       // free document
334     //xmlCleanupParser();    // free globals //vsr: xmlCleanupParser should not be called from the application
335   }
336
337   void parseXaoNode(xmlDocPtr doc, xmlNodePtr xaoNode, Xao* xaoObject)
338   {
339     std::string version = readStringProp(xaoNode, C_ATTR_XAO_VERSION, false, "");
340     if (version != "")
341         xaoObject->setVersion(version);
342
343     std::string author = readStringProp(xaoNode, C_ATTR_XAO_AUTHOR, false, "");
344     xaoObject->setAuthor(author);
345
346     for (xmlNodePtr node = xaoNode->children; node; node = node->next)
347     {
348         if (xmlStrcmp(node->name, C_TAG_GEOMETRY) == 0)
349             parseGeometryNode(doc, node, xaoObject);
350         else if (xmlStrcmp(node->name, C_TAG_GROUPS) == 0)
351             parseGroupsNode(node, xaoObject);
352         else if (xmlStrcmp(node->name, C_TAG_FIELDS) == 0)
353             parseFieldsNode(node, xaoObject);
354     }
355   }
356
357   void parseGeometryNode(xmlDocPtr doc, xmlNodePtr geometryNode, Xao* xaoObject)
358   {
359     // get the shape and topo nodes
360     xmlNodePtr shapeNode = NULL;
361     xmlNodePtr topoNode = NULL;
362     for (xmlNodePtr node = geometryNode->children; node; node = node->next)
363     {
364         if (xmlStrcmp(node->name, C_TAG_SHAPE) == 0)
365             shapeNode = node;
366         else if (xmlStrcmp(node->name, C_TAG_TOPOLOGY) == 0)
367             topoNode = node;
368     }
369
370     std::string name = readStringProp(geometryNode, C_ATTR_GEOMETRY_NAME, false, "");
371     std::string strFormat = readStringProp(shapeNode, C_ATTR_SHAPE_FORMAT, true, "");
372     XAO::Format shapeFormat = XaoUtils::stringToShapeFormat(strFormat);
373     Geometry* geometry = Geometry::createGeometry(shapeFormat, name);
374
375     parseShapeNode(doc, shapeNode, geometry);
376     parseTopologyNode(topoNode, geometry);
377
378     xaoObject->setGeometry(geometry);
379   }
380
381   void parseShapeNode(xmlDocPtr doc, xmlNodePtr shapeNode, Geometry* geometry)
382   {
383     if (geometry->getFormat() == XAO::BREP)
384     {
385         std::string strFile = readStringProp(shapeNode, C_ATTR_SHAPE_FILE, false, "");
386         if (strFile != "")
387         {
388             geometry->readShapeFile(strFile);
389         }
390         else
391         {
392             // read brep from node content
393             xmlChar* data = xmlNodeGetContent(shapeNode->children);
394             if (data == NULL)
395                 throw XAO_Exception("Missing BREP");
396             geometry->setShapeString((char*)data);
397             xmlFree(data);
398         }
399     }
400     else
401     {
402         throw XAO_Exception(MsgBuilder() << "Shape format not supported: "
403                                          << XaoUtils::shapeFormatToString(geometry->getFormat()));
404     }
405   }
406
407   void parseTopologyNode(xmlNodePtr topologyNode, Geometry* geometry)
408   {
409     for (xmlNodePtr node = topologyNode->children; node; node = node->next)
410     {
411         if (xmlStrcmp(node->name, C_TAG_VERTICES) == 0)
412             parseVerticesNode(node, geometry);
413         else if (xmlStrcmp(node->name, C_TAG_EDGES) == 0)
414             parseEdgesNode(node, geometry);
415         else if (xmlStrcmp(node->name, C_TAG_FACES) == 0)
416             parseFacesNode(node, geometry);
417         else if (xmlStrcmp(node->name, C_TAG_SOLIDS) == 0)
418             parseSolidsNode(node, geometry);
419     }
420   }
421
422   void parseVerticesNode(xmlNodePtr verticesNode, Geometry* geometry)
423   {
424     int count = readIntegerProp(verticesNode, C_ATTR_COUNT, true, -1);
425     geometry->setCountVertices(count);
426
427     for (xmlNodePtr node = verticesNode->children; node; node = node->next)
428     {
429         if (xmlStrcmp(node->name, C_TAG_VERTEX) == 0)
430         {
431             int index = readIntegerProp(node, C_ATTR_ELT_INDEX, true, -1);
432             std::string name = readStringProp(node, C_ATTR_ELT_NAME, false, "");
433             std::string reference = readStringProp(node, C_ATTR_ELT_REFERENCE, true, "");
434
435             geometry->setVertex(index, name, reference);
436         }
437     }
438   }
439
440   void parseEdgesNode(xmlNodePtr edgesNode, Geometry* geometry)
441   {
442     int count = readIntegerProp(edgesNode, C_ATTR_COUNT, true, -1);
443     geometry->setCountEdges(count);
444
445     for (xmlNodePtr node = edgesNode->children; node; node = node->next)
446     {
447         if (xmlStrcmp(node->name, C_TAG_EDGE) == 0)
448         {
449             int index = readIntegerProp(node, C_ATTR_ELT_INDEX, true, -1);
450             std::string name = readStringProp(node, C_ATTR_ELT_NAME, false, "");
451             std::string reference = readStringProp(node, C_ATTR_ELT_REFERENCE, true, "");
452
453             geometry->setEdge(index, name, reference);
454         }
455     }
456   }
457
458   void parseFacesNode(xmlNodePtr facesNode, Geometry* geometry)
459   {
460     int count = readIntegerProp(facesNode, C_ATTR_COUNT, true, -1);
461     geometry->setCountFaces(count);
462
463     for (xmlNodePtr node = facesNode->children; node; node = node->next)
464     {
465         if (xmlStrcmp(node->name, C_TAG_FACE) == 0)
466         {
467             int index = readIntegerProp(node, C_ATTR_ELT_INDEX, true, -1);
468             std::string name = readStringProp(node, C_ATTR_ELT_NAME, false, "");
469             std::string reference = readStringProp(node, C_ATTR_ELT_REFERENCE, true, "");
470
471             geometry->setFace(index, name, reference);
472         }
473     }
474   }
475
476   void parseSolidsNode(xmlNodePtr solidsNode, Geometry* geometry)
477   {
478     int count = readIntegerProp(solidsNode, C_ATTR_COUNT, true, -1);
479     geometry->setCountSolids(count);
480
481     for (xmlNodePtr node = solidsNode->children; node; node = node->next)
482     {
483         if (xmlStrcmp(node->name, C_TAG_SOLID) == 0)
484         {
485             int index = readIntegerProp(node, C_ATTR_ELT_INDEX, true, -1);
486             std::string name = readStringProp(node, C_ATTR_ELT_NAME, false, "");
487             std::string reference = readStringProp(node, C_ATTR_ELT_REFERENCE, true, "");
488
489             geometry->setSolid(index, name, reference);
490         }
491     }
492   }
493
494   void parseGroupsNode(xmlNodePtr groupsNode, Xao* xaoObject)
495   {
496     for (xmlNodePtr node = groupsNode->children; node; node = node->next)
497     {
498         if (xmlStrcmp(node->name, C_TAG_GROUP) == 0)
499         {
500             parseGroupNode(node, xaoObject);
501         }
502     }
503   }
504
505   void parseGroupNode(xmlNodePtr groupNode, Xao* xaoObject)
506   {
507     std::string strDimension = readStringProp(groupNode, C_ATTR_GROUP_DIM, true, "");
508     XAO::Dimension dim = XaoUtils::stringToDimension(strDimension);
509     Group* group = xaoObject->addGroup(dim);
510
511     std::string name = readStringProp(groupNode, C_ATTR_GROUP_NAME, false, "");
512     group->setName(name);
513
514     for (xmlNodePtr node = groupNode->children; node; node = node->next)
515     {
516         if (xmlStrcmp(node->name, C_TAG_ELEMENT) == 0)
517         {
518             int index = readIntegerProp(node, C_ATTR_ELEMENT_INDEX, true, -1);
519             group->add(index);
520         }
521     }
522   }
523
524   void parseFieldsNode(xmlNodePtr fieldsNode, Xao* xaoObject)
525   {
526     for (xmlNodePtr node = fieldsNode->children; node; node = node->next)
527     {
528         if (xmlStrcmp(node->name, C_TAG_FIELD) == 0)
529         {
530             parseFieldNode(node, xaoObject);
531         }
532     }
533   }
534
535   void parseFieldNode(xmlNodePtr fieldNode, Xao* xaoObject)
536   {
537     std::string strDimension = readStringProp(fieldNode, C_ATTR_FIELD_DIMENSION, true, "");
538     XAO::Dimension dim = XaoUtils::stringToDimension(strDimension);
539
540     std::string strType = readStringProp(fieldNode, C_ATTR_FIELD_TYPE, true, "");
541     XAO::Type type = XaoUtils::stringToFieldType(strType);
542
543     // we need to get the number of components first to create the field
544     xmlNodePtr componentsNode = NULL;
545     xmlNodePtr stepsNode = NULL;
546
547     for (xmlNodePtr node = fieldNode->children; node; node = node->next)
548     {
549         if (xmlStrcmp(node->name, C_TAG_COMPONENTS) == 0)
550             componentsNode = node;
551         else if (xmlStrcmp(node->name, C_TAG_STEPS) == 0)
552             stepsNode = node;
553     }
554
555     // ensure that the components node is defined
556     if (componentsNode == NULL)
557     {
558         throw XAO_Exception(MsgBuilder() << "Line " << fieldNode->line << ": "
559                                          << "No components defined for field.");
560     }
561
562     // create the field
563     int nbComponents = readIntegerProp(componentsNode, C_ATTR_COUNT, true, -1);
564     Field* field = xaoObject->addField(type, dim, nbComponents);
565
566     // parse the components
567     for (xmlNodePtr compNode = componentsNode->children; compNode; compNode = compNode->next)
568     {
569         std::string compName= readStringProp(compNode, C_ATTR_COMPONENT_NAME, false, "");
570         if (compName.size() > 0)
571         {
572             int col = readIntegerProp(compNode, C_ATTR_COMPONENT_COLUMN, true, -1);
573             field->setComponentName(col, compName);
574         }
575     }
576
577     // set the name
578     std::string name = readStringProp(fieldNode, C_ATTR_FIELD_NAME, false, "");
579     if (name.size() > 0) field->setName(name);
580
581     // read the steps
582     if (stepsNode != 0)
583     {
584         for (xmlNodePtr stepNode = stepsNode->children; stepNode; stepNode = stepNode->next)
585         {
586             if (xmlStrcmp(stepNode->name, C_TAG_STEP) == 0)
587             {
588                 parseStepNode(stepNode, field);
589             }
590         }
591     }
592   }
593
594   void parseStepNode(xmlNodePtr stepNode, Field* field)
595   {
596     int stepNumber = readIntegerProp(stepNode, C_ATTR_STEP_NUMBER, true, -1);
597     Step* step = field->addNewStep(stepNumber);
598
599     int stepStamp = readIntegerProp(stepNode, C_ATTR_STEP_STAMP, false, -1);
600     if (stepStamp != -1)
601     {
602         step->setStamp(stepStamp);
603     }
604
605     for (xmlNodePtr eltNode = stepNode->children; eltNode; eltNode = eltNode->next)
606     {
607         if (xmlStrcmp(eltNode->name, C_TAG_ELEMENT) == 0)
608         {
609             parseStepElementNode(eltNode, step);
610         }
611     }
612   }
613
614   void parseStepElementNode(xmlNodePtr eltNode, Step* step)
615   {
616     int index = readIntegerProp(eltNode, C_ATTR_ELT_INDEX, true, -1);
617
618     for (xmlNodePtr valNode = eltNode->children; valNode; valNode = valNode->next)
619     {
620         if (xmlStrcmp(valNode->name, C_TAG_VALUE) == 0)
621         {
622             int component = readIntegerProp(valNode, C_ATTR_VALUE_COMPONENT, true, -1);
623             xmlChar* data = xmlNodeGetContent(valNode->children);
624
625             std::string value;
626             if (data != NULL)
627             {
628                 value = (char*)data;
629             }
630             else if (step->getType() != XAO::STRING)
631             {
632                 throw XAO_Exception(MsgBuilder() << "Line " << valNode->line << ": no content for value.");
633             }
634
635             step->setStringValue(index, component, value);
636         }
637     }
638   }
639 }
640
641 const bool XaoExporter::saveToFile(Xao* xaoObject, const std::string& fileName, const std::string& shapeFileName)
642 throw (XAO_Exception)
643 {
644     xmlDocPtr doc = exportXMLDoc(xaoObject, shapeFileName);
645     xmlSaveFormatFileEnc(fileName.c_str(), doc, "UTF-8", 1); // format = 1 for node indentation
646     xmlFreeDoc(doc);
647
648     return true;
649 }
650
651 const std::string XaoExporter::saveToXml(Xao* xaoObject)
652 throw (XAO_Exception)
653 {
654     xmlDocPtr doc = exportXMLDoc(xaoObject, "");
655
656     xmlChar *xmlbuff;
657     int buffersize;
658     xmlDocDumpFormatMemory(doc, &xmlbuff, &buffersize, 1); // format = 1 for node indentation
659     xmlFreeDoc(doc);
660     xmlCleanupGlobals();
661
662     return (char*)xmlbuff;
663 }
664
665 const bool XaoExporter::readFromFile(const std::string& fileName, Xao* xaoObject)
666 throw (XAO_Exception)
667 {
668     // parse the file and get the DOM
669     int options = XML_PARSE_HUGE | XML_PARSE_NOCDATA;
670     xmlDocPtr doc = xmlReadFile(fileName.c_str(), NULL, options);
671     if (doc == NULL)
672     {
673         throw XAO_Exception("Cannot read XAO file");
674     }
675
676     parseXMLDoc(doc, xaoObject);
677     return true;
678 }
679
680 const bool XaoExporter::setXML(const std::string& xml, Xao* xaoObject)
681 throw (XAO_Exception)
682 {
683     int options = XML_PARSE_HUGE | XML_PARSE_NOCDATA;
684     xmlDocPtr doc = xmlReadDoc(BAD_CAST xml.c_str(), "", NULL, options);
685     if (doc == NULL)
686     {
687         throw XAO_Exception("Cannot read XAO stream");
688     }
689
690     parseXMLDoc(doc, xaoObject);
691     return true;
692 }