DesignObject.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: DesignObject
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include "DesignProperties.h"
#include <NDEVR/DesignObjectBase.h>
#include <NDEVR/RWLock.h>
#include <NDEVR/TranslatedString.h>
namespace NDEVR
{
    class DesignCommand;
    class File;
    class Scene;
    class JSONNode;
    class SelectionInfo;
 
    class Model;
    typedef PrimitiveAlignedBuffer<Model, 16> ModelBuffer;  
    class Effect;
    typedef PrimitiveAlignedBuffer<Effect, 16> EffectBuffer;    
    class Material;
    typedef PrimitiveAlignedBuffer<Material, 16> MaterialBuffer;    
    class Geometry;
    typedef PrimitiveAlignedBuffer<Geometry, 16> GeometryBuffer;    
    class NDEVR_DESIGN_API DesignObject : public DesignInfo
    {
    public:
        friend class Model;
        DesignObject() = default;

        explicit DesignObject(DesignObjectBase* base);

        DesignObject(uint04 index, DesignObjectBase* base);

        DesignObject(const DesignInfo& info);

        void setDesignType(DesignObjectType mode, bool is_type);

        bool isDesignType(DesignObjectType mode) const;

        bool isDesignType(uint04 mode) const;

        bool validateDesignObject() const;

        JSONNode activeFilters() const;

        void setActiveFilters(const JSONNode& node);

        template<class t_type, class t_property_type>
        [[nodiscard]] constexpr decltype(auto) get(t_property_type property) const
        {
            return PropertyInterface<t_property_type>::template Get<t_type>(this, property);
        }

        template<auto t_property, class t_type>
        [[nodiscard]] constexpr decltype(auto) get() const
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            return PropertyInterface<t_property_type>::template Get<t_property, t_type>(this);
        }

        template<auto t_property>
        [[nodiscard]] constexpr decltype(auto) get() const
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            return PropertyInterface<t_property_type>::template Get<t_property>(this);
        }

        template<class t_type, class t_property_type>
        void set(t_property_type property, const t_type& value)
        {
            PropertyInterface<t_property_type>::Set(this, property, value);
        }

        template<auto t_property, class t_type>
        void set(const t_type& value)
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            PropertyInterface<t_property_type>::template Set<t_property>(this, value);
        }

        template<class t_type, class t_property_type>
        bool update(t_property_type property, const t_type& value, const void* lock = nullptr)
        {
            if (!is(property, value))
            {
                WLock wLock(lock);
                set(property, value);
                updateDesignModifiedTime();
                return true;
            }
            return false;
        }

        template<auto t_property, class t_type>
        bool update(const t_type& value, const void* lock = nullptr)
        {
            if (!is<t_property>(value))
            {
                WLock wLock(lock);
                set<t_property>(value);
                updateDesignModifiedTime();
                return true;
            }
            return false;
        }

        template<class t_type, class t_design_type>
        [[nodiscard]] bool hasProperty(t_design_type property) const
        {
            return IsValid(get<t_type>(property));
        }

        template<class t_property_type>
        [[nodiscard]] bool is(t_property_type property, const StringView& value) const
        {
            return PropertyInterface<t_property_type>::IsSame(this, property, value);
        }

        template<class t_property_type>
        [[nodiscard]] bool is(t_property_type property, const char* value) const
        {
            return PropertyInterface<t_property_type>::IsSame(this, property, value);
        }

        template<class t_property_type>
        [[nodiscard]] bool is(t_property_type property, const String& value) const
        {
            return PropertyInterface<t_property_type>::IsSame(this, property, value);
        }

        template<class t_property_type, class t_type>
        [[nodiscard]] typename std::enable_if<!ObjectInfo<t_type>::String, bool>::type is(t_property_type property, const t_type& value) const
        {
            return get<t_type>(property) == value;
        }

        template<auto t_property>
        [[nodiscard]] bool is(const StringView& value) const
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            return PropertyInterface<t_property_type>::IsSame(this, t_property, value);
        }

        template<auto t_property>
        [[nodiscard]] bool is(const char* value) const
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            return PropertyInterface<t_property_type>::IsSame(this, t_property, value);
        }

        template<auto t_property>
        [[nodiscard]] bool is(const String& value) const
        {
            using t_property_type = std::decay_t<decltype(t_property)>;
            return PropertyInterface<t_property_type>::IsSame(this, t_property, value);
        }

        template<auto t_property, class t_type>
        [[nodiscard]] typename std::enable_if<!ObjectInfo<t_type>::String, bool>::type is(const t_type& value) const
        {
            return get<t_property, t_type>() == value;
        }

        [[nodiscard]] bool doesPropertyBeginWith(NDPO property, const StringView& value, bool ignore_case) const
        {
            return m_base->design_properties[eint01(property)]->beginsWith(index(), value, ignore_case);
        }

        [[nodiscard]] bool doesPropertyContain(NDPO property, const StringView& value, bool ignore_case) const
        {
            return m_base->design_properties[eint01(property)]->contains(index(), value, ignore_case);
        }

        template<class t_type>
        [[nodiscard]] decltype(auto) getInheritedProperty(NDPO property) const
        {
            if (hasProperty<t_type>(property))
                return get<t_type>(property);
            DesignObject parent = getDesignParent();
            while (parent.isValid())
            {
                if (parent.hasProperty<t_type>(property))
                    return parent.get<t_type>(property);
                else
                    parent = parent.getDesignParent();
            }
            return get<t_type>(property);
        }

        [[nodiscard]] File file() const { return File(get<StringView>(NDPO::file)); }
        //virtual bool processSelection(SelectionInfo& info) const;

        [[nodiscard]] StringView getIcon() const;

        [[nodiscard]] DesignObject getDesignParent() const;

        void updateDesignModifiedTime(Time time = Time::SystemTime());

        void updateCreatedTime();

        void copyFrom(const DesignObject& object);
 
        //Adjusts this model's index based on models being deleted from the specified index
        void scale(Vector<3, fltp08> scale, Vertex<3, fltp08> center_of_scale = Constant<Vertex<3, fltp08>>::Invalid);

        void scale(Vector<3, fltp08> scale, Vertex<3, fltp08> center_of_scale, const Matrix<fltp08>& transform);

        void offsetDesign(const Vector<3, fltp08>& offset);

        bool hasMetaData(const StringView& index) const;

        [[nodiscard]] const JSONNode& metaData(const StringView& index) const;

        [[nodiscard]] const JSONNode& metaData() const;

        void setMetaData(const JSONNode& node);

        void setMetaData(const StringView& index, const JSONNode& node);

        void setMetaData(const StringView& index, const String& data);

        void setMetaData(const StringView& index, const StringView& data);

        void setMetaData(const StringView& index, const bool& data);

        void setMetaData(const StringView& index, const fltp08& data);

        void setMetaData(const StringView& index, const uint01& data);

        void setMetaData(const StringView& index, const uint04& data);

        void clearAllMetaData();

        void clearMetaData(const StringView& index);

        void updateMetaData(const StringView& index, const String& data, const void* lock_ptr = nullptr);

        void updateMetaData(const StringView& index, const StringView& data, const void* lock_ptr = nullptr);

        void updateMetaData(const StringView& index, const fltp08& data, const void* lock_ptr = nullptr);

        void updateMetaData(const StringView& index, const bool& data, const void* lock_ptr = nullptr);

        void removeMetaData(const StringView& index, const void* lock_ptr = nullptr);

        void appendData(const StringView& data, bool compressed);

        inline uint04 index() const { return m_index; }

        inline uint04 designIndex() const { return m_design_index; }

        [[nodiscard]] const Table& propertyTable() const;

        [[nodiscard]] Table& propertyTable();

        bool operator==(const DesignObject& object) const;

        bool operator!=(const DesignObject& object) const;

        bool operator<(const DesignObject& object) const;

        bool operator>(const DesignObject& object) const;

        operator bool() const { return isValid(); }

        [[nodiscard]] DesignObjectBase& base() const { return *m_base; }

        void updateDesignTransform(const Matrix<fltp08>& transform, const void* lock = nullptr);

        bool updateDesignVisible(bool is_visible, const void* lock = nullptr);

        [[nodiscard]] bool isValid() const { return IsValid(m_index); }

        [[nodiscard]] Scene getScene() const;

        [[nodiscard]] static constexpr StringView FilePathDesignNameVariable() { return "[DESIGN_NAME]"; }
    protected:
        void initDesignObject();

        template<class t_type>
        void _setProperty(NDPO property, const t_type& value)
        {
            m_base->design_properties[eint01(property)]->set(m_index, value);
        }
    };
#ifndef _DEBUG
    static_assert(sizeof(DesignObject) == 16, "DesignObject size incorrect");
#endif
    template class NDEVR_DESIGN_API StringStream<NDPO>;
    //static_assert(!std::is_polymorphic<DesignObject>(), "Model should not be polymorphic");

    template<>
    struct ObjectInfo<DesignObject, false, false>
    {
        static const uint01 Dimensions = 0;     
        static const bool Vector = false;       
        static const bool Buffer = false;       
        static const bool Primitive = true;     
        static const bool Pointer = false;      
        static const bool Unsigned = false;     
        static const bool Float = false;        
        static const bool Integer = false;      
        static const bool Number = false;       
        static const bool Enum = false;         
        static const bool String = false;       
        static const bool Color = false;        
        static const bool Boolean = false;      

        static constexpr ObjectInfo<DesignObject, false, false> VectorSub() { return ObjectInfo<DesignObject, false, false>(); }
    };
}
 
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<DesignObject>
    {
        std::size_t operator()(const DesignObject& d) const noexcept
        {
            UUID s = d.get<NDPO::guid>();
            std::size_t value = 0;
            for (uint01 i = 0; i < 8; i++)
            {
                value = value * 256 + (s[i + 0U] ^ s[i + 8U]);
            }
            return value;
        }
    };
};