config.h

#ifndef FLAME_CONFIG_H
#define FLAME_CONFIG_H

#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
} // extern "C"

#include <ostream>
#include <vector>
#include <map>
#include <memory>
#include <stdexcept>

#include <boost/shared_ptr.hpp>
#include <boost/variant.hpp>
#include <boost/call_traits.hpp>
#include <boost/static_assert.hpp>

#include "util.h"

namespace detail {
// helper to return POD types by value and complex types by const reference
template<typename X>
struct RT { typedef const X& type; };
template<> struct RT<double> { typedef double type; };

template<typename V>
struct buildval {
    static inline V op() { return V(); }
};
template<>
struct buildval<double> {
    static inline double op() { return 0.0; }
};

// helper to ensure that attempts to call Config::get<T> for unsupported T will fail to compile.
template<typename T>
struct is_config_value {
};
#define IS_CONFIG_VALUE(TYPE) \
namespace detail {template<> struct is_config_value<TYPE> { typedef TYPE type; };}
} // namespace detail
IS_CONFIG_VALUE(double)
IS_CONFIG_VALUE(std::string)
IS_CONFIG_VALUE(std::vector<double>)

class Config
{
public:
    typedef boost::variant<
        double,
        std::vector<double>,
        std::string,
        std::vector<Config>
    > value_t;

    typedef std::vector<Config> vector_t;

    typedef std::map<std::string, value_t> values_t;
private:
    typedef boost::shared_ptr<values_t> values_pointer;
    typedef boost::shared_ptr<const values_t> const_values_pointer;

    values_pointer values;
    const_values_pointer implicit_values;

    void _cow();
public:
    Config();
    Config(const Config&);
    ~Config() {}
    Config& operator=(const Config&);

    bool tryGetAny(const std::string& name, value_t& ret) const;
    const value_t& getAny(const std::string& name) const;
    void setAny(const std::string& name, const value_t& val);
    void swapAny(const std::string& name, value_t& val);

    template<typename T>
    typename detail::RT<T>::type
    get(const std::string& name) const {
        try {
            return boost::get<typename detail::is_config_value<T>::type>(getAny(name));
        } catch(boost::bad_get&) {
            throw key_error(SB()<<"Wrong type for '"<<name<<"'.  should be "<<typeid(T).name());
        }
    }
    template<typename T>
    typename detail::RT<T>::type
    get(const std::string& name, typename boost::call_traits<T>::param_type def) const {
        try{
            return boost::get<typename detail::is_config_value<T>::type>(getAny(name));
        } catch(boost::bad_get&) {
        } catch(key_error&) {
        }
        return def;
    }

    template<typename T>
    bool
    tryGet(const std::string& name, T& val) const {
        value_t ret;
        if(tryGetAny(name, ret)) {
            try{
                val = boost::get<typename detail::is_config_value<T>::type>(ret);
                return true;
            } catch(boost::bad_get&) {
            }
        }
        return false;
    }

    template<typename T>
    void set(const std::string& name,
             typename boost::call_traits<typename detail::is_config_value<T>::type>::param_type val)
    {
        _cow();
        (*values)[name] = val;
    }

    template<typename T>
    void swap(const std::string& name,
              typename boost::call_traits<typename detail::is_config_value<T>::type>::reference val)
    {
        value_t temp = detail::buildval<T>::op();
        val.swap(boost::get<T>(temp));
        swapAny(name, temp);
        //val.swap(boost::get<T>(temp)); // TODO: detect insert, make this a real swap
    }

    void swap(Config& c)
    {
        // no _cow() here since no value_t are modified
        values.swap(c.values);
        implicit_values.swap(c.implicit_values);
    }

    void show(std::ostream&, unsigned indent=0) const;

    typedef values_t::iterator iterator;
    typedef values_t::const_iterator const_iterator;

    inline const_iterator begin() const { return values->begin(); }
    inline const_iterator end() const { return values->end(); }

    inline void reserve(size_t) {}
    Config new_scope() const;
    void push_scope();

    void flatten();
};

IS_CONFIG_VALUE(std::vector<Config>);

inline
std::ostream& operator<<(std::ostream& strm, const Config& c)
{
    c.show(strm);
    return strm;
}

class GLPSParser
{
    class Pvt;
    std::auto_ptr<Pvt> priv;
public:
    GLPSParser();
    ~GLPSParser();

    void setVar(const std::string& name, const Config::value_t& v);
    void setPrinter(std::ostream*);

    Config *parse_file(const char *fname);
    Config *parse_file(FILE *fp, const char *path=NULL);
    Config *parse_byte(const char* s, size_t len, const char *path=NULL);
    Config *parse_byte(const std::string& s, const char *path=NULL);
};

void GLPSPrint(std::ostream& strm, const Config&);


#undef IS_CONFIG_VALUE

#endif /* extern "C" */

#endif // FLAME_CONFIG_H