cfg.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.             *
 ***************************************************************************/
#include <sstream>
#include "cfg.h"

//Global 
static Cfg gso_CfgObject;

Cfg& g_getCfgNonConst()
{
        return gso_CfgObject; 
}
const Cfg& g_getCfg() 
{
        return gso_CfgObject; 
}

//Cfg
const std::string Cfg::_s_strMode = "mode";
const std::string Cfg::_s_strRunModes[Cfg::_ENUM_last] =
    { "init","normal","weak","reverse" };
const std::string Cfg::_s_strTimeout = "timeout";
const std::string Cfg::_s_strVerbose = "verbose";
const std::string Cfg::_s_strDbType = "dbtype";
const std::string Cfg::_s_strNoPrefix = "";     
const std::string Cfg::_s_strDbPrefix = "db";   
const std::string Cfg::_s_strWlPrefix = "wl";   
const std::string Cfg::_s_strWlModes[Cfg::WLEntry::_ENUM_last] = {"off","db","dbcached"};
const std::string Cfg::_s_strWeakBytes = "weakbytes";

void Cfg::init(const ConfigReader& reader) throw (std::exception)
{
//      const std::string& verbose = reader.getValOrDef(_s_strNoPrefix,_s_strVerbose,_s_strRunModes[0]);
        const std::string& mode = reader.getValOrDef(_s_strNoPrefix,_s_strMode,_s_strRunModes[0]);
        _runMode = parseSelect<RunMode,Cfg::_ENUM_last>(mode,_s_strRunModes); 
        _dbtype = reader.getValOrDef(_s_strNoPrefix,_s_strDbType,_dbtype);
        _ulTimeout = parseNumeric(reader,_s_strNoPrefix,_s_strTimeout,_ulTimeout);
        _uWeakBytes = parseNumeric(reader,_s_strNoPrefix,_s_strWeakBytes,_uWeakBytes);
        //read db_<params>
        //this throws (and exits)
        //TODO can be empty
        const ConfigReader::StringMap& preMap = reader.get(_s_strDbPrefix); //get everything prefixed with db_
        for(ConfigReader::StringMap::const_iterator itr = preMap.begin(); itr != preMap.end();++itr) {
                _dbParams.push_back(itr->first);
                _dbParams.push_back(itr->second);
        }
        //read wl_<params>
        const ConfigReader::StringMap& wlMap = reader.get(_s_strWlPrefix,true); //get everything prefixed with wl_,dont throw
        for(ConfigReader::StringMap::const_iterator itr = wlMap.begin(); itr != wlMap.end();++itr) {
                WLEntry entry(parseSelect<WLEntry::WLMode,WLEntry::_ENUM_last>(itr->second,_s_strWlModes),"");
                _wlMap.insert(WLMap::value_type(itr->first,entry));
        }
} 
unsigned long Cfg::parseNumeric(const ConfigReader& reader,const std::string& prefix,const std::string& key,unsigned long def) const
{
        std::stringstream defStm;
        defStm << def;
        const std::string& str = reader.getValOrDef(prefix,key,defStm.str());
        if(str != defStm.str()) {
                unsigned long ul = def;
                std::stringstream stm;
                stm << str;
                stm >> ul;
                def = ul;
        }
        return def;
}
const std::string& Cfg::getWlModeName(const WLEntry::WLMode mode) const throw (std::exception)
{
        if(mode >= WLEntry::_ENUM_last)
                throw std::out_of_range("Cfg::getWlModeName mode out of range");
        return _s_strWlModes[mode];
}
const Cfg::WLEntry Cfg::getWLEntry(const std::string& key) const
{
        WLMap::const_iterator itr = _wlMap.find(key);
        if(itr != _wlMap.end())
                return itr->second;
        else
                return WLEntry(WLEntry::WL_off,"");
}

---