CODEWITHSUNDEEP
c++design-patternsconfiguration
rubenvb
rubenvb

Reputation: 76579

Dynamically storing an internal configuration

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

Here's the details:

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).

Upvotes: 2

Views: 496

Answers (3)

Maxim Egorushkin
Maxim Egorushkin

Reputation: 136306

It is very useful to support nesting in configuration files. Something like JSON.

As parameter values can be scalars, arrays and nested groups of parameters, it could be stored in a std::map of boost::variant's, whose value can be a scalar, array or other std::map recursively. Note that std::map sorts by name, so if the original config file order of parameters is important there should be a sequential index of parameters as well. This can be achieved by using boost::multi_index with an ordered or hashed index for fast lookup and a sequential index for traversing the parameters in the original config file order.

I haven't checked, that boost property map could do that from what I've heard.

It is possible to store all values as strings (or arrays of strings for array values) converting them to the destination type only when accessing it.

Upvotes: 0

Steve Townsend
Steve Townsend

Reputation: 54168

You could use Boost.PropertyTree for this.

Property trees are versatile data structures, but are particularly suited for holding configuration data. The tree provides its own, tree-specific interface, and each node is also an STL-compatible Sequence for its child nodes.

Upvotes: 3

Moo-Juice
Moo-Juice

Reputation: 38800

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
};

Upvotes: 2

Related Questions