entityptr.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
#include "entity.h"
#include <rtti/objectptr.h>
 
namespace nap
{
    class EntityPtr
    {
    public:
        EntityPtr() = default;
 
        EntityPtr(Entity* entity) : mResource(entity)
        { }
 
        const std::string& getInstancePath() const                              { return mPath; }
 
        std::string toString() const                                            { return mPath; }
 
        Entity* toObject() const                                                { return mResource.get(); }
 
        void assign(const std::string& targetPath, rtti::Object* targetObject)  { mPath = targetPath; mResource = rtti_cast<Entity>(targetObject); }
 
        Entity* get() const                                                     { return mResource.get(); }
 
        Entity* get()                                                           { return mResource.get(); }
 
        static std::string translateTargetID(const std::string& targetID);
 
        const Entity& operator*() const                                         { assert(mResource != nullptr); return *mResource; }
 
        Entity& operator*()                                                     { assert(mResource != nullptr); return *mResource; }
 
        const Entity* operator->() const                                        { assert(mResource != nullptr); return mResource.get(); }
 
        Entity* operator->()                                                    { assert(mResource != nullptr); return mResource.get(); }
 
        bool operator==(const EntityPtr& other) const                           { return mResource == other.mResource; }
 
        bool operator==(std::nullptr_t) const                                   { return mResource == nullptr; }
 
        bool operator!=(const EntityPtr& other) const                           { return mResource != other.mResource; }
 
        bool operator!=(std::nullptr_t) const                                   { return mResource != nullptr; }
 
        bool operator<(const EntityPtr& other) const                            { return mResource < other.mResource; }
 
        bool operator>(const EntityPtr& other) const                            { return mResource > other.mResource; }
 
        bool operator<=(const EntityPtr& other) const                           { return mResource <= other.mResource; }
 
        bool operator>=(const EntityPtr& other) const                           { return mResource >= other.mResource; }
 
    private:
        rtti::ObjectPtr<Entity> mResource;      
        std::string             mPath;          
    };
 
 
    template<typename SourceComponentType>
    struct EntityInstancePtrInitProxy
    {
        ComponentInstance*                  mSourceComponentInstance;                       
        EntityPtr                           SourceComponentType::*mEntityMemberPointer;     
    };
 
    class EntityInstancePtr
    {
    public:
        EntityInstancePtr() = default;
 
        template<class SourceComponentType>
        EntityInstancePtr(ComponentInstance* sourceComponentInstance, EntityPtr(SourceComponentType::*entityMemberPointer))
        {
            SourceComponentType* resource = sourceComponentInstance->getComponent<SourceComponentType>();
            EntityPtr& target_entity_resource = resource->*entityMemberPointer;
            sourceComponentInstance->addToEntityLinkMap(target_entity_resource.get(), target_entity_resource.getInstancePath(), &mInstance);
        }
 
        template<class SourceComponentType>
        EntityInstancePtr(const EntityInstancePtrInitProxy<SourceComponentType>& proxy) :
            EntityInstancePtr(proxy.mSourceComponentInstance, proxy.mEntityMemberPointer)
        { }
 
        const EntityInstance& operator*() const                                 { assert(mInstance != nullptr); return *mInstance; }
 
        EntityInstance& operator*()                                             { assert(mInstance != nullptr); return *mInstance; }
 
        EntityInstance* operator->() const                                      { assert(mInstance != nullptr); return mInstance; }
 
        EntityInstance* operator->()                                            { assert(mInstance != nullptr); return mInstance; }
 
        bool operator==(const EntityInstancePtr& other) const                   { return mInstance == other.mInstance; }
 
        bool operator==(std::nullptr_t) const                                   { return mInstance == nullptr; }
 
        bool operator!=(const EntityInstancePtr& other) const                   { return mInstance != other.mInstance; }
 
        bool operator!=(std::nullptr_t) const                                   { return mInstance != nullptr; }
 
        bool operator<(const EntityInstancePtr& other) const                    { return mInstance < other.mInstance; }
 
        bool operator>(const EntityInstancePtr& other) const                    { return mInstance > other.mInstance; }
 
        bool operator<=(const EntityInstancePtr& other) const                   { return mInstance <= other.mInstance; }
 
        bool operator>=(const EntityInstancePtr& other) const                   { return mInstance >= other.mInstance; }
 
        EntityInstance* get() const                                             { return mInstance; }
 
        EntityInstance* get()                                                   { return mInstance; }
 
    private:
        template<typename SourceComponentType_>
        friend std::vector<EntityInstancePtr> initEntityInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<EntityPtr>(SourceComponentType_::*entityMemberPointer));
 
        EntityInstance* mInstance = nullptr;
    };
 
    template<typename SourceComponentType>
    EntityInstancePtrInitProxy<SourceComponentType> initEntityInstancePtr(ComponentInstance* sourceComponentInstance, EntityPtr(SourceComponentType::*entityMemberPointer));
 
    template<typename SourceComponentType>
    std::vector<EntityInstancePtr> initEntityInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<EntityPtr>(SourceComponentType::*entityMemberPointer));
}
 
 
// The following construct is required to support EntityPtr in RTTR as a regular pointer.
namespace rttr
{
    template<>
    struct wrapper_mapper<nap::EntityPtr>
    {
        using wrapped_type = nap::Entity*;
        using type = nap::EntityPtr;
        inline static wrapped_type get(const type& obj)         { return obj.get(); }
        inline static type create(const wrapped_type& value)    { return nap::EntityPtr(value); }
    };
}
 
 
// Template Definitions
namespace nap
{
    template<typename SourceComponentType>
    nap::EntityInstancePtrInitProxy<SourceComponentType>
        initEntityInstancePtr(ComponentInstance* sourceComponentInstance, EntityPtr(SourceComponentType::*entityMemberPointer))
    {
        return{ sourceComponentInstance, entityMemberPointer };
    }
 
 
    template<typename SourceComponentType>
    std::vector<nap::EntityInstancePtr>
        initEntityInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<EntityPtr>(SourceComponentType::*entityMemberPointer))
    {
        SourceComponentType* resource = sourceComponentInstance->getComponent<SourceComponentType>();
        std::vector<EntityPtr>& target_entity_resource = resource->*entityMemberPointer;
 
        std::vector<EntityInstancePtr> result;
        result.resize(target_entity_resource.size());
 
        for (int i = 0; i != result.size(); ++i)
            sourceComponentInstance->addToEntityLinkMap(target_entity_resource[i].get(), target_entity_resource[i].getInstancePath(), &result[i].mInstance);
 
        return result;
    }
 
}