src/Config/Config_XMLReader.cpp

   1 // Copyright (C) 2014-2017  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
  18 // email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
  19 //
  20
  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>
  26
  27 #include <Events_Loop.h>
  28 #include <Events_InfoMessage.h>
  29 #include <libxml/parser.h>
  30 #include <libxml/tree.h>
  31
  32 #include <fstream>
  33 #include <sstream>
  34
  35 #ifdef WIN32
  36 #pragma warning(disable : 4996) // for getenv
  37 #endif
  38
  39 #ifdef _DEBUG
  40 #include <iostream>
  41 #endif
  42
  43 #ifdef WIN32
  44     static const char FSEP = '\\';
  45 #else
  46     static const char FSEP = '/';
  47 #endif
  48
  49 Config_XMLReader::Config_XMLReader(const std::string& theXmlFileName)
  50     : myXmlDoc(NULL), myRootFileName(theXmlFileName)
  51 {
  52   myDocumentPath = findConfigFile(theXmlFileName);
  53   if (myDocumentPath.empty()) {
  54     Events_InfoMessage("Config_XMLReader", "Unable to open %1").arg(theXmlFileName).send();
  55   }
  56 }
  57
  58 Config_XMLReader::~Config_XMLReader()
  59 {
  60   xmlFreeDoc(myXmlDoc);
  61 }
  62
  63 std::string Config_XMLReader::resourcesConfigFile()
  64 {
  65   std::string aValue;
  66   char* anEnv = getenv("SHAPER_ROOT_DIR");
  67   if (anEnv) {
  68     aValue = std::string(anEnv) +
  69       FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
  70   } else {
  71     anEnv = getenv("OPENPARTS_ROOT_DIR");
  72     if (anEnv) {
  73       aValue = std::string(anEnv) + FSEP + "resources";
  74     }
  75   }
  76   return aValue;
  77 }
  78
  79 std::string Config_XMLReader::pluginConfigFile()
  80 {
  81   std::string aValue;
  82   char* anEnv = getenv("SHAPER_ROOT_DIR");
  83   if (anEnv) {
  84     aValue = std::string(anEnv) +
  85       FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
  86   } else {
  87     anEnv = getenv("OPENPARTS_ROOT_DIR");
  88     if (anEnv) {
  89       aValue = std::string(anEnv) + FSEP + "plugins";
  90     }
  91   }
  92   return aValue;
  93 }
  94
  95 std::string Config_XMLReader::findConfigFile(const std::string theFileName, const int theFindIndex)
  96 {
  97   int aResultIndex = 0;
  98   for(int aSolution = 0; aSolution < 12; aSolution++) {
  99     std::string aFileName;
 100     if (aSolution == 0) {
 101       Config_Prop* aProp = Config_PropManager::findProp("Plugins", "default_path");
 102       if (!aProp)
 103         continue;
 104       aFileName = aProp->value();
 105     } else {
 106       std::ostringstream anEnvName;
 107       if (aSolution == 1)
 108         anEnvName<<"SHAPER_ROOT_DIR";
 109       else if (aSolution == 2)
 110         anEnvName<<"OPENPARTS_ROOT_DIR";
 111       else
 112         anEnvName<<"OPENPARTS_PLUGINS_DIR";
 113
 114       char* anEnv = getenv(anEnvName.str().c_str());
 115       if (!anEnv)
 116         continue;
 117       if (aSolution > 2) { // there may be several paths separated by ";" symbol
 118         std::string anEnvPart = anEnv;
 119         size_t aPosStart = 0, aPosEnd;
 120         for(int aSubNum = 0; aSubNum < aSolution - 3; aSubNum++) {
 121           aPosStart++;
 122           aPosStart = anEnvPart.find(';', aPosStart);
 123           if (aPosStart == std::string::npos)
 124             break;
 125         }
 126         if (aPosStart == std::string::npos)
 127           break;
 128         if (aPosStart != 0)
 129           aPosStart++;
 130         aPosEnd = anEnvPart.find(';', aPosStart);
 131         aFileName = anEnvPart.substr(aPosStart,
 132           aPosEnd == std::string::npos ? aPosEnd : aPosEnd - aPosStart) + FSEP;
 133       } else {
 134         aFileName = std::string(anEnv) + FSEP;
 135       }
 136       if (aSolution == 1)
 137         aFileName += std::string("share") + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper";
 138       else if (aSolution == 2)
 139         aFileName += "plugins";
 140     }
 141
 142     aFileName += FSEP + theFileName;
 143     std::ifstream aTestFile(aFileName);
 144     if (aTestFile) {
 145       if (aResultIndex == theFindIndex)
 146         return aFileName;
 147       aResultIndex++;
 148       if (aSolution == 1) // don't allow SHAPER and OpenParts paths treated simultaneously
 149         aSolution++;
 150     }
 151   }
 152   return ""; // no files found
 153 }
 154
 155 void Config_XMLReader::readAll()
 156 {
 157   // to load external modules dependencies (like GEOM for Connector Feature)
 158   Config_ModuleReader::loadScript("salome.shaper.initConfig", false);
 159
 160   for(int aSolution = 0; true; aSolution++) {
 161     std::string aFoundFile = findConfigFile(myRootFileName, aSolution);
 162     if (aFoundFile.empty()) {
 163       break; // no more solutions
 164     }
 165
 166     if (myXmlDoc != NULL) { // clear the previous XML document - now the new one will be opened
 167       xmlFreeDoc(myXmlDoc);
 168       myXmlDoc = NULL;
 169     }
 170     xmlNodePtr aRoot = findRoot(aFoundFile);
 171     readRecursively(aRoot);
 172   }
 173 }
 174
 175 void Config_XMLReader::processNode(xmlNodePtr theNode)
 176 {
 177   if (isNode(theNode, NODE_SOURCE, NULL)) {
 178     std::string aSourceFile = getProperty(theNode, SOURCE_FILE);
 179     Config_XMLReader aSourceReader = Config_XMLReader(aSourceFile);
 180     readRecursively(aSourceReader.findRoot());
 181 #ifdef _DEBUG
 182     //std::cout << "Config_XMLReader::sourced node: " << aSourceFile << std::endl;
 183 #endif
 184   }
 185 }
 186
 187 void Config_XMLReader::cleanup(xmlNodePtr)
 188 {
 189   // do nothing;
 190 }
 191
 192 bool Config_XMLReader::processChildren(xmlNodePtr aNode)
 193 {
 194   return true;
 195 }
 196
 197 xmlNodePtr Config_XMLReader::findRoot(const std::string theDocumentPath)
 198 {
 199   std::string aDocPath = theDocumentPath.empty() ? myDocumentPath : theDocumentPath;
 200   if (myXmlDoc == NULL) {
 201     myXmlDoc = xmlParseFile(aDocPath.c_str());
 202   }
 203   if (myXmlDoc == NULL) {
 204 #ifdef _DEBUG
 205     std::cout << "Config_XMLReader::import: " << "Document " << aDocPath
 206     << " is not parsed successfully." << std::endl;
 207 #endif
 208     return NULL;
 209   }
 210   xmlNodePtr aRoot = xmlDocGetRootElement(myXmlDoc);
 211 #ifdef _DEBUG
 212   if(aRoot == NULL) {
 213     std::cout << "Config_XMLReader::import: " << "Error: empty document";
 214   }
 215 #endif
 216   return aRoot;
 217 }
 218
 219 void Config_XMLReader::readRecursively(xmlNodePtr theParent)
 220 {
 221   if (!theParent)
 222     return;
 223   xmlNodePtr aNode = theParent->xmlChildrenNode;
 224   for (; aNode; aNode = aNode->next) {
 225     //Still no text processing in features...
 226     if (!isElementNode(aNode)) {
 227       continue;
 228     }
 229     processNode(aNode);
 230     if (processChildren(aNode)) {
 231       readRecursively(aNode);
 232     }
 233     cleanup(aNode);
 234   }
 235 }
 236
 237 xmlNodePtr Config_XMLReader::node(void* theNode)
 238 {
 239   return static_cast<xmlNodePtr>(theNode);
 240 }
 241
 242 std::string Config_XMLReader::getNodeName(xmlNodePtr theNode)
 243 {
 244   std::string result = "";
 245   char* aPropChars = (char*) theNode->name;
 246   if (!aPropChars || aPropChars[0] == 0)
 247     return result;
 248   result = std::string(aPropChars);
 249   return result;
 250 }
 251
 252 void Config_XMLReader::storeAttribute(xmlNodePtr theNode, const char* theAttribute, bool doClean)
 253 {
 254   std::string aKey = getNodeName(theNode) + ":" + std::string(theAttribute);
 255   std::string aValue = getProperty(theNode, theAttribute);
 256   if (doClean || !aValue.empty()) {
 257     myCachedAttributes[aKey] = aValue;
 258   }
 259 }
 260
 261 std::string Config_XMLReader::restoreAttribute(xmlNodePtr theNode, const char* theAttribute)
 262 {
 263   return restoreAttribute(getNodeName(theNode).c_str(), theAttribute);
 264 }
 265
 266 std::string Config_XMLReader::restoreAttribute(const char* theNodeName, const char* theAttribute)
 267 {
 268   std::string aKey = std::string(theNodeName) + ":" + std::string(theAttribute);
 269   std::string result = "";
 270   if(myCachedAttributes.find(aKey) != myCachedAttributes.end()) {
 271     result = myCachedAttributes[aKey];
 272   }
 273   return result;
 274 }
 275
 276 bool Config_XMLReader::cleanupAttribute(xmlNodePtr theNode, const char* theNodeAttribute)
 277 {
 278   return cleanupAttribute(getNodeName(theNode).c_str(), theNodeAttribute);
 279 }
 280
 281 bool Config_XMLReader::cleanupAttribute(const char* theNodeName, const char* theNodeAttribute)
 282 {
 283   std::string aKey = std::string(theNodeName) + ":" + std::string(theNodeAttribute);
 284   bool result = false;
 285   std::map<std::string, std::string>::iterator anEntry = myCachedAttributes.find(aKey);
 286   if( anEntry != myCachedAttributes.end()) {
 287     myCachedAttributes.erase(anEntry);
 288     result = true;
 289   }
 290   return result;
 291 }
 292
 293 const char* Config_XMLReader::encoding() const
 294 {
 295   return (const char*) myXmlDoc->encoding;
 296 }