cfg.h

/***************************************************************************
 *   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.             *
 ***************************************************************************/
#ifndef CFG_H
#define CFG_H
#include <stdexcept>
#include <map>
#include "configreader.h"
#include "db.h"

class Cfg{
        typedef enum {
                RM_init = 0,
                RM_normal,
                RM_weak,
                RM_reverse,
                _ENUM_last
        }RunMode;
public:
        class WLEntry {
        public:
                typedef enum {
                        WL_off = 0,
                        WL_db,
                        WL_dbcached,
                        _ENUM_last
                }WLMode;
        public:
                WLEntry(WLMode mode,const std::string&) : _mode(mode) { }
                WLMode getMode() const { return _mode; }
        private:
                WLMode _mode;
        };
        typedef std::map<std::string,WLEntry>WLMap;
    
        Cfg(RunMode runMode=RM_init,unsigned long ulTimeout=3600,
                const std::string dbtype="mysql",bool verbose=false,
                unsigned significant_bytes_in_weak_mode=3)
                :       _runMode(runMode),_verbose(verbose),_dbtype(dbtype),
                        _ulTimeout(ulTimeout),_uWeakBytes(significant_bytes_in_weak_mode)
                { }
        void init(const ConfigReader& cfgreader) throw (std::exception);
    ~Cfg() { };
        // user
        bool isVerbose() const { return _verbose; }
        void setVerbose(bool b) { _verbose = b; }
        bool isModeReverse() const { return _runMode == RM_reverse; }
        const std::string& getDbType() const { return _dbtype; }
        const DB::ParamVector& getDbParamVector() const { return _dbParams; }
        bool isModeInit() const { return _runMode == RM_init; }
        bool isModeWeak() const { return _runMode == RM_weak; }
        unsigned getWeakBytes() const { return _uWeakBytes; }
//      WLMode isWLNetwork() const { return _wlNetwork; }
        bool isWlDb(const std::string& key) const { return getWLEntry(key).getMode() == WLEntry::WL_db; }
        bool isWlDbCached(const std::string& key) const { return getWLEntry(key).getMode() == WLEntry::WL_dbcached; }
        WLEntry::WLMode getWLMode(const std::string& key) const { return getWLEntry(key).getMode(); }
        unsigned long getTimeout() const { return _ulTimeout; }
        const WLMap& getWLMap() const { return _wlMap; }
        const std::string& getWlModeName(const WLEntry::WLMode mode) const throw (std::exception);
protected:
        /* return WL_off if not found */
        const WLEntry getWLEntry(const std::string&) const;
        unsigned long parseNumeric(const ConfigReader& reader,const std::string& prefix,const std::string& key,unsigned long def) const;
private:        
        RunMode _runMode;
        bool _verbose;
        std::string _dbtype;
        
        DB::ParamVector _dbParams;
        
        unsigned long _ulTimeout;       

        unsigned _uWeakBytes;
        
        WLMap _wlMap;
                
        static const std::string _s_strMode;
        static const std::string _s_strRunModes[_ENUM_last];
        static const std::string _s_strTimeout; 
        static const std::string _s_strVerbose; 
        static const std::string _s_strDbType;  
        static const std::string _s_strNoPrefix;
        static const std::string _s_strDbPrefix;        
        static const std::string _s_strWlPrefix;        
        static const std::string _s_strWlModes[WLEntry::_ENUM_last];    
        static const std::string _s_strWeakBytes;
        
        template <typename T,unsigned size>
        T parseSelect(const std::string& key, const std::string array[T::_ENUM_last]) const
        {
                //unsigned bla = ;
                for(unsigned i=0;i < size; i++) {
                        if(key == array[i]) {
                                return T(i);
                        }
                }
                return T(0);
        }
        
        
};
Cfg& g_getCfgNonConst();
const Cfg& g_getCfg();

#endif

---