X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FConfig%2FConfig_XMLReader.cpp;h=1dab4ac3d46667278c11936eeba332ec55bb1b57;hb=28f4045c9be1df4b9fb76b5b01f32f4c78293dfe;hp=0261f2551600b54fd7dec93cd03f81247c6763f6;hpb=420c997daf80ad43abc8cc65fb19b282169525c3;p=modules%2Fshaper.git diff --git a/src/Config/Config_XMLReader.cpp b/src/Config/Config_XMLReader.cpp index 0261f2551..1dab4ac3d 100644 --- a/src/Config/Config_XMLReader.cpp +++ b/src/Config/Config_XMLReader.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D + /* * Config_XMLReader.cpp * @@ -6,38 +8,52 @@ */ #include +#include +#include +#include -#include -#include -#include +#include +#include +#include +#include + +#include -/* #ifdef WIN32 -//For GetModuleFileNameW -#include +#pragma warning(disable : 4996) // for getenv #endif -*/ #ifdef _DEBUG #include #endif +#ifdef WIN32 + static const char FSEP = '\\'; +#else + static const char FSEP = '/'; +#endif + Config_XMLReader::Config_XMLReader(const std::string& theXmlFileName) : myXmlDoc(NULL) { - std::string prefix = ""; + std::string prefix = ""; + Config_Prop* aProp = Config_PropManager::findProp("Plugins", "default_path"); + if (aProp) + prefix = aProp->value(); /* * Get path to *.xml files (typically ./bin/../plugins/) * 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"); - if (anEnv) { - prefix = std::string(anEnv) + "/"; - } - - myDocumentPath = prefix + theXmlFileName; + if (prefix.empty()) + prefix = pluginConfigFile(); + + myDocumentPath = prefix + FSEP + theXmlFileName; + std::ifstream aTestFile(myDocumentPath); + if (!aTestFile) + Events_InfoMessage("Config_XMLReader", "Unable to open %1").arg(myDocumentPath).send(); + aTestFile.close(); } Config_XMLReader::~Config_XMLReader() @@ -45,46 +61,55 @@ Config_XMLReader::~Config_XMLReader() xmlFreeDoc(myXmlDoc); } -/* - * 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. - */ +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("OPENPARTS_ROOT_DIR"); + if (anEnv) { + aValue = std::string(anEnv) + FSEP + "plugins"; + } + } + return aValue; +} + void Config_XMLReader::readAll() { xmlNodePtr aRoot = findRoot(); readRecursively(aRoot); } -/* - * Allows to customize reader's behavior for a node. Virtual. - * The default implementation does nothing. (In debug mode prints - * some info) - */ -void Config_XMLReader::processNode(xmlNodePtr aNode) +void Config_XMLReader::processNode(xmlNodePtr theNode) { + if (isNode(theNode, NODE_SOURCE, NULL)) { + std::string aSourceFile = getProperty(theNode, SOURCE_FILE); + Config_XMLReader aSourceReader = Config_XMLReader(aSourceFile); + readRecursively(aSourceReader.findRoot()); #ifdef _DEBUG - std::cout << "Config_XMLReader::processNode: " - << aNode->name << " content: " - << aNode->content << std::endl; + //std::cout << "Config_XMLReader::sourced node: " << aSourceFile << std::endl; #endif + } +} + +void Config_XMLReader::cleanup(xmlNodePtr) +{ + // do nothing; } -/* - * Defines which nodes should be processed recursively. Virtual. - * The default implementation is to read all nodes. - */ bool Config_XMLReader::processChildren(xmlNodePtr aNode) { return true; } -/* - * - */ xmlNodePtr Config_XMLReader::findRoot() { - myXmlDoc = xmlParseFile(myDocumentPath.c_str()); + if (myXmlDoc == NULL) { + myXmlDoc = xmlParseFile(myDocumentPath.c_str()); + } if (myXmlDoc == NULL) { #ifdef _DEBUG std::cout << "Config_XMLReader::import: " << "Document " << myDocumentPath @@ -92,7 +117,6 @@ xmlNodePtr Config_XMLReader::findRoot() #endif return NULL; } - xmlNodePtr aRoot = xmlDocGetRootElement(myXmlDoc); #ifdef _DEBUG if(aRoot == NULL) { @@ -102,87 +126,81 @@ 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) return; xmlNodePtr aNode = theParent->xmlChildrenNode; - for(; aNode; aNode = aNode->next) { + for (; aNode; aNode = aNode->next) { + //Still no text processing in features... + if (!isElementNode(aNode)) { + continue; + } processNode(aNode); if (processChildren(aNode)) { readRecursively(aNode); } + cleanup(aNode); } } -/* - * void* -> xmlNodePtr - */ xmlNodePtr Config_XMLReader::node(void* theNode) { return static_cast(theNode); } -/* - * Returns named property for a given node as std::string. - */ -std::string Config_XMLReader::getProperty(xmlNodePtr theNode, const char* name) +std::string Config_XMLReader::getNodeName(xmlNodePtr theNode) { std::string result = ""; - char* aPropChars = (char*) xmlGetProp(theNode, BAD_CAST name); + char* aPropChars = (char*) theNode->name; if (!aPropChars || aPropChars[0] == 0) return result; result = std::string(aPropChars); return result; } -/* - * Returns true if theNode is XML node with a given name. - */ -bool Config_XMLReader::isNode(xmlNodePtr theNode, const char* theNodeName, ...) +void Config_XMLReader::storeAttribute(xmlNodePtr theNode, const char* theAttribute, bool doClean) { - bool result = false; - const xmlChar* aName = theNode->name; - if (!aName || theNode->type != XML_ELEMENT_NODE) { - return false; + std::string aKey = getNodeName(theNode) + ":" + std::string(theAttribute); + std::string aValue = getProperty(theNode, theAttribute); + if (doClean || !aValue.empty()) { + myCachedAttributes[aKey] = aValue; } - if (!xmlStrcmp(aName, (const xmlChar *) theNodeName)) { - return true; - } - va_list args; // define argument list variable - va_start(args, theNodeName); // init list; point to last defined argument - while(true) { - char *anArg = va_arg (args, char*); // get next argument - if (anArg == NULL) - break; - if (!xmlStrcmp(aName, (const xmlChar *) anArg)) { - va_end(args); // cleanup the system stack - return true; - } +} + +std::string Config_XMLReader::restoreAttribute(xmlNodePtr theNode, const char* theAttribute) +{ + return restoreAttribute(getNodeName(theNode).c_str(), theAttribute); +} + +std::string Config_XMLReader::restoreAttribute(const char* theNodeName, const char* theAttribute) +{ + std::string aKey = std::string(theNodeName) + ":" + std::string(theAttribute); + std::string result = ""; + if(myCachedAttributes.find(aKey) != myCachedAttributes.end()) { + result = myCachedAttributes[aKey]; } - va_end(args); // cleanup the system stack - return false; + return result; } -/* - * Every xml node has child. Even if there is no explicit - * child nodes libxml gives the "Text node" as child. - * - * This method checks if real child nodes exist in the - * given node. - */ -bool Config_XMLReader::hasChild(xmlNodePtr theNode) +bool Config_XMLReader::cleanupAttribute(xmlNodePtr theNode, const char* theNodeAttribute) { - xmlNodePtr aNode = theNode->children; - for(; aNode; aNode = aNode->next) { - if (aNode->type != XML_ELEMENT_NODE) { - return true; - } + 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; } - return false; + return result; } + +const char* Config_XMLReader::encoding() const +{ + return (const char*) myXmlDoc->encoding; +} \ No newline at end of file