/home/fwph/code/wurde/rde/core/xmlparser.cpp

Go to the documentation of this file.

#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/util/XMLChar.hpp>
#include <string>
#include <iostream>
#include <WURDEConfiguration.H>
#include <Logger.H>
#include <errno.h>
#include <algorithm>
#include <cctype>

// Other include files, declarations, and non-Xerces-C++ initializations.
XERCES_CPP_NAMESPACE_USE 

using namespace WURDE;
using namespace std;

namespace WURDE {  
       
        void parseWURDEConfig(string config){

              FILE *ptr;
              ptr=fopen(config.c_str(),"r");
              if(!ptr){
                     cout << "Config file not found!\n";
                     return;
              }else{
                     fclose(ptr);
              }
              
              try {
                     XMLPlatformUtils::Initialize();
              }
              catch (const XMLException& toCatch) {           
                     cout << "Something went wrong.\n";
                     //we should probably do some more failure processing, and generally catch the exceptions
                     //that can be thrown by Xerces, but i'm not doing that right now.
                     return;
              }

              /*
               * Create a DOM parser, and turn schemas on. Namespace validation is necessary as well.
               */
              XercesDOMParser *domparser=new XercesDOMParser;
              domparser->setValidationScheme(XercesDOMParser::Val_Always);
              domparser->setDoNamespaces(true);
              domparser->setDoSchema(true);
              domparser->parse(config.c_str());

              XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0;
              DOMElement *root;
              DOMNode *child,*item;
              DOMNodeList *children,*theNodes;
              DOMNamedNodeMap *attr;
                
              doc=domparser->getDocument();
              //              doc = parser->parseURI(config.c_str());
              if(!doc){
                     g_logfatal << "Config file " << config.c_str() << " not found!"<< endl;
                     exit(1);
              }

              
              root=doc->getDocumentElement();
              if(!root){
                     g_logfatal << "Document did not validate!" << endl;
                     exit(1);
              }
              //now the code
              string currentname, temp;
              
              //make sure we've got an mcp-config section
              /*              temp=XMLString::transcode(root->getTagName());
              if(temp!="robot"){
                     g_logfatal << "That is not a proper robot configuration file." << endl;
                     exit(1);
                     }*/
              
              //get the module nodes
              theNodes=root->getElementsByTagName(XMLString::transcode("wurde-config"));
              //children=doc->getChildNodes();        
              if(theNodes->getLength() > 0){
                     child=theNodes->item(0);
                     children=child->getChildNodes();
              }else{
                     g_logfatal << "Found no wurde-config elements. Invalid config!" << endl;
                     exit(1);
              }


              for(unsigned int j=0;j<children->getLength();j++){
                            child=children->item(j);
                            temp=XMLString::transcode(child->getNodeName());
                            
                            if(temp=="config-directory"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("location"));
                                   if(item){
                                          g_globalConfiguration.setConfigDirectory(XMLString::transcode(item->getNodeValue()));
                                   }else{
                                          cout << "config-directory option present but no location!\n";
                                   }
                            }else if(temp=="data-directory"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("location"));
                                   if(item){
                                          g_globalConfiguration.setDataDirectory(XMLString::transcode(item->getNodeValue()));
                                   }else{
                                          cout << "data-directory option present but no location!\n";
                                   }
                            }else if(temp=="bin-directory"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("location"));
                                   if(item){
                                           g_globalConfiguration.setBinDirectory(XMLString::transcode(item->getNodeValue()));
                                   }else{
                                           g_logdebug << "bin-directory option present but no location!\n";
                                   }

                            }else if(temp=="mcp"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("mcp-config"));
                                   if(item){
                                          g_globalConfiguration.setMCPConfigFile(XMLString::transcode(item->getNodeValue()));
                                   }else{
                                          g_logdebug << "mcp entity present but no mcp-config!\n";
                                   }


                            }else if(temp=="log"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("directory"));
                                   if(item){
                                          g_globalConfiguration.setLogDirectory(XMLString::transcode(item->getNodeValue()));
                                   }

                                   item=attr->getNamedItem(XMLString::transcode("level"));
                                   if(item){
                                          string tmplog=XMLString::transcode(item->getNodeValue());
                                          std::transform (tmplog.begin(),tmplog.end(), tmplog.begin(), (int (*) (int)) tolower);

                                          if(tmplog=="debug"){
                                                 g_globalConfiguration.setLogLevel(LOG_DEBUG);
                                          }else if(tmplog=="info"){
                                                 g_globalConfiguration.setLogLevel(LOG_INFO);
                                          }else if(tmplog=="notice"){
                                                 g_globalConfiguration.setLogLevel(LOG_NOTICE);
                                          }else if(tmplog=="warn"){
                                                 g_globalConfiguration.setLogLevel(LOG_WARNING);
                                          }else if(tmplog=="error"){
                                                 g_globalConfiguration.setLogLevel(LOG_ERR);
                                          }else if(tmplog=="fatal"){
                                                 g_globalConfiguration.setLogLevel(LOG_CRIT);
                                          }else{
                                                 cout << "Invalid loging level requested. Using LOG_DEBUG\n";
                                                 g_globalConfiguration.setLogLevel(LOG_DEBUG);
                                          }

                                   }

                            }else if(temp=="option"){
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("name"));
                                   std::string optname;
                                   std::string optval;
                                   if(item){
                                          optname=XMLString::transcode(item->getNodeValue());
                                   }

                                   item=attr->getNamedItem(XMLString::transcode("value"));
                                   if(item){
                                          optval=XMLString::transcode(item->getNodeValue());
                                   }

                                   g_globalConfiguration.setOption(optname,optval);

                            }else if(temp=="module"){
                                   DOMNodeList *tempchildren;
                                   tempchildren=child->getChildNodes();
                                   std::string mname;
                                   attr=child->getAttributes();
                                   item=attr->getNamedItem(XMLString::transcode("name"));
                                   if(item){
                                          mname=XMLString::transcode(item->getNodeValue());
                                   }

                                   for(unsigned int k=0;k<tempchildren->getLength();k++){
                                          child=tempchildren->item(k);
                                          temp=XMLString::transcode(child->getNodeName());
                                          if(temp=="option"){
                                                 std::string optname;
                                                 std::string optval;
                                                 
                                                 attr=child->getAttributes();
                                                 item=attr->getNamedItem(XMLString::transcode("name"));
                                                 if(item){
                                                        optname=XMLString::transcode(item->getNodeValue());
                                                 }

                                                 item=attr->getNamedItem(XMLString::transcode("value"));
                                                 optval=XMLString::transcode(item->getNodeValue());
                                                 
                                                 g_globalConfiguration.setModuleOption(mname,optname,optval);
                                          }
                                   }
                            }else if(temp!="#text"){
                                   g_logwarn << "Unrecognized tag " << temp << endl;
                            }
              }
              
              
              
              XMLPlatformUtils::Terminate();
              
              // Other terminations and cleanup.
              return;
       }
       
}

---