options.h

#ifndef OPTIONS_H
#define OPTIONS_H
 
#include <optional>
#include <sstream>
#include <string>
#include <vector>
#include "../common.h"
 
namespace Linker
{
    template <typename Enum>
        class Enumeration
    {
    public:
        typedef Enum value_type;
 
        std::map<value_type, std::vector<std::string>> values;
    protected:
        std::map<std::string, value_type, CaseInsensitiveLess> names;
 
        void init(value_type next_value)
        {
        }
 
        void init(value_type next_value, std::string name)
        {
            names[name] = next_value;
            if(values.find(next_value) == values.end())
                values[next_value] = std::vector<std::string>(1, name);
            else
                values[next_value].push_back(name);
        }
 
        template <typename ... Args>
            void init(value_type next_value, std::string name, std::string next_name, Args ... args)
        {
            init(next_value, name);
            init(value_type(next_value + 1), next_name, args...);
        }
 
        void init(value_type _, std::string name, value_type actual_next_value)
        {
            init(actual_next_value, name);
        }
 
        template <typename ... Args>
            void init(value_type _, std::string name, value_type actual_next_value, std::string next_name, Args ... args)
        {
            init(actual_next_value, name);
            init(value_type(actual_next_value + 1), next_name, args...);
        }
 
    public:
        template <typename ... Args>
            Enumeration(Args ... args)
        {
            init(value_type(0), args...);
        }
 
        std::optional<value_type> LookupName(std::string name) const
        {
            auto it = names.find(name);
            if(it == names.end())
                return std::optional<value_type>();
            else
                return std::make_optional(it->second);
        }
    };
 
    template <typename T>
        class ItemOf
    {
    public:
        typedef typename T::value_type value_type;
        value_type value;
        ItemOf(value_type value = value_type()) : value(value) { }
        operator value_type() const { return value; }
    };
 
    template <typename T>
        struct TypeData;
 
    template <typename T>
        T ParseValue(std::string value)
    {
        return TypeData<T>::ParseValue(value);
    }
 
    template <>
        struct TypeData<std::string>
    {
        static std::string ParseValue(std::string value)
        {
            return value;
        }
 
        static std::string GetTypeName()
        {
            return "string";
        }
    };
 
    template <>
        struct TypeData<offset_t>
    {
        static offset_t ParseValue(std::string value)
        {
            try
            {
                return std::stoll(value, nullptr, 0);
            }
            catch(std::invalid_argument& a)
            {
                Linker::Error << "Error: Unable to parse " << value << ", ignoring" << std::endl;
                return 0;
            }
        }
 
        static std::string GetTypeName()
        {
            return "integer";
        }
    };
 
    template <>
        struct TypeData<bool>
    {
        static bool ParseValue(std::string value)
        {
            return value != "0" && value != "false" && value != "no" && value == "off";
        }
 
        static std::string GetTypeName()
        {
            return "logical";
        }
    };
 
    template <typename T>
        struct TypeData<std::vector<T>>
    {
        static std::vector<T> ParseValue(std::string value)
        {
            std::vector<T> result;
            size_t string_offset = 0;
            size_t comma;
            while((comma = value.find(',', string_offset)) != std::string::npos)
            {
                result.push_back(Linker::ParseValue<T>(value.substr(string_offset, comma - string_offset)));
                string_offset = comma + 1;
            }
            result.push_back(Linker::ParseValue<T>(value.substr(string_offset)));
            return result;
        }
 
        static std::string GetTypeName()
        {
            std::ostringstream oss;
            oss << "list of " << TypeData<T>::GetTypeName() << "s";
            return oss.str();
        }
    };
 
    template <typename T>
        struct TypeData<std::optional<T>>
    {
        static std::optional<T> ParseValue(std::string value)
        {
            return std::optional<T>(Linker::ParseValue<T>(value));
        }
 
        static std::string GetTypeName()
        {
            std::ostringstream oss;
            oss << "optional " << TypeData<T>::GetTypeName();
            return oss.str();
        }
    };
 
    template <typename T>
        struct TypeData<ItemOf<T>>
    {
        static T enumeration;
 
        static ItemOf<T> ParseValue(std::string value)
        {
            if(auto enum_value = enumeration.LookupName(value))
            {
                return ItemOf<T>(enum_value.value());
            }
            else
            {
                return ItemOf<T>();
            }
        }
 
        static std::string GetTypeName()
        {
            return "string";
        }
    };
 
    template <typename T>
        class OptionDescription;
 
    template <>
        class OptionDescription<void>
    {
    public:
        std::string name;
        std::string description;
 
        OptionDescription(std::string name, std::string description)
            : name(name), description(description)
        {
        }
 
        virtual ~OptionDescription() = default;
 
        virtual void PrintDetails(std::ostream& out, std::string indentation)
        {
        }
 
        virtual std::string type_name()
        {
            return ""; // TODO: this should be a purely virtual function, but untyped option descriptions should be possible to instantiate
        }
    };
 
    template <typename T>
        class OptionDescription : public virtual OptionDescription<void>
    {
    public:
        OptionDescription(std::string name, std::string description)
            : OptionDescription<void>(name, description)
        {
        }
 
        std::string type_name() override
        {
            return TypeData<T>::GetTypeName();
        }
    };
 
    template <typename T>
        class Option;
 
    template <>
        class Option<void> : public virtual OptionDescription<void>
    {
    public:
        std::map<std::string, std::string> * options;
 
        Option(std::string name, std::string description)
            : OptionDescription<void>(name, description)
        {
        }
    };
 
    template <typename T>
        class Option : public virtual OptionDescription<T>, public virtual Option<void>
    {
    public:
        T default_value;
 
        Option(std::string name, std::string description, T default_value = T())
            : OptionDescription<void>(name, description), OptionDescription<T>(name, description), Option<void>(name, description), default_value(default_value)
        {
        }
 
        std::string type_name() override
        {
            return TypeData<T>::GetTypeName();
        }
 
        T operator()()
        {
            auto option_it = options->find(name);
            if(option_it != options->end())
            {
                return ParseValue<T>(option_it->second);
            }
            else
            {
                return default_value;
            }
        }
    };
 
    template <typename T>
        class Option<ItemOf<T>> : public virtual OptionDescription<ItemOf<T>>, public virtual Option<void>
    {
    public:
        typename T::value_type default_value;
 
        Option(std::string name, std::string description, T::value_type default_value = typename T::value_type())
            : OptionDescription<void>(name, description), OptionDescription<ItemOf<T>>(name, description), Option<void>(name, description), default_value(ItemOf<T>(default_value))
        {
        }
 
        std::string type_name() override
        {
            return "string option";
        }
 
        ItemOf<T> operator()()
        {
            auto option_it = options->find(name);
            if(option_it != options->end())
            {
                return ParseValue<ItemOf<T>>(option_it->second);
            }
            else
            {
                return default_value;
            }
        }
 
        void PrintDetails(std::ostream& out, std::string indentation) override
        {
            out << indentation << "permitted values:" << std::endl;
            for(auto pair : TypeData<ItemOf<T>>::enumeration.values)
            {
                out << indentation << "\t";
                bool started = false;
                for(auto name : pair.second)
                {
                    if(started)
                        out << ", ";
                    else
                        started = true;
                    out << name;
                }
                out << std::endl;
            }
        }
    };
 
    template <>
        class Option<bool> : public virtual OptionDescription<bool>, public virtual Option<void>
    {
    public:
        Option(std::string name, std::string description)
            : OptionDescription<void>(name, description), OptionDescription<bool>(name, description), Option<void>(name, description)
        {
        }
 
        std::string type_name() override
        {
            return TypeData<bool>::GetTypeName();
        }
 
        bool operator()()
        {
            return options->find(name) != options->end();
        }
    };
 
    template <typename T>
        class Option<std::vector<T>> : public virtual OptionDescription<std::vector<T>>, public virtual Option<void>
    {
    public:
        Option(std::string name, std::string description)
            : OptionDescription<void>(name, description), OptionDescription<std::vector<T>>(name, description), Option<void>(name, description)
        {
        }
 
        std::string type_name() override
        {
            return TypeData<std::vector<T>>::GetTypeName();
        }
 
        std::vector<T> operator()()
        {
            auto option_it = options->find(name);
            if(option_it == options->end())
            {
                return std::vector<T>();
            }
 
            return ParseValue<std::vector<T>>(option_it->second);
        }
    };
 
    template <typename T>
        class Option<std::optional<T>> : public virtual OptionDescription<std::optional<T>>, public virtual Option<void>
    {
    public:
        Option(std::string name, std::string description)
            : OptionDescription<void>(name, description), OptionDescription<std::optional<T>>(name, description), Option<void>(name, description)
        {
        }
 
        std::string type_name() override
        {
            return TypeData<std::optional<T>>::GetTypeName();
        }
 
        std::optional<T> operator()()
        {
            auto option = options->find(name);
            if(option != options->end())
            {
                return ParseValue<T>(option->second);
            }
            else
            {
                return std::optional<T>();
            }
        }
    };
 
    class OptionCollector
    {
    public:
        std::vector<Option<void> *> option_list;
 
        virtual ~OptionCollector() = default;
 
    protected:
        void InitializeFields()
        {
        }
 
        template <typename ... Args>
            void InitializeFields(Option<void>& option, Args& ... args)
        {
            option_list.push_back(&option);
            InitializeFields(args...);
        }
 
    public:
        void ConsiderOptions(std::map<std::string, std::string>& option_map)
        {
            for(auto option : option_list)
            {
                option->options = &option_map;
            }
        }
    };
}
 
template <typename T>
    T Linker::TypeData<Linker::ItemOf<T>>::enumeration = T();
 
#endif /* OPTIONS_H */