config_node.hpp

#if !defined(__CONFIG_NODE_HPP__)
#define __CONFIG_NODE_HPP__

//
// standard includes
//
#include <string>
#include <vector>

//
// local includes
//
#include "core/util/noncopyable.hpp"
#include "core/util/c++0x.hpp"
#include "core/system/log.hpp"

//
// forward declarations
//
namespace detail
{
    template <typename NodeTypeT>
    struct node_traits
    {};
}

struct config_node : private noncopyable
{
    //
    // mandatory attributes
    //
    std::string id;

    //
    // node types
    //
    enum type
    {
        BOOL, NUMBER, INTERVAL, STRING, LIST, SECTION
    } type;

    //
    // value attributes
    //
    union
    {
        bool boolean;
        unsigned long number;
        struct
        {
            unsigned long low, high;
        };
    };

    std::string string;

  protected:
    //
    // hierarchy attributes
    //
    config_node *next, *children;

  public:
    //
    // constructors & destructor
    //
    inline config_node(const std::string &id, bool boolean)
        : id(id), type(BOOL), boolean(boolean), next(nullptr), children(nullptr)
    {}

    inline config_node(const std::string &id, unsigned long number)
        : id(id), type(NUMBER), number(number), next(nullptr), children(nullptr)
    {}

    inline config_node(const std::string &id, unsigned long low, unsigned long high)
        : id(id), type(INTERVAL), low(low), high(high), next(nullptr), children(nullptr)
    {}

    inline config_node(const std::string &id, const char *string)
        : id(id), type(STRING), string(string), next(nullptr), children(nullptr)
    {}

    inline config_node(const std::string &id, config_node *children)
        : id(id), type(LIST), next(nullptr), children(children)
    {}

    inline config_node(const std::string &id, enum type type, config_node *next, config_node *children)
        : id(id), type(type), next(next), children(children)
    {}

    inline ~config_node(void)
    {
        delete next;
        delete children;
    }

    //
    // query functions
    //
    inline bool is(enum type type) const
    {
        return this->type == type;
    }

    inline bool is_bool(void) const
    {
        return is(BOOL);
    }

    inline bool is_number(void) const
    {
        return is(NUMBER);
    }

    inline bool is_interval(void) const
    {
        return is(INTERVAL);
    }

    inline bool is_string(void) const
    {
        return is(STRING);
    }

    inline bool is_list(void) const
    {
        return is(LIST);
    }

    inline bool is_section(void) const
    {
        return is(SECTION);
    }

    inline bool is_attribute(void) const
    {
        return !is_section();
    }

    inline bool is_or_warn(enum type type) const
    {
        if (is(type)) return true;
        warn_wrong_type(type);
        return false;
    }

    //
    // ID functions
    //
    void set_ID(const std::string &id, bool recursive=false);

    //
    // siblings handling
    //
    inline int num_siblings(void) const
    {
        return num_nodes(next);
    }

    inline bool has_sibling(const std::string &id="") const
    {
        return get_node(next, id) != nullptr;
    }

    inline const config_node *get_sibling(const std::string &id="") const
    {
        return get_node(next, id);
    }

    inline void append_sibling(config_node *node)
    {
        // appends the node at the end of the silblings list, so do not free it anymore
        return append_node(next, node);
    }

    inline const config_node *remove_sibling(const std::string &id="")
    {
        // removes the first sibling named id from the list, which doesn't get_node freed
        //     automatically anymore (transfers ownership to caller)
        return remove_node(next, id);
    }

    //
    // children handling
    //
    inline int num_children(void) const
    {
        return num_nodes(children);
    }

    inline bool has_child(const std::string &id="") const
    {
        return get_node(children, id) != nullptr;
    }

    inline const config_node *get_child(const std::string &id="") const
    {
        return get_node(children, id);
    }

    inline void append_child(config_node *node)
    {
        // appends the node at the end of the children list, so do not free it anymore
        return append_node(children, node);
    }

    inline config_node *remove_child(const std::string &id="")
    {
        // removes the first child named id from the list, which doesn't get freed
        //     automatically anymore (transfers ownership to caller)
        return remove_node(children, id);
    }

    //
    // data functions for all node types
    //
    inline void warn_wrong_type(void) const
    {
        log::warn("wrong type for option: %s, ignored\n", id.c_str());
    }

    inline void warn_wrong_type(enum type type) const
    {
        log::warn("wrong type for option: %s, expected: %s\n", id.c_str(), type2string(type));
    }

    inline void warn_wrong_value(void) const
    {
        log::warn("wrong value '%s' for option: %s, ignored\n", get_value().c_str(), id.c_str());
    }

    void warn_non_empty_section(const char *message=nullptr) const;
    std::string get_value(void) const;

    template <typename NodeTypeT>
    inline NodeTypeT get_value(const NodeTypeT default_value=NodeTypeT()) const
    {
        return is_or_warn(detail::node_traits<NodeTypeT>::type) ?
                   detail::node_traits<NodeTypeT>::value(*this) : default_value;
    }

    //
    // data functions for section/list nodes:
    //     operate on all child nodes with the specified (list child nodes inherit their id)
    //
    template <typename NodeTypeT>
    NodeTypeT get_option(const std::string &id, NodeTypeT default_value=NodeTypeT());

    template <typename NodeTypeT>
    int get_list_option(std::vector<NodeTypeT> &result, const std::string &id);

    //
    // debug stuff
    //
    static inline const char *type2string(enum type type)
    {
        return (type == BOOL) ? "bool" :
                   (type == NUMBER) ? "number" :
                       (type == INTERVAL) ? "interval" :
                           (type == STRING) ? "string" :
                               (type == LIST) ? "list" :
                                   (type == SECTION) ? "section" : "unknown";
    }

    inline const char *type2string(void) const
    {
        return type2string(type);
    }

    void print(int indent=0, int indent_inc=2, bool siblings=false) const;

  protected:
    //
    // hierarchy management functions: these functions do the real work
    //
    static inline int num_nodes(const config_node *chain)
    {
        for (int n=0; ; chain=chain->next, n++)
            if (!chain) return n;
    }

    static inline const config_node *get_node(const config_node *chain, const std::string &id="")
    {
        for (const config_node *p=chain; ; p=p->next)
            if (!p || (id == "") || (p->id == id)) return p;
    }

    static void append_node(config_node *&chain, config_node *node);
    static config_node *remove_node(config_node *&chain, const std::string &id="");
};

//
// node_traits implementation (cannot specialize member function templates :()
//
namespace detail
{
    using ::config_node;

    template <>
    struct node_traits<bool>
    {
        static const enum config_node::type type=config_node::BOOL;

        static inline bool value(const config_node &node)
        {
            return node.boolean;
        }
    };

    template <>
    struct node_traits<unsigned long>
    {
        static const enum config_node::type type=config_node::NUMBER;

        static inline unsigned long value(const config_node &node)
        {
            return node.number;
        }
    };

    template <>
    struct node_traits<std::string>
    {
        static const enum config_node::type type=config_node::STRING;

        static inline std::string value(const config_node &node)
        {
            return node.string;
        }
    };
}

#endif

// ***** end of source ***** //