GenericOptions.h

Go to the documentation of this file.

#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>
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 ProgressInfo;
    /**--------------------------------------------------------------------------------------------------
    \brief Stores a generic option of any type as well as some information about how the user
        might interact with that type.
    **/
    struct NDEVR_BASE_API GenericOption
    {
        GenericOption();
        GenericOption(const String& id, const TranslatedString& name, const String& value);
        template<class t_type>
        GenericOption(const String& 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)
            : name(option.name)
            , description(option.description)
            , id(option.id)
            , value(option.value.get())
            , default_value(option.default_value)
            , file_extensions(option.file_extensions)
            , icon(option.icon)
            , regex(option.regex)
            , parameter_type(option.parameter_type)
            , available_options(option.available_options)
            , value_bounds(option.value_bounds)
            , unit(option.unit)
            , allow_custom_option(option.allow_custom_option)
            , is_editable(option.is_editable)
            , is_viewable(option.is_viewable)
        {}
        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 String& new_value)
        {
            return value.set(new_value);
        }
        void setToDefault()
        {
            value.set(default_value);
        }
        bool operator==(const GenericOption& option) const
        {
            return option.value.get() == value.get();
        }
        bool operator!=(const GenericOption& option) const
        {
            return option.value.get() != value.get();
        }
        GenericOption& operator=(const GenericOption& option)
        {
            name = option.name;
            description = option.description;
            id = option.id;
            default_value = option.default_value;
            parameter_type = option.parameter_type;
            icon = option.icon;
            regex = option.regex;
            parameter_type = option.parameter_type;
            available_options = option.available_options;
            value_bounds = option.value_bounds;
            file_extensions = option.file_extensions;
            unit = option.unit;
            is_editable = option.is_editable;
            is_viewable = option.is_viewable;
            allow_custom_option = option.allow_custom_option;
            value.set(option.value.get());
            return *this;
        }
        TranslatedString name;
        TranslatedString description;
        String id;
        Resource<String> value;
        String default_value;
        String file_extensions;//If blank, not a file
        String icon;
        String regex;
        TypeInfo parameter_type;
        Buffer<std::pair<TranslatedString, String>> 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;
    };
    /**--------------------------------------------------------------------------------------------------
    \brief Stores a groups of GenericOptions that can be used to group them.
    **/
    class NDEVR_BASE_API GenericOptionGroup
    {
    public:
        GenericOptionGroup() = default;
        GenericOptionGroup(const TranslatedString& group_name, const String& group_id = String());
        virtual ~GenericOptionGroup();
        template<class t_type>
        void addOption(const TranslatedString& name, const t_type& value, bool is_editable = true)
        {
            GenericOption option(name.translationID(), 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.translationID());
        }
        bool hasOption(const String& 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.translationID()), "Bad Option");
            options[name.translationID()].value.set(String(value));
        }
        template<class t_type>
        void setValue(const String& name, const t_type& value)
        {
            lib_assert(options.hasKey(name), "Bad Option");
            options[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.translationID());
        }
        GenericOption& getOption(const TranslatedString& n)
        {
            return options.get(n.translationID());
        }
 
        template<class t_type>
        t_type getValue(const TranslatedString& name) const
        {
            return options.get(name.translationID()).getAs<t_type>();
        }
        template<class t_type>
        t_type getValue(const String& 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.translationID());
            if (iter != options.end())
                return iter.value().getAs<t_type>();
            else
                return value_if_not_exist;
        }
        template<class t_type>
        t_type getValue(const String& 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;
    };
}