DesignProperties.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObjectBase.h>
namespace NDEVR
{
    class NDEVR_DESIGN_API DesignInfo
    {
    public:
        template<class t_property_enum>
        friend class PropertyInterface;
        template<class t_property_enum>
        friend class PropertyColumnInterface;
        enum DesignObjectType : uint01
        {
              e_model = 0x01
            , e_geometry = 0x02
            , e_material = 0x04
            , e_bone = 0x08
            , e_effect = 0x10
            , e_layer = 0x20
        };
    protected:
        DesignInfo() = default;
        DesignInfo(DesignObjectBase* base);

        DesignInfo(uint04 index, DesignObjectBase* base);

        void _setTransform(const Matrix<fltp08>& transform);

        void _setDesignVisible(bool is_visible);
    protected:
        DesignObjectBase* m_base = nullptr; 
#ifdef Q_OS_WASM
        uint04 m_padding = 0; 
#endif
        uint04 m_index = Constant<uint04>::Invalid; 
        uint04 m_design_index = Constant<uint04>::Invalid; 
    };

    template<class t_property_enum>
    class PropertyColumnInterface
    {
    public:
        static TableColumn* column(const DesignInfo* object, t_property_enum property);

        static uint04 index(const DesignInfo* object, t_property_enum property);
    };

    template<auto t_property>
    struct PropertySpec
    {
    };

    template<class t_property_enum>
    class PropertyInterface
    {
    public:
        static TableColumn* column(const DesignInfo* object, t_property_enum property)
        {
            return PropertyColumnInterface<t_property_enum>::column(object, property);
        }

        static uint04 index(const DesignInfo* object, t_property_enum property)
        {
            return PropertyColumnInterface<t_property_enum>::index(object, property);
        }

        template<class t_value_type>
        static void Set(DesignInfo* object, t_property_enum property, const t_value_type& value)
        {
            column(object, property)->set(index(object, property), value);
        }

        template<t_property_enum t_property, class t_value_type>
        static void Set(DesignInfo* object, const t_value_type& value)
        {
            column(object, t_property)->set(index(object, t_property), value);
        }

        template<class t_value_type>
        static decltype(auto) Get(const DesignInfo* object, t_property_enum property)
        {
            return column(object, property)->template get<t_value_type>(index(object, property));
        }

        template<t_property_enum t_property, class t_value_type>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return column(object, t_property)->template get<t_value_type>(index(object, t_property));
        }

        template<t_property_enum t_property>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return column(object, t_property)->template get<typename PropertySpec<t_property>::type>(index(object, t_property));
        }

        template<class t_value_type>
        static bool IsSame(const DesignInfo* object, t_value_type property, const StringView& value)
        {
            return column(object, property)->isSame(index(object, property), value);
        }
    };

    enum class NDPO : uint04
    {
          guid 
        , design_type 
        , transform 
        , bounding_box 
        , name 
        , description 
        , editable_description 
        , creation_time 
        , modified_time 
        , asc_modified_time 
        , desc_modified_time 
        , geometry_modified_time 
        , author 
        , creation_software 
        , spacial_visible 
        , tree_visible 
        , icon 
        , is_selected 
        , is_focused 
        , allow_interactions 
        , file 
        , search_terms 
        , category 
        , deletion_allowed 
        , is_deleted 
        , application_locked 
        , is_application_owned 
        , bounds_ignored 
        , selection_ignored 
        , meta_data 
        , untranslated_string_data 
        , translated_string_data 
        , uncompressed_data 
        , compressed_data 
        , library_id 
        , is_frozen 
        , applied_filters 
        , property_size 
        //Dummy convenience properties
    };
    template<> struct PropertySpec<NDPO::guid> { using type = UUID; }; 
    template<> struct PropertySpec<NDPO::library_id> { using type = UUID; }; 
    template<> struct PropertySpec<NDPO::design_type> { using type = uint01; }; 
    template<> struct PropertySpec<NDPO::creation_time> { using type = Time; }; 
    template<> struct PropertySpec<NDPO::modified_time> { using type = Time; }; 
    template<> struct PropertySpec<NDPO::asc_modified_time> { using type = Time; }; 
    template<> struct PropertySpec<NDPO::desc_modified_time> {using type = Time; }; 
    template<> struct PropertySpec<NDPO::geometry_modified_time> { using type = Time; }; 
    template<> struct PropertySpec<NDPO::transform> { using type = Matrix<fltp08>; }; 
    template<> struct PropertySpec<NDPO::bounding_box> { using type = Bounds<3, fltp08>; }; 
    template<> struct PropertySpec<NDPO::name> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::description> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::author> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::creation_software> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::icon> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::file> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::search_terms> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::meta_data> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::category> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::applied_filters> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::untranslated_string_data> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::translated_string_data> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPO::uncompressed_data> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::compressed_data> { using type = StringView; }; 
    template<> struct PropertySpec<NDPO::editable_description> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::spacial_visible> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::tree_visible> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::is_selected> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::is_focused> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::allow_interactions> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::deletion_allowed> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::is_deleted> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::application_locked> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::is_application_owned> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::bounds_ignored> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::selection_ignored> { using type = bool; }; 
    template<> struct PropertySpec<NDPO::is_frozen> { using type = bool; }; 

    template<>
    class PropertyInterface<NDPO>
    {
    public:
        template<class t_value_type>
        static decltype(auto) Get(const DesignInfo* object, NDPO property)
        {
            return column(object, property)->get<t_value_type>(object->m_index);
        }

        template<NDPO t_property, class t_value_type>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return column(object, t_property)->get<t_value_type>(object->m_index);
        }

        template<class t_value_type>
        static void Set(DesignInfo* object, NDPO property, const t_value_type& value)
        {
            switch (property)
            {
            case NDPO::design_type:
                object->m_base->design_properties[eint01(property)]->set(object->m_index, value);
                break;
            case NDPO::spacial_visible:
                object->m_base->design_properties[eint01(property)]->set(object->m_index, value);
                object->_setDesignVisible(Get<NDPO::spacial_visible, bool>(object));
                break;
            case NDPO::transform:
                object->m_base->design_properties[eint01(property)]->set(object->m_index, value);
                object->_setTransform(Get<NDPO::transform, Matrix<fltp08>>(object));
                break;
            default:
                object->m_base->design_properties[eint01(property)]->set(object->m_index, value);
                break;
            }
        }

        template<NDPO t_property>
        static inline void Set(DesignInfo* object, const typename PropertySpec<t_property>::type& value)
        {
            static_assert(t_property != NDPO::is_deleted, "cannot directly delete design object");
            if constexpr (t_property == NDPO::design_type)
            {
                object->m_base->design_type[object->m_index] = value;
            }
            else if constexpr (t_property == NDPO::guid)
            {
                object->m_base->guid[object->m_index] = value;
            }
            else if constexpr (t_property == NDPO::modified_time)
            {
                object->m_base->modified_time[object->m_index] = rcast<uint08>(value);
            }
            else if constexpr (t_property == NDPO::desc_modified_time)
            {
                object->m_base->desc_modified_time[object->m_index] = rcast<uint08>(value);
            }
            else if constexpr (t_property == NDPO::asc_modified_time)
            {
                object->m_base->asc_modified_time[object->m_index] = rcast<uint08>(value);
            }
            else if constexpr (t_property == NDPO::name)
            {
                object->m_base->name[object->m_index] = value;
            }
            else if constexpr (t_property == NDPO::transform)
            {
                object->_setTransform(value);
                lib_assert(IsValid(value), "Tried to set Invalid transform");
                lib_assert(IsValid(value.invert()), "Tried to set to non-invertable transform");
            }
            else if constexpr (t_property == NDPO::bounding_box)
            {
                object->m_base->bounding_box[object->m_index] = rcast<Vector<6, fltp08>>(value);
            }
            else if constexpr (t_property == NDPO::spacial_visible)
            {
                object->_setDesignVisible(value);
            }
            else if constexpr (t_property == NDPO::tree_visible)
            {
                object->m_base->tree_visible[object->m_index] = value;
            }
            else if constexpr (t_property == NDPO::is_deleted)
            {
                object->m_base->is_deleted[object->m_index] = value;
            }
            else
            {
                object->m_base->design_properties[eint01(t_property)]->set(object->m_index, value);
            }
        }

        static constexpr TableColumn* column(const DesignInfo* object, NDPO property)
        {
            return object->m_base->design_properties[eint01(property)];
        }

        static bool IsSame(const DesignInfo* object, NDPO property, const StringView& value)
        {
            return column(object, property)->isSame(object->m_index, value);
        }

        template<NDPO t_property>
        static decltype(auto) Get(const DesignInfo* object)
        {
            if constexpr (t_property == NDPO::design_type)
                return object->m_base->design_type[object->m_index];
            else if constexpr (t_property == NDPO::guid)
                return rcast<UUID>(object->m_base->guid[object->m_index]);
            else if constexpr (t_property == NDPO::modified_time)
                return rcast<Time>(object->m_base->modified_time[object->m_index]);
            else if constexpr (t_property == NDPO::asc_modified_time)
                return rcast<Time>(object->m_base->asc_modified_time[object->m_index]);
            else if constexpr (t_property == NDPO::desc_modified_time)
                return rcast<Time>(object->m_base->desc_modified_time[object->m_index]);
            else if constexpr (t_property == NDPO::name)
                return object->m_base->name[object->m_index];
            else if constexpr (t_property == NDPO::transform)
                return rcast<Matrix<fltp08>>(object->m_base->transform[object->m_index]);
            else if constexpr (t_property == NDPO::bounding_box)
                return rcast<Bounds<3, fltp08>>(object->m_base->bounding_box[object->m_index]);
            else if constexpr (t_property == NDPO::tree_visible)
                return object->m_base->tree_visible[object->m_index];
            else if constexpr (t_property == NDPO::spacial_visible)
                return object->m_base->spacial_visible[object->m_index];
            else if constexpr (t_property == NDPO::is_deleted)
                return object->m_base->is_deleted[object->m_index];
            else
                return column(object, t_property)->get<typename PropertySpec<t_property>::type>(object->m_index);
        }
    };
    // not a true property, but allows for easy calculated get/set
    enum class NDPOC
    {
          name 
        , description 
        , creation_software 
        , category 
        , search_terms 
        , author 
    };
    template<> struct PropertySpec<NDPOC::name> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPOC::description> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPOC::creation_software> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPOC::category> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPOC::search_terms> { using type = TranslatedString; }; 
    template<> struct PropertySpec<NDPOC::author> { using type = TranslatedString; }; 

    template<>
    class PropertyColumnInterface<NDPOC>
    {
    public:
        static constexpr TableColumn* column(const DesignInfo* object, NDPOC property)
        {
            switch (property)
            {
            case NDPOC::name:
                return &object->m_base->name;
            case NDPOC::description:
                return object->m_base->design_properties[eint01(NDPO::description)];
            case NDPOC::creation_software:
                return object->m_base->design_properties[eint01(NDPO::creation_software)];
            case NDPOC::category:
                return object->m_base->design_properties[eint01(NDPO::category)];
            case NDPOC::search_terms:
                return object->m_base->design_properties[eint01(NDPO::search_terms)];
            case NDPOC::author:
                return object->m_base->design_properties[eint01(NDPO::author)];
            default:
                lib_assert(false, "Bad value");
                return nullptr;
            }
        }

        static constexpr uint04 index(const DesignInfo* object, NDPOC)
        {
            return object->m_index;
        }
    };
}