X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FConfig%2FConfig_XMLReader.cpp;h=a9c56d7de1acb8c18b163c42197791899702ffbc;hb=06e7f5859095193fc7f498bd89a7d28009794f53;hp=81c5d37258f41e8828e9623b0bbe96e0d1ab1911;hpb=63e954c524a2bf8ef9ee3098f6ee2eb14a9966dd;p=modules%2Fshaper.git diff --git a/src/Config/Config_XMLReader.cpp b/src/Config/Config_XMLReader.cpp index 81c5d3725..a9c56d7de 100644 --- a/src/Config/Config_XMLReader.cpp +++ b/src/Config/Config_XMLReader.cpp @@ -1,19 +1,36 @@ -/* - * Config_XMLReader.cpp - * - * Created on: Mar 14, 2014 - * Author: sbh - */ +// Copyright (C) 2014-2023 CEA, EDF +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include #include #include -#include +#include +#include #include +#include #include #include +#include +#include + #ifdef WIN32 #pragma warning(disable : 4996) // for getenv #endif @@ -22,45 +39,152 @@ #include #endif -Config_XMLReader::Config_XMLReader(const std::string& theXmlFileName) - : myXmlDoc(NULL) +#ifdef WIN32 + static const char FSEP = '\\'; +#else + static const char FSEP = '/'; +#endif + +Config_XMLReader::Config_XMLReader(const std::string& theXmlFileName, bool isXMLContent) + : myXmlDoc(NULL), myRootFileName(theXmlFileName) { - std::string prefix = ""; - /* - * Get path to *.xml files (typically ./bin/../plugins/) + isFromMemory = isXMLContent; + if (!isXMLContent) { + myDocumentPath = findConfigFile(theXmlFileName); + if (myDocumentPath.empty()) { + Events_InfoMessage("Config_XMLReader", "Unable to open %1").arg(theXmlFileName).send(); + } + } +} - * the problem: application may be launched using python executable, - * to use environment variable (at least for the current moment) - */ - char* anEnv = getenv("NEW_GEOM_CONFIG_FILE"); +Config_XMLReader::~Config_XMLReader() +{ + xmlFreeDoc(myXmlDoc); +} + +// LCOV_EXCL_START +std::string Config_XMLReader::resourcesConfigFile() +{ + std::string aValue; + char* anEnv = getenv("SHAPER_ROOT_DIR"); if (anEnv) { - prefix = std::string(anEnv) + "/"; + aValue = std::string(anEnv) + + FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper"; + } else { + anEnv = getenv("CADBUILDER_ROOT_DIR"); + if (anEnv) { + aValue = std::string(anEnv) + FSEP + "resources"; + } } + return aValue; +} - myDocumentPath = prefix + theXmlFileName; +std::string Config_XMLReader::pluginConfigFile() +{ + std::string aValue; + char* anEnv = getenv("SHAPER_ROOT_DIR"); + if (anEnv) { + aValue = std::string(anEnv) + + FSEP + "share" + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper"; + } else { + anEnv = getenv("CADBUILDER_ROOT_DIR"); + if (anEnv) { + aValue = std::string(anEnv) + FSEP + "plugins"; + } + } + return aValue; } +// LCOV_EXCL_STOP -Config_XMLReader::~Config_XMLReader() +std::string Config_XMLReader::findConfigFile(const std::string theFileName, const int theFindIndex) { - xmlFreeDoc(myXmlDoc); + int aResultIndex = 0; + for(int aSolution = 0; aSolution < 12; aSolution++) { + std::string aFileName; + if (aSolution == 0) { + Config_Prop* aProp = Config_PropManager::findProp("Plugins", "default_path"); + if (!aProp) + continue; + aFileName = aProp->value(); + } else { + std::ostringstream anEnvName; + if (aSolution == 1) + anEnvName<<"SHAPER_ROOT_DIR"; + else if (aSolution == 2) + anEnvName<<"CADBUILDER_ROOT_DIR"; + else + anEnvName<<"CADBUILDER_ROOT_DIR"; + + char* anEnv = getenv(anEnvName.str().c_str()); + if (!anEnv) + continue; + if (aSolution > 2) { // there may be several paths separated by ";" symbol +// LCOV_EXCL_START + std::string anEnvPart = anEnv; + size_t aPosStart = 0, aPosEnd; + for(int aSubNum = 0; aSubNum < aSolution - 3; aSubNum++) { + aPosStart++; + aPosStart = anEnvPart.find(';', aPosStart); + if (aPosStart == std::string::npos) + break; + } + if (aPosStart == std::string::npos) + break; + if (aPosStart != 0) + aPosStart++; + aPosEnd = anEnvPart.find(';', aPosStart); + aFileName = anEnvPart.substr(aPosStart, + aPosEnd == std::string::npos ? aPosEnd : aPosEnd - aPosStart) + FSEP; +// LCOV_EXCL_STOP + } else { + aFileName = std::string(anEnv) + FSEP; + } + if (aSolution == 1) + aFileName += std::string("share") + FSEP + "salome" + FSEP + "resources" + FSEP + "shaper"; + else if (aSolution == 2) + aFileName += "plugins"; + } + + aFileName += FSEP + theFileName; + std::ifstream aTestFile(aFileName); + if (aTestFile) { + if (aResultIndex == theFindIndex) + return aFileName; + aResultIndex++; + if (aSolution == 1) // don't allow SHAPER and CADBuilder paths treated simultaneously + aSolution++; + } + } + return ""; // no files found } -/* - * Read all nodes in associated xml file, - * recursively if processChildren(xmlNode) is true for the xmlNode. - * For each read node the processNode will be called. - */ void Config_XMLReader::readAll() { - xmlNodePtr aRoot = findRoot(); - readRecursively(aRoot); + if (isFromMemory) { + myXmlDoc = xmlParseMemory(myRootFileName.c_str(), (int)myRootFileName.length()); + xmlNodePtr aRoot = xmlDocGetRootElement(myXmlDoc); + readRecursively(aRoot); + return; + } + + // to load external modules dependencies (like GEOM for Connector Feature) + Config_ModuleReader::loadScript("salome.shaper.initConfig", false); + + for(int aSolution = 0; true; aSolution++) { + std::string aFoundFile = findConfigFile(myRootFileName, aSolution); + if (aFoundFile.empty()) { + break; // no more solutions + } + + if (myXmlDoc != NULL) { // clear the previous XML document - now the new one will be opened + xmlFreeDoc(myXmlDoc); + myXmlDoc = NULL; + } + xmlNodePtr aRoot = findRoot(aFoundFile); + readRecursively(aRoot); + } } -/* - * Allows to customize reader's behavior for a node. Virtual. - * The default impl does nothing. (In debug mode prints - * some info) - */ void Config_XMLReader::processNode(xmlNodePtr theNode) { if (isNode(theNode, NODE_SOURCE, NULL)) { @@ -68,33 +192,32 @@ void Config_XMLReader::processNode(xmlNodePtr theNode) Config_XMLReader aSourceReader = Config_XMLReader(aSourceFile); readRecursively(aSourceReader.findRoot()); #ifdef _DEBUG - std::cout << "Config_XMLReader::sourced node: " << aSourceFile << std::endl; + //std::cout << "Config_XMLReader::sourced node: " << aSourceFile << std::endl; #endif - } else if (isNode(theNode, NODE_VALIDATOR, NULL)) { - processValidator(theNode); } } -/* - * Defines which nodes should be processed recursively. Virtual. - * The default impl is to read all nodes. - */ -bool Config_XMLReader::processChildren(xmlNodePtr aNode) +void Config_XMLReader::cleanup(xmlNodePtr) +{ + // do nothing; +} + +// LCOV_EXCL_START +bool Config_XMLReader::processChildren(xmlNodePtr /*aNode*/) { return true; } +// LCOV_EXCL_STOP -/* - * - */ -xmlNodePtr Config_XMLReader::findRoot() +xmlNodePtr Config_XMLReader::findRoot(const std::string theDocumentPath) { + std::string aDocPath = theDocumentPath.empty() ? myDocumentPath : theDocumentPath; if (myXmlDoc == NULL) { - myXmlDoc = xmlParseFile(myDocumentPath.c_str()); + myXmlDoc = xmlParseFile(aDocPath.c_str()); } if (myXmlDoc == NULL) { #ifdef _DEBUG - std::cout << "Config_XMLReader::import: " << "Document " << myDocumentPath + std::cout << "Config_XMLReader::import: " << "Document " << aDocPath << " is not parsed successfully." << std::endl; #endif return NULL; @@ -108,11 +231,6 @@ xmlNodePtr Config_XMLReader::findRoot() return aRoot; } -/* - * Calls processNode() for each child (for some - recursively) - * of the given node. - * \sa ReadAll() - */ void Config_XMLReader::readRecursively(xmlNodePtr theParent) { if (!theParent) @@ -127,16 +245,16 @@ void Config_XMLReader::readRecursively(xmlNodePtr theParent) if (processChildren(aNode)) { readRecursively(aNode); } + cleanup(aNode); } } -/* - * void* -> xmlNodePtr - */ +// LCOV_EXCL_START xmlNodePtr Config_XMLReader::node(void* theNode) { return static_cast(theNode); } +// LCOV_EXCL_STOP std::string Config_XMLReader::getNodeName(xmlNodePtr theNode) { @@ -148,36 +266,52 @@ std::string Config_XMLReader::getNodeName(xmlNodePtr theNode) return result; } -/* - * Returns named property for a given node as std::string. - */ -std::string Config_XMLReader::getProperty(xmlNodePtr theNode, const char* theName) +void Config_XMLReader::storeAttribute(xmlNodePtr theNode, const char* theAttribute, bool doClean) { + std::string aKey = getNodeName(theNode) + ":" + std::string(theAttribute); + std::string aValue = getProperty(theNode, theAttribute); + if (doClean || !aValue.empty()) { + myCachedAttributes[aKey] = aValue; + } +} + +// LCOV_EXCL_START +std::string Config_XMLReader::restoreAttribute(xmlNodePtr theNode, const char* theAttribute) +{ + return restoreAttribute(getNodeName(theNode).c_str(), theAttribute); +} +// LCOV_EXCL_STOP + +std::string Config_XMLReader::restoreAttribute(const char* theNodeName, const char* theAttribute) +{ + std::string aKey = std::string(theNodeName) + ":" + std::string(theAttribute); std::string result = ""; - char* aPropChars = (char*) xmlGetProp(theNode, BAD_CAST theName); - if (!aPropChars || aPropChars[0] == 0) - return result; - result = std::string(aPropChars); + if(myCachedAttributes.find(aKey) != myCachedAttributes.end()) { + result = myCachedAttributes[aKey]; + } return result; } -void Config_XMLReader::processValidator(xmlNodePtr theNode) -{ - Events_ID aValidatoEvent = Events_Loop::eventByName(EVENT_VALIDATOR_LOADED); - Events_Loop* aEvLoop = Events_Loop::loop(); - boost::shared_ptr - aMessage(new Config_ValidatorMessage(aValidatoEvent, this)); - std::string aValidatorId; - std::list aValidatorParameters; - getValidatorInfo(theNode, aValidatorId, aValidatorParameters); - aMessage->setValidatorId(aValidatorId); - aMessage->setValidatorParameters(aValidatorParameters); - xmlNodePtr aFeatureOrWdgNode = theNode->parent; - if (isNode(aFeatureOrWdgNode, NODE_FEATURE, NULL)) { - aMessage->setFeatureId(getProperty(aFeatureOrWdgNode, _ID)); - } else { - aMessage->setAttributeId(getProperty(aFeatureOrWdgNode, _ID)); - aMessage->setFeatureId(myCurrentFeature); +bool Config_XMLReader::cleanupAttribute(xmlNodePtr theNode, const char* theNodeAttribute) +{ + return cleanupAttribute(getNodeName(theNode).c_str(), theNodeAttribute); +} + +bool Config_XMLReader::cleanupAttribute(const char* theNodeName, const char* theNodeAttribute) +{ + std::string aKey = std::string(theNodeName) + ":" + std::string(theNodeAttribute); + bool result = false; + std::map::iterator anEntry = myCachedAttributes.find(aKey); + if( anEntry != myCachedAttributes.end()) { + myCachedAttributes.erase(anEntry); + result = true; } - aEvLoop->send(aMessage); + return result; +} + +// LCOV_EXCL_START +const char* Config_XMLReader::encoding() const +{ + return (const char*) myXmlDoc->encoding; } +// LCOV_EXCL_STOP