configreader.cpp

/***************************************************************************
 *   Copyright (C) 2004 by Michael Moritz                                  *
 *   mimo@restoel.net                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <iostream>
#include <syslog.h>
#include "strtrim.h"
#include "configreader.h"
#include "cfg.h"

using namespace std;

ConfigReader::StringMap ConfigReader::s_emptyMap;

ConfigReader::ConfigReader(std::istream &is) throw (std::exception)
{
        bool verbose = g_getCfg().isVerbose();
        StrTrim trimmer(" \t");
        while(!is.eof()) {
                string line;
                getline(is,line);
                if(line.length() > 0) {
                        if(line.at(0) != '#') { //ignore comments
                                string prefix = "";
                                string val = "";
                                string key;
                                string::size_type eqpos = line.find('=');       
                                string::size_type uscorepos = line.find('_');
                                if((uscorepos != string::npos) && (uscorepos < eqpos)) {
                                        prefix = line.substr(0,uscorepos);
                                        key = line.substr(uscorepos+1,eqpos-uscorepos-1);
                                } else {
                                        key = line.substr(0,eqpos);
                                }
                                if(eqpos != string::npos) {
                                        val = line.substr(eqpos+1,string::npos);
                                        trimmer.trim(prefix);
                                        trimmer.trim(key);
                                        trimmer.trim(val);
                                        if(verbose) {
                                                if(key == "password")
                                                        syslog(LOG_DEBUG,"config: prefix: %s key: %s value=(hidden)",prefix.c_str(),key.c_str());
                                                else                                            
                                                        syslog(LOG_DEBUG,"config: prefix: %s key: %s value=%s",prefix.c_str(),key.c_str(),val.c_str());
                                        }
//                                      cout << "pre: " << prefix << " key: " << key << " val=" << val << endl;
                                        ConfigMap::iterator itr = _map.find(prefix);
                                        if( itr == _map.end() ) {
                                                StringMap tmpMap;
                                                tmpMap.insert(StringMap::value_type(key,val));
                                                _map.insert(ConfigMap::value_type(prefix,tmpMap));      
                                        } else {
                                                itr->second.insert(StringMap::value_type(key,val));
                                        }
                                } else {
                                        if(verbose)
                                                syslog(LOG_DEBUG,"config: ingoring: %s",line.c_str());
                                }
                        }
                }
        }
}
const ConfigReader::StringMap& ConfigReader::get(const std::string& prefix,bool dontThrow) const throw (std::exception)
{
        ConfigMap::const_iterator itr = _map.find(prefix);
        if(itr != _map.end())
                return itr->second;
        else {
                if(!dontThrow)
                        throw runtime_error("prefix: "+prefix+" not found");
                else
                        return s_emptyMap;
        }
}
const std::string& ConfigReader::getVal(const std::string& prefix, const std::string& key) const throw (std::exception)
{
        const StringMap& preMap = get(prefix);  
        StringMap::const_iterator itr = preMap.find(key);
        if(itr != preMap.end())
        return itr->second;
        else
                throw runtime_error("key: "+key+" not found");
}
const std::string ConfigReader::getValOrDef(const std::string& prefix,const std::string& key,const std::string& def) const throw (std::exception)
{
        ConfigMap::const_iterator pitr = _map.find(prefix);
        if(pitr != _map.end()) {
                StringMap::const_iterator itr = pitr->second.find(key);
        if(itr != pitr->second.end())
                return itr->second;
        }
        return def;
}


/*
int main()
{
        ConfigReader reader(cin);
        try {
                reader.get("bla");
        } catch(exception &e) {
                cout <<"ok - exception caught: "<< e.what()<<endl;
        }
        const ConfigReader::StringMap& preMap = reader.get("prefix");
        for(ConfigReader::StringMap::const_iterator itr = preMap.begin(); itr != preMap.end();++itr) 
                cout << itr->first << " = " << itr->second << endl;

        return 0;
}
*/

---