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

Go to the documentation of this file.

#include <WURDEConfiguration.H>
#include <syslog.h>
#include <stdlib.h>
#include <Logger.H>

using namespace WURDE;
using namespace std;

namespace WURDE {

       WURDEConfiguration g_globalConfiguration;

       WURDEConfiguration::WURDEConfiguration(){
              // set up defaults for the robot
              m_dataDir="/usr/local/share/wurde/data";
              m_binDir="/usr/local/bin";
              m_configDir="/usr/local/share/wurde/config";
              m_mcpConfigFile="mcp-config.xml";
              m_logDirectory="/usr/local/share/wurde/log";
              m_moduleName="null";
              m_logLevel=LOG_DEBUG;
       }

       bool WURDEConfiguration::haveOption(std::string name){
              std::multimap<std::string,std::string>::iterator iter;
              g_logdebug << "looking for option #"<<name<<"# in conf object " << this <<endl;
              iter=m_options.find(name);
              if(iter!=m_options.end()){
                     return true;
              }
              g_logdebug << "Don't have it." <<endl;
              return false;
       }
       
       std::string WURDEConfiguration::getOption(std::string name){
              std::multimap<std::string,std::string>::iterator iter;

              iter=m_options.find(name);
              if(iter!=m_options.end()){
                     return iter->second;
              }

              return "empty";
       }

       void WURDEConfiguration::setOption(std::string name, std::string value){
              m_options.insert(pair<string,string>(name,value));
              g_logdebug << "Setting option #"<<name<<"#"<<endl;
              if(m_options.find(name)==m_options.end()){
                      g_logdebug << "SOMETHING IS VERY WRONG IN SETOPTIONS" << endl;
              }else if(!haveOption(name)){
                      g_logdebug << "SOMETHING IS BROKEN IN HAVEOPTIONS" << endl;
                    
              }else{
                      g_logdebug << "Everything is peachy. " << endl;
              }
       }

       bool WURDEConfiguration::haveModuleOption(std::string module, std::string name){
              std::multimap<std::string, std::multimap<std::string, std::string> >::iterator iter;
              iter=m_moduleOptions.find(module);
              if(iter!=m_moduleOptions.end()){
                     std::multimap<std::string,std::string>::iterator iter2;
                     iter2=iter->second.find(name);
                     if(iter2!=iter->second.end()){
                            return true;
                     }

                     return false;
              }

              return false;
       }
       
       std::string WURDEConfiguration::getModuleOption(std::string module, std::string name){
              std::multimap<std::string, std::multimap<std::string, std::string> >::iterator iter;

              iter=m_moduleOptions.find(module);
              if(iter!=m_moduleOptions.end()){
                     std::multimap<std::string,std::string>::iterator iter2;
                     iter2=iter->second.find(name);
                     if(iter2!=iter->second.end()){
                            return iter2->second;;
                     }

                     return "empty";
              }

              return "empty";

       }

       void WURDEConfiguration::setModuleOption(std::string module, std::string name, std::string value){
              std::multimap<std::string, std::multimap<std::string, std::string> >::iterator iter;

              iter=m_moduleOptions.find(module);
              if(iter!=m_moduleOptions.end()){
                     iter->second.insert(pair<string,string>(name,value));
              }else{
                     std::multimap<string,string> temp;
                     temp.insert(pair<string,string>(name,value));
                     m_moduleOptions.insert(pair<string,multimap<string,string> >(module,temp));
              }
              
       }


       void WURDEConfiguration::readEnvironment(){
              char *temp;

              temp=getenv("WURDE_DATA_DIR");
              if(temp){
                     setDataDirectory(temp);
              }

              temp=getenv("WURDE_CONFIG_DIR");
              if(temp){
                     setConfigDirectory(temp);
              }

              temp=getenv("WURDE_BIN_DIR");
              if(temp){
                     setBinDirectory(temp);
              }

              temp=getenv("WURDE_MCP_CONFIG");
              if(temp){
                     setMCPConfigFile(temp);
              }

              temp=getenv("WURDE_LOG_LEVEL");
              if(temp){
                     string tmplog=temp;
                     std::transform (tmplog.begin(),tmplog.end(), tmplog.begin(), (int (*) (int)) tolower);
                     if(tmplog=="debug"){
                            setLogLevel(LOG_DEBUG);
                     }else if(tmplog=="info"){
                            setLogLevel(LOG_INFO);
                     }else if(tmplog=="notice"){
                            setLogLevel(LOG_NOTICE);
                     }else if(tmplog=="warn"){
                            setLogLevel(LOG_WARNING);
                     }else if(tmplog=="error"){
                            setLogLevel(LOG_ERR);
                     }else if(tmplog=="fatal"){
                            setLogLevel(LOG_CRIT);
                     }else{
                            cout << "Invalid loging level requested. Using LOG_DEBUG\n";
                            setLogLevel(LOG_DEBUG);
                     }
              }

              temp=getenv("WURDE_LOG_DIRECTORY");
              if(temp){
                     setLogDirectory(temp);
              }

       }


}

---