ApplicationOptions.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/GenericOption.h>
#include <NDEVR/INIFactory.h>
#include <NDEVR/Dictionary.h>
namespace NDEVR
{
    class INIFactory;
    class INIOption;
    class ResourceListener;

    class ApplicationOptionBase
    {
    public:
        virtual ~ApplicationOptionBase() {};

        virtual StringAllocatingView toString() const = 0;

        virtual void fromString(const String&) = 0;

        virtual bool isDefault() const = 0;

        virtual void setToDefaultValue() = 0;

        virtual INIOption* iniOption() = 0;
    };

    class NDEVR_BASE_API ApplicationOptions
    {
    public:
        ApplicationOptions();

        void addOption(const TranslatedString& name, ApplicationOptionBase* value)
        {
            addOption(TranslatedString(), name, value);
        }

        void addOption(const TranslatedString& group_name, const TranslatedString& name, ApplicationOptionBase* value)
        {
            lib_assert(!m_options[group_name].hasKey(name), "Duplicate entry");
            m_options[group_name][name] = value;
        }

        const ApplicationOptionBase* getOption(const TranslatedString& group,const TranslatedString& name) const
        {
            return m_options[group][name];
        }

        const ApplicationOptionBase* getOption(const TranslatedString& name) const
        {
            return getOption(TranslatedString(), name);
        }

        Dictionary<TranslatedString, ApplicationOptionBase*> optionGroup(TranslatedString);

        void addToINI(INIFactory& factory);

        void addToINI(const TranslatedString& group_name, INIFactory& factory);

        void setToDefaults();

        void setToDefaults(const TranslatedString& group_name);

        void logOptions(LogPtr& log, bool log_only_non_defaults);

        static ApplicationOptions& UserOptions();
    protected:
        Dictionary<TranslatedString, Dictionary<TranslatedString, ApplicationOptionBase*>> m_options; 
    };

    template<class t_type>
    class ApplicationOption : public ApplicationOptionBase
    {
    public:
        ApplicationOption(TranslatedString&& group, TranslatedString&& label, const t_type& value, ApplicationOptions& options = ApplicationOptions::UserOptions())
            : m_group(std::move(group))
            , m_label(std::move(label))
            , m_value(value)
            , m_options(options)
            , m_default_value(value)
        {
            m_options.addOption(m_group, m_label, this);
        }

        ApplicationOption(const TranslatedString& group, const TranslatedString& label, const t_type& value, ApplicationOptions& options = ApplicationOptions::UserOptions())
            : m_group(group)
            , m_label(label)
            , m_value(value)
            , m_options(options)
            , m_default_value(value)
        {
            m_options.addOption(group, label, this);
        }

        ApplicationOption(const TranslatedString& label, const t_type& value, ApplicationOptions& options = ApplicationOptions::UserOptions())
            : m_label(label)
            , m_value(value)
            , m_options(options)
            , m_default_value(value)
        {
            m_options.addOption(label, this);
        }

        template<class t_other_type = t_type>
        decltype(auto) get() const
        {
            return m_value.get();// m_options.getValue<t_type>(m_group, m_label);
        }

        Resource<t_type>& getResource()
        {
            return m_value;
        }

        void set(const t_type& value, bool make_default = false)
        {
            if (make_default)
                m_default_value = value;
            return m_value.set(value);
        }

        void setDefaultValue(const t_type& value)
        {
            m_default_value = value;
        }

        void addListener(ResourceListener* listener, bool silent_add = false)
        {
            m_value.addListener(listener, silent_add);
        }

        virtual StringAllocatingView toString() const override
        {
            return StringAllocatingView(m_value.get());
        }

        virtual void fromString(const String& value) override
        {
            m_value.set(value.getAs<t_type>());
        }

        virtual bool isDefault() const override
        {
            return m_value.get() == m_default_value;
        }

        virtual void setToDefaultValue() override
        {
            m_value.set(m_default_value);
        }

        virtual INIOption* iniOption() override
        {
            return INIFactory::ToOption(m_value);
        }

        const TranslatedString& label() const
        {
            return m_label;
        }

        const TranslatedString& group() const
        {
            return m_group;
        }
    protected:
        const TranslatedString m_group; 
        const TranslatedString m_label; 
        Resource<t_type> m_value; 
        ApplicationOptions& m_options; 
        t_type m_default_value; 
    };
}