IConfigManager.h

Go to the documentation of this file.

// mortic - A game engine for the Expanses of Naryan.
// Copyright (C) 2007  Aaron Griffith
// This file is under the LGPL. See mortic.h for more information.

//   _____             __ _       __  __                                      //
//  / ____|           / _(_)     |  \/  |                                     //
// | | $   ___  _ __ | |_ _  __ _| \  / | __ _ _ __   __ _  __ _  ___ _ __    //
// | | $  / _ \| '_ \|  _| |/ _` | |\/| |/ _` | '_ \ / _` |/ _` |/ _ \ '__|   //
// | |___| (_) | | | | | | | (_| | |  | | (_| | | | | (_| | (_| |  __/ |      //
//  \_____\___/|_| |_|_| |_|\__, |_|  |_|\__,_|_| |_|\__,_|\__, |\___|_|      //
//                           __/ |                          __/ |             //
//                          |___/                          |___/              //
// IConfigManager.h - Interface of ConfigManager                              //

#ifndef __IConfigManager_h_INCLUDED__
#define __IConfigManager_h_INCLUDED__

#include "IRoot.h"
#include "IObject.h"

#include <sstream>
#include <vector>
#include <string>

namespace mortic
{
        
        class IConfigSet
        {
        friend class IRoot;
        public:
                IConfigSet()
                { }
                ~IConfigSet()
                { }
                
                
        void setOption(std::string section, std::string key, std::string value)
        {
                sections.push_back(section);
                keys.push_back(key);
                values.push_back(value);
        }

        std::vector<std::string> sections;
        std::vector<std::string> keys;
        std::vector<std::string> values;
    };
                
    
    class IConfigManager : public IObject
    {
    public:
        
        IConfigManager(IRoot* root) : IObject(root, "ConfigManager")
        { }
        
        
        virtual ~IConfigManager()
        { }
        
        
        virtual std::string getOption(std::string section, std::string key, std::string def) = 0;
        
        
        template<typename T> T getOption(std::string section, std::string key, T def)
        {
            std::stringstream out;
            std::stringstream in;
            T outvar;
            out << def;
            in << getOption(section, key, out.str());
            in >> outvar;
            return outvar;
        }
        
        
        virtual void setOption(std::string section, std::string key, std::string value) = 0;
        
        
        template<typename T> void setOption(std::string section, std::string key, T value)
        {
                std::stringstream tmp;
                tmp << value;
                setOption(section, key, tmp.str());
        }
        
        // Loads configuration from a file.
        
        // This loads all the values in the given file into the manager
        // \arg \b file - the filename to read from
        // \sa writeConfig()
        //virtual void loadConfig(std::string file) = 0;
        
        // Saves configuration to a file.
        
        // This saves all the current values to the given file.
        // \arg \b file - the filename to write to
        // \sa loadConfig()
        //virtual void writeConfig(std::string file) = 0;
    };

}
; // namespace mortic
#endif // __IConfigManager_h_INCLUDED__

---