Question

I’ve been thinking of The Right Way (R) to store my program’s internal configuration.

Here’s the details:

• The configuration is runtime only, so generated each run.
• It can be adapted (and should) through directives in a “project” file (the reading of that file is not in the scope of this question)
• It needs to be extensible, ie there should be a way to add new “variables” with assignes values.

My questions about this:

1. How should I begin with this? Is a
   class with accessors and setters
   with an internal std::map for
   custom variables a good option?
2. Are there any known and “good” ways
   of doing this?
3. Should there be a difference between
   integer, boolean and string
   configuration variables?
4. Should there be a difference at all
   between user and built-in
   (pre-existing as in I already
   thought of them) variables?

Thanks!

PS: If the question isn’t clear, feel free to ask for more info.

UPDATE: Wow, every answer seems to have implicitely or explicitly used boost. I should have mentioned I’d like to avoid boost (I want to explore the Standard libraries’ capabilities as is for now).

Answer 1

You could do worse than some kind of a property map (StringMap is just a typedef’d std::map)

class PropertyMap
{
private:
    StringMap m_Map;

public:
    PropertyMap() { };
            ~PropertyMap() { };

    // properties
    template<class T>
    T get(const String& _key, const T& _default = T()) const
    {
        StringMap_cit cit(m_Map.find(_key));
        return (cit != m_Map.end()) ? boost::lexical_cast<T>(cit->second) : _default;
    };  // eo get

    // methods
    void set(const String& _cap, const String& _value)
    { 
        m_Map[_cap] = _value;
    };  // eo set

    template<class T>
    void set(const String& _key, const T& _val)
    {
        set(_key, boost::lexical_cast<String>(_val));
    };  // eo set
};