1 // Copyright (C) 2014-2017 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or
18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
21 #include <Config_XMLReader.h>
22 #include <Config_Keywords.h>
23 #include <Config_Common.h>
24 #include <Config_PropManager.h>
25 #include <Config_ModuleReader.h>
27 #include <Events_Loop.h>
28 #include <Events_InfoMessage.h>
29 #include <libxml/parser.h>
30 #include <libxml/tree.h>
36 #pragma warning(disable : 4996) // for getenv
44 static const char FSEP = '\\';
46 static const char FSEP = '/';
49 Config_XMLReader::Config_XMLReader(const std::string& theXmlFileName)
50 : myXmlDoc(NULL), myRootFileName(theXmlFileName)
52 myDocumentPath = findConfigFile(theXmlFileName);
53 if (myDocumentPath.empty()) {
54 Events_InfoMessage("Config_XMLReader", "Unable to open %1").arg(theXmlFileName).send();
58 Config_XMLReader::~Config_XMLReader()
63 std::string Config_XMLReader::pluginConfigFile()
66 char* anEnv = getenv("SHAPER_ROOT_DIR");
68 aValue = std::string(anEnv) +
69 FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
71 anEnv = getenv("OPENPARTS_ROOT_DIR");
73 aValue = std::string(anEnv) + FSEP + "plugins";
79 std::string Config_XMLReader::findConfigFile(const std::string theFileName, const int theFindIndex)
82 for(int aSolution = 0; aSolution < 12; aSolution++) {
83 std::string aFileName;
85 Config_Prop* aProp = Config_PropManager::findProp("Plugins", "default_path");
88 aFileName = aProp->value();
90 std::ostringstream anEnvName;
92 anEnvName<<"SHAPER_ROOT_DIR";
93 else if (aSolution == 2)
94 anEnvName<<"OPENPARTS_ROOT_DIR";
96 anEnvName<<"OPENPARTS_PLUGINS_DIR";
98 char* anEnv = getenv(anEnvName.str().c_str());
101 if (aSolution > 2) { // there may be several paths separated by ";" symbol
102 std::string anEnvPart = anEnv;
103 size_t aPosStart = 0, aPosEnd;
104 for(int aSubNum = 0; aSubNum < aSolution - 3; aSubNum++) {
106 aPosStart = anEnvPart.find(';', aPosStart);
107 if (aPosStart == std::string::npos)
110 if (aPosStart == std::string::npos)
114 aPosEnd = anEnvPart.find(';', aPosStart);
115 aFileName = anEnvPart.substr(aPosStart,
116 aPosEnd == std::string::npos ? aPosEnd : aPosEnd - aPosStart) + FSEP;
118 aFileName = std::string(anEnv) + FSEP;
121 aFileName += std::string("share") + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
122 else if (aSolution == 2)
123 aFileName += "plugins";
126 aFileName += FSEP + theFileName;
127 std::ifstream aTestFile(aFileName);
129 if (aResultIndex == theFindIndex)
132 if (aSolution == 1) // don't allow SHAPER and OpenParts paths treated simultaneously
136 return ""; // no files found
139 void Config_XMLReader::readAll()
141 // to load external modules dependencies (like GEOM for Connector Feature)
142 Config_ModuleReader::loadScript("salome.shaper.initConfig", false);
144 for(int aSolution = 0; true; aSolution++) {
145 std::string aFoundFile = findConfigFile(myRootFileName, aSolution);
146 if (aFoundFile.empty()) {
147 break; // no more solutions
150 if (myXmlDoc != NULL) { // clear the previous XML document - now the new one will be opened
151 xmlFreeDoc(myXmlDoc);
154 xmlNodePtr aRoot = findRoot(aFoundFile);
155 readRecursively(aRoot);
159 void Config_XMLReader::processNode(xmlNodePtr theNode)
161 if (isNode(theNode, NODE_SOURCE, NULL)) {
162 std::string aSourceFile = getProperty(theNode, SOURCE_FILE);
163 Config_XMLReader aSourceReader = Config_XMLReader(aSourceFile);
164 readRecursively(aSourceReader.findRoot());
166 //std::cout << "Config_XMLReader::sourced node: " << aSourceFile << std::endl;
171 void Config_XMLReader::cleanup(xmlNodePtr)
176 bool Config_XMLReader::processChildren(xmlNodePtr aNode)
181 xmlNodePtr Config_XMLReader::findRoot(const std::string theDocumentPath)
183 std::string aDocPath = theDocumentPath.empty() ? myDocumentPath : theDocumentPath;
184 if (myXmlDoc == NULL) {
185 myXmlDoc = xmlParseFile(aDocPath.c_str());
187 if (myXmlDoc == NULL) {
189 std::cout << "Config_XMLReader::import: " << "Document " << aDocPath
190 << " is not parsed successfully." << std::endl;
194 xmlNodePtr aRoot = xmlDocGetRootElement(myXmlDoc);
197 std::cout << "Config_XMLReader::import: " << "Error: empty document";
203 void Config_XMLReader::readRecursively(xmlNodePtr theParent)
207 xmlNodePtr aNode = theParent->xmlChildrenNode;
208 for (; aNode; aNode = aNode->next) {
209 //Still no text processing in features...
210 if (!isElementNode(aNode)) {
214 if (processChildren(aNode)) {
215 readRecursively(aNode);
221 xmlNodePtr Config_XMLReader::node(void* theNode)
223 return static_cast<xmlNodePtr>(theNode);
226 std::string Config_XMLReader::getNodeName(xmlNodePtr theNode)
228 std::string result = "";
229 char* aPropChars = (char*) theNode->name;
230 if (!aPropChars || aPropChars[0] == 0)
232 result = std::string(aPropChars);
236 void Config_XMLReader::storeAttribute(xmlNodePtr theNode, const char* theAttribute, bool doClean)
238 std::string aKey = getNodeName(theNode) + ":" + std::string(theAttribute);
239 std::string aValue = getProperty(theNode, theAttribute);
240 if (doClean || !aValue.empty()) {
241 myCachedAttributes[aKey] = aValue;
245 std::string Config_XMLReader::restoreAttribute(xmlNodePtr theNode, const char* theAttribute)
247 return restoreAttribute(getNodeName(theNode).c_str(), theAttribute);
250 std::string Config_XMLReader::restoreAttribute(const char* theNodeName, const char* theAttribute)
252 std::string aKey = std::string(theNodeName) + ":" + std::string(theAttribute);
253 std::string result = "";
254 if(myCachedAttributes.find(aKey) != myCachedAttributes.end()) {
255 result = myCachedAttributes[aKey];
260 bool Config_XMLReader::cleanupAttribute(xmlNodePtr theNode, const char* theNodeAttribute)
262 return cleanupAttribute(getNodeName(theNode).c_str(), theNodeAttribute);
265 bool Config_XMLReader::cleanupAttribute(const char* theNodeName, const char* theNodeAttribute)
267 std::string aKey = std::string(theNodeName) + ":" + std::string(theNodeAttribute);
269 std::map<std::string, std::string>::iterator anEntry = myCachedAttributes.find(aKey);
270 if( anEntry != myCachedAttributes.end()) {
271 myCachedAttributes.erase(anEntry);
277 const char* Config_XMLReader::encoding() const
279 return (const char*) myXmlDoc->encoding;