]> SALOME platform Git repositories - modules/shaper.git/blob - src/Config/Config_Common.cpp
Salome HOME
[bos #36169] EDF 25230 - Conversion xyz => uv => xyz. Replace all calls of ShapeAnaly...
[modules/shaper.git] / src / Config / Config_Common.cpp
1 // Copyright (C) 2014-2023  CEA, EDF
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 "Config_Common.h"
21 #include <Config_Keywords.h>
22
23 #include <libxml/parser.h>
24 #include <libxml/tree.h>
25
26 #include <sstream> // for stringstream
27
28 #include <string>
29 #include <algorithm> // for std::transform
30 #include <vector>
31
32 bool isElementNode(xmlNodePtr theNode)
33 {
34   if (!theNode)
35     return false;
36   return theNode->type == XML_ELEMENT_NODE;
37 }
38
39 bool isNode(xmlNodePtr theNode, const char* theNodeName, ...)
40 {
41   const xmlChar* aName = theNode->name;
42   if (!aName || !isElementNode(theNode)) {
43     return false;
44   }
45   if (!xmlStrcmp(aName, (const xmlChar *) theNodeName)) {
46     return true;
47   }
48   va_list args;  // define argument list variable
49   va_start(args, theNodeName);  // init list; point to last defined argument
50   while (true) {
51     char *anArg = va_arg (args, char*);  // get next argument
52     if (anArg == NULL)
53       break;
54     if (!xmlStrcmp(aName, (const xmlChar *) anArg)) {
55       va_end(args);  // cleanup the system stack
56       return true;
57     }
58   }
59   va_end(args);  // cleanup the system stack
60   return false;
61 }
62
63 bool isAttributeNode(xmlNodePtr theNode)
64 {
65   if(!isElementNode(theNode))
66     return false;
67   // it's parent is "feature" or "source" or page ("case" or "box")
68   if(!hasParent(theNode, NODE_FEATURE, NODE_SOURCE,
69                          WDG_GROUP, WDG_OPTIONALBOX,
70                          WDG_TOOLBOX_BOX, WDG_RADIOBOX_ITEM,
71                          WDG_SWITCH_CASE, NULL))
72     return false;
73
74   //it should not be a "source" or a "validator" node
75   bool isLogical = isNode(theNode, NODE_SOURCE, NODE_VALIDATOR, NULL);
76   // here must be only widgets not connected to attributes
77   bool isPagedContainer = isNode(theNode, WDG_TOOLBOX_BOX,
78                                           WDG_GROUP,
79                                           WDG_SWITCH_CASE,  NULL);
80   return !isLogical && !isPagedContainer;
81 }
82
83 bool isWidgetNode(xmlNodePtr theNode)
84 {
85   if(!isElementNode(theNode))
86     return false;
87   // it's parent is "feature" or "source" or a page ("box", "case")
88   if(!hasParent(theNode, NODE_FEATURE, NODE_SOURCE, WDG_GROUP, WDG_OPTIONALBOX,
89     WDG_TOOLBOX_BOX, WDG_RADIOBOX_ITEM, WDG_SWITCH_CASE, WDG_FILTER, NULL))
90     return false;
91
92   //it should not be a "source" or a "validator" node
93   return !isNode(theNode, NODE_SOURCE, NODE_VALIDATOR, NULL);
94 }
95
96 // LCOV_EXCL_START
97 // widget api?
98 bool isCaseNode(xmlNodePtr theNode)
99 {
100   if(!isElementNode(theNode))
101     return false;
102
103   return isNode(theNode, WDG_OPTIONALBOX, WDG_SWITCH_CASE, WDG_TOOLBOX_BOX,
104     WDG_RADIOBOX_ITEM, NULL);
105 }
106 // LCOV_EXCL_STOP
107
108 bool hasChild(xmlNodePtr theNode)
109 {
110   xmlNodePtr aNode = theNode->children;
111   for (; aNode; aNode = aNode->next) {
112     if (isElementNode(theNode)) {
113       return true;
114     }
115   }
116   return false;
117 }
118
119 bool hasParent(xmlNodePtr theNode)
120 {
121   xmlNodePtr aNode = theNode->parent;
122   if (!aNode) {
123     return false;
124   }
125   for (; aNode; aNode = aNode->next) {
126     if (isElementNode(theNode)) {
127       return true;
128     }
129   }
130   return false;
131 }
132
133 bool hasParent(xmlNodePtr theNode, const char* theNodeName, ...)
134 {
135   if (!hasParent(theNode)) {
136     return false; // have no parents at all
137   }
138   xmlNodePtr aNode = theNode->parent;
139   const xmlChar* aName = aNode->name;
140   if (!aName || !isElementNode(aNode)) {
141     return false;
142   }
143   if (!xmlStrcmp(aName, (const xmlChar *) theNodeName)) {
144     return true;
145   }
146   va_list args;  // define argument list variable
147   va_start(args, theNodeName);  // init list; point to last defined argument
148   while (true) {
149     char *anArg = va_arg (args, char*);  // get next argument
150     if (anArg == NULL)
151       break;
152     if (!xmlStrcmp(aName, (const xmlChar *) anArg)) {
153       va_end(args);  // cleanup the system stack
154       return true;
155     }
156   }
157   va_end(args);  // cleanup the system stack
158   return false;
159 }
160
161 xmlNodePtr hasParentRecursive(xmlNodePtr theNode, const std::vector<const char*>& theNodeNames)
162 {
163   if (!hasParent(theNode)) {
164     return 0; // have no parents at all
165   }
166   xmlNodePtr aNode = theNode->parent;
167   const xmlChar* aName = aNode->name;
168   if (!aName || !isElementNode(aNode)) {
169     return 0;
170   }
171   for (size_t anIndex = 0; anIndex < theNodeNames.size(); ++anIndex) {
172     if (!xmlStrcmp(aName, (const xmlChar *) theNodeNames[anIndex]))
173       return aNode;
174   }
175   return hasParentRecursive(aNode, theNodeNames);
176 }
177
178 xmlNodePtr hasParentRecursive(xmlNodePtr theNode, const char* theNodeName, ...)
179 {
180   std::vector<const char*> aNodeNames;
181   va_list args;  // define argument list variable
182   va_start(args, theNodeName);  // init list; point to last defined argument
183   aNodeNames.push_back(theNodeName);
184   while (true) {
185     char *anArg = va_arg (args, char*);  // get next argument
186     if (anArg == NULL)
187       break;
188     aNodeNames.push_back(anArg);
189   }
190   va_end(args);  // cleanup the system stack
191   return hasParentRecursive(theNode, aNodeNames);
192 }
193
194 bool getParametersInfo(xmlNodePtr theNode, std::string& outPropertyId,
195                       std::list<std::string>& outValidatorParameters)
196 {
197   //Property id:
198   char* anIdProp = (char*) xmlGetProp(theNode, BAD_CAST _ID);
199   if (!anIdProp || anIdProp[0] == 0) {
200     return false;
201   }
202   outPropertyId = std::string(anIdProp);
203
204   //Property parameters:
205   char* aParamProp = (char*) xmlGetProp(theNode, BAD_CAST _PARAMETERS);
206   if (aParamProp && aParamProp[0] != 0) {
207     std::string aPropString = std::string(aParamProp);
208     std::stringstream aPropStringStream(aPropString);
209     char COMMA_DELIM = ',';
210     std::string aParameter;
211     while (std::getline(aPropStringStream, aParameter, COMMA_DELIM)) {
212       outValidatorParameters.push_back(aParameter);
213     }
214   }
215   return true;
216 }
217
218 std::string library(const std::string& theLibName)
219 {
220   if(theLibName.empty())
221     return std::string();
222   std::string aLibName = theLibName;
223 #ifndef WIN32
224   static std::string aLibExt( ".so" );
225   if (aLibName.size() < 3 || aLibName.substr(0, 3) !="lib") {
226     aLibName = "lib" + aLibName;
227   }
228 #else
229   static std::string aLibExt(".dll");
230 #endif
231   std::string anExt = aLibName.substr(aLibName.size() - 4);
232   if (anExt != aLibExt)
233     aLibName += aLibExt;
234
235   return aLibName;
236 }
237
238 bool BothAreSpaces(char lhs, char rhs) { return (lhs == rhs) && (lhs == ' '); }
239
240 std::string getProperty(xmlNodePtr theNode, const char* thePropName)
241 {
242   std::string result = "";
243   xmlChar* aPropChars = xmlGetProp(theNode, BAD_CAST thePropName);
244   if (!aPropChars || aPropChars[0] == 0)
245     return result;
246   result = std::string((char*)aPropChars);
247   xmlFree(aPropChars);
248
249   std::string::iterator new_end = std::unique(result.begin(), result.end(), BothAreSpaces);
250   result.erase(new_end, result.end());
251
252   return result;
253 }
254
255 // LCOV_EXCL_START
256 std::string getContent(xmlNodePtr theNode)
257 {
258   std::string result = "";
259   xmlChar* aContent = xmlNodeGetContent(theNode);
260   if (!aContent || aContent[0] == 0)
261     return result;
262   result = std::string((char*)aContent);
263   xmlFree(aContent);
264   return result;
265 }
266 // LCOV_EXCL_STOP
267
268 std::string getNormalizedProperty(xmlNodePtr theNode, const char* thePropName)
269 {
270   return normalize(getProperty(theNode, thePropName));
271 }
272
273 bool getBooleanAttribute(xmlNodePtr theNode, const char* theAttributeName, bool theDefault)
274 {
275   std::string prop = normalize(getProperty(theNode, theAttributeName));
276   bool result = theDefault;
277   if (prop == "true" || prop == "1") {
278     result = true;
279   } else if (prop == "false" || prop == "0") {
280     result = false;
281   }
282   return result;
283 }
284
285 CONFIG_EXPORT std::string normalize(const std::string& theString)
286 {
287   std::string result = theString;
288   std::transform(result.begin(), result.end(), result.begin(),
289                  [](char c) { return static_cast<char>(::tolower(c)); });
290   return result;
291 }