GenericOptions.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/Pointer.h>
#include <NDEVR/TypeInfo.h>
#include <NDEVR/String.h>
#include <NDEVR/Unit.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Resource.h>
#include <utility>
namespace NDEVR
{
    /*struct GenericContainer
    {
        union ContainerValue
        {
            ContainerValue() {};
            ~ContainerValue() {}
            String string_value;
            fltp08 fltp08_value;
            fltp04 fltp04_value;
            sint08 sint08_value;
            uint08 uint08_value;
            sint04 sint04_value;
            uint04 uint04_value;
            bool bool_value;
        };
        template<class t_type> GenericContainer(const t_type& value) { value.string_value = String(value); }
        GenericContainer(const String& value) { m_value.string_value = value; }
        GenericContainer(fltp08 value) { m_value.fltp08_value = value; }
        GenericContainer(fltp04 value) { m_value.fltp04_value = value; }
        GenericContainer(sint08 value) { m_value.sint08_value = value; }
        GenericContainer(sint04 value) { m_value.sint04_value = value; }
        GenericContainer(uint08 value) { m_value.uint08_value = value; }
        GenericContainer(uint04 value) { m_value.uint04_value = value; }
        GenericContainer(bool value) {  m_value.bool_value = value; }
        template<class t_type> t_type getValue() const { return m_value.string_value.template getAs<t_type>(); }
        template<> String getValue() const { return m_value.string_value.getAs<String>(); }
        template<> fltp08 getValue<fltp08>() const { return m_value.fltp08_value; }
        template<> fltp04 getValue<fltp04>() const { return m_value.fltp04_value; }
        template<> sint08 getValue<sint08>() const { return m_value.sint08_value; }
        template<> sint04 getValue<sint04>() const { return m_value.sint04_value; }
        template<> uint08 getValue<uint08>() const { return m_value.uint08_value; }
        template<> uint04 getValue<uint04>() const { return m_value.uint04_value; }
        template<> bool getValue<bool>() const { return m_value.bool_value; }
 
    protected:
        ContainerValue m_value;
    };*/
    class INIFactory;
    class JSONNode;
    class InfoPipe;
    struct NDEVR_BASE_API GenericOption
    {
        TranslatedString name; 
        TranslatedString description; 
        String id; 
        Resource<String> value; 
        String default_value; 
        String file_extensions; 
        String icon; 
        String regex; 
        String password_encode_key; 
        TypeInfo parameter_type; 
        Buffer<std::pair<TranslatedString, StringAllocatingView>> available_options; 
        Bounds<1, fltp08> value_bounds = Constant<Bounds<1, fltp08>>::Invalid; 
        ConstPointer<Unit> unit; 
        bool allow_custom_option = false; 
        bool is_editable = true; 
        bool is_viewable = true; 
        bool show_resolved_links = false; 
        bool is_password = false; 
        bool allow_multi_line = false; 
        bool is_create_file = false; 
        GenericOption();
        GenericOption(const StringView& id, const TranslatedString& name, const StringView& value);
        template<class t_type>
        GenericOption(const StringView& id, const TranslatedString& name, const t_type& value)
            : name(name)
            , id(id)
            , value(String(value))
            , default_value(String(value))
            , parameter_type(GetTypeInfo<t_type>())
        {}

        GenericOption(const GenericOption& option);
        template<class t_type>
        [[nodiscard]] t_type getAs() const
        {
            return value.get().getAs<t_type>();
        }

        template<class t_type>
        void set(const t_type& new_value)
        {
            return value.set(String(new_value));
        }

        void set(const StringView& new_value)
        {
            return value.set(String(new_value));
        }

        void set(const String& new_value)
        {
            return value.set(new_value);
        }

        void setToDefault()
        {
            value.set(default_value);
        }

        GenericOption& operator=(const GenericOption& option);
        void setupForFolder();
        void setupForFile(const StringView& extensions = StringView());
        void setupForDelimiter();
        bool operator==(const GenericOption& option) const
        {
            return option.value.get() == value.get();
        }

        bool operator!=(const GenericOption& option) const
        {
            return option.value.get() != value.get();
        }
 
    };

    class NDEVR_BASE_API GenericOptionGroup
    {
    public:
        GenericOptionGroup() = default;
        GenericOptionGroup(const TranslatedString& group_name, const StringView& group_id = StringView());
        virtual ~GenericOptionGroup();
        template<class t_type>
        void addOption(const TranslatedString& name, const t_type& value, bool is_editable = true)
        {
            GenericOption option(name.readableID(), name, value);
            option.is_editable = is_editable;
            addOption(option);
        }

        void addOption(const GenericOption& option)
        {
            lib_assert(!options.hasKey(option.id), "Bad Option");
            options.add(option.id, option);
            ordered_options.add(option.id);
        };

        bool hasOption(const TranslatedString& option_name) const
        {
            return options.hasKey(option_name.readableID());
        }

        bool hasOption(const StringView& option_name) const
        {
            return options.hasKey(option_name);
        }

        template<class t_type>
        void setValue(const TranslatedString& name, const t_type& value)
        {
            lib_assert(options.hasKey(name.readableID()), "Bad Option");
            options[name.readableID()].value.set(String(value));
        }

        template<class t_type>
        void setValue(const StringView& name, const t_type& value)
        {
            lib_assert(options.hasKey(name), "Bad Option");
            options.get(name).value.set(String(value));
        }

        void setOption(const GenericOption& option)
        {
            lib_assert(options.hasKey(option.id), "Bad Option");
            if (!options.hasKey(option.id))
                ordered_options.add(option.id);
            options[option.id] = option;
 
        }

        const GenericOption& getOption(const TranslatedString& n) const
        {
            return options.get(n.readableID());
        }

        GenericOption& getOption(const TranslatedString& n)
        {
            return options.get(n.readableID());
        }

        template<class t_type>
        t_type getValue(const TranslatedString& name) const
        {
            return options.get(name.readableID()).getAs<t_type>();
        }

        template<class t_type>
        t_type getValue(const StringView& name) const
        {
            return options.get(name).getAs<t_type>();
        }

        template<class t_type>
        t_type getValue(const TranslatedString& name, const t_type& value_if_not_exist) const
        {
            auto iter = options.find(name.readableID());
            if (iter != options.end())
                return iter.value().getAs<t_type>();
            else
                return value_if_not_exist;
        }

        template<class t_type>
        t_type getValue(const StringView& name, const t_type& value_if_not_exist) const
        {
            auto iter = options.find(name);
            if (iter != options.end())
                return iter.value().getAs<t_type>();
            else
                return value_if_not_exist;
        }

        bool operator==(const GenericOptionGroup& option_group) const;
        bool operator!=(const GenericOptionGroup& option_group) const;
        INIFactory ini();
        void addOptionsToINI(INIFactory& factory);
        [[nodiscard]] virtual JSONNode toJSONNode(bool only_value = true) const;
        virtual void fromJSONNode(const JSONNode& node);
        void clear();
        Dictionary<String, GenericOption> options; 
        Buffer<String> ordered_options; 
        TranslatedString name; 
        String id; 
    };
}