componentptr.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 "component.h"
#include <rtti/typeinfo.h>
#include <rtti/objectptr.h>
 
namespace nap
{
    class ComponentPtrBase
    {
        RTTI_ENABLE();
    public:
        virtual ~ComponentPtrBase() = default;
 
        static std::string translateTargetID(const std::string& targetID);
 
        virtual std::string toString() const = 0;
 
        virtual Component* toObject() const = 0;
 
        virtual void assign(const std::string& targetPath, rtti::Object* targetObject) = 0;
    };
 
    template<class ComponentType>
    class ComponentPtr : public ComponentPtrBase
    {
        RTTI_ENABLE(ComponentPtrBase)
 
    public:
        // ctr
        ComponentPtr() = default;
 
        // ctr override
        ComponentPtr(ComponentType* component) : mResource(component)                               { }
 
        const std::string& getInstancePath() const                          { return mPath; }
 
        virtual std::string toString() const override                       { return mPath; }
 
        virtual Component* toObject() const override                        { return rtti_cast<nap::Component>(mResource.get()); }
 
        virtual void assign(const std::string& targetID, rtti::Object* targetObject) override;
 
        ComponentType* get() const                                          { return mResource.get(); }
 
        ComponentType* get()                                                { return mResource.get(); }
 
        const ComponentType& operator*() const                              { assert(mResource != nullptr); return *mResource; }
 
        ComponentType& operator*()                                          { assert(mResource != nullptr); return *mResource; }
 
        const ComponentType* operator->() const                             { assert(mResource != nullptr); return mResource.get(); }
 
        ComponentType* operator->()                                         { assert(mResource != nullptr); return mResource.get(); }
 
        bool operator==(const ComponentPtr<ComponentType>& other) const     { return mResource == other.mResource; }
 
        template<typename OTHER>
        bool operator==(const ComponentPtr<OTHER>& other) const             { return mResource == other.mResource; }
 
        template<typename OTHER>
        bool operator==(const OTHER* ptr) const                             { return mResource == ptr; }
 
        bool operator==(std::nullptr_t) const                               { return mResource == nullptr; }
 
        bool operator!=(const ComponentPtr<ComponentType>& other) const     { return mResource != other.mResource; }
 
        template<typename OTHER>
        bool operator!=(const ComponentPtr<OTHER>& other) const             { return mResource != other.mResource; }
 
        template<typename OTHER>
        bool operator!=(const OTHER* ptr) const                             { return mResource != ptr; }
 
        bool operator!=(std::nullptr_t) const                               { return mResource != nullptr; }
 
        bool operator<(const ComponentPtr<ComponentType>& other) const      { return mResource < other.mResource; }
 
        bool operator>(const ComponentPtr<ComponentType>& other) const      { return mResource > other.mResource; }
 
        bool operator<=(const ComponentPtr<ComponentType>& other) const     { return mResource <= other.mResource; }
 
        bool operator>=(const ComponentPtr<ComponentType>& other) const     { return mResource >= other.mResource; }
 
    private:
        rtti::ObjectPtr<ComponentType>  mResource;      
        std::string                     mPath;          
    };
 
    template<class ComponentType>
    void nap::ComponentPtr<ComponentType>::assign(const std::string& targetID, rtti::Object* targetObject)
    {
        mPath = targetID;
        mResource = rtti_cast<ComponentType>(targetObject);
    }
 
 
    template<typename TargetComponentType, typename SourceComponentType>
    struct ComponentInstancePtrInitProxy
    {
        ComponentInstance*                  mSourceComponentInstance;                       
        ComponentPtr<TargetComponentType>   SourceComponentType::*mComponentMemberPointer;  
    };
 
    template<class TargetComponentType>
    class ComponentInstancePtr
    {
    public:
        using TargetComponentInstanceType = typename TargetComponentType::InstanceType;
 
        ComponentInstancePtr() = default;
 
        template<class SourceComponentType>
        ComponentInstancePtr(ComponentInstance* sourceComponentInstance, ComponentPtr<TargetComponentType>(SourceComponentType::* componentMemberPointer))
        {
            SourceComponentType* resource = sourceComponentInstance->getComponent<SourceComponentType>();
            ComponentPtr<TargetComponentType>& target_component_resource = resource->*componentMemberPointer;
            sourceComponentInstance->addToComponentLinkMap(target_component_resource.get(), target_component_resource.getInstancePath(), (ComponentInstance**)&mInstance);
        }
 
        template<class SourceComponentType>
        ComponentInstancePtr(const ComponentInstancePtrInitProxy<TargetComponentType, SourceComponentType>& proxy) :
            ComponentInstancePtr(proxy.mSourceComponentInstance, proxy.mComponentMemberPointer)
        { }
 
        const TargetComponentInstanceType& operator*() const                            { assert(mInstance != nullptr); return *mInstance; }
 
        TargetComponentInstanceType& operator*()                                        { assert(mInstance != nullptr); return *mInstance; }
 
        TargetComponentInstanceType* operator->() const                                 { assert(mInstance != nullptr); return mInstance; }
 
        TargetComponentInstanceType* operator->()                                       { assert(mInstance != nullptr); return mInstance; }
 
        bool operator==(const ComponentInstancePtr<TargetComponentType>& other) const   { return mInstance == other.mPtr; }
 
        template<typename OTHER>
        bool operator==(const ComponentInstancePtr<OTHER>& other) const                 { return mInstance == other.mPtr; }
 
        template<typename OTHER>
        bool operator==(const OTHER* ptr) const                                         { return mInstance == ptr; }
 
        bool operator==(std::nullptr_t) const                                           { return mInstance == nullptr; }
 
        bool operator!=(const ComponentInstancePtr<TargetComponentType>& other) const   { return mInstance != other.mPtr; }
 
        template<typename OTHER>
        bool operator!=(const ComponentInstancePtr<OTHER>& other) const                 { return mInstance != other.mPtr; }
 
        template<typename OTHER>
        bool operator!=(const OTHER* ptr) const                                         { return mInstance != ptr; }
 
        bool operator!=(std::nullptr_t) const                                           { return mInstance != nullptr; }
 
        bool operator<(const ComponentInstancePtr<TargetComponentType>& other) const    { return mInstance < other.mInstance; }
 
        bool operator>(const ComponentInstancePtr<TargetComponentType>& other) const    { return mInstance > other.mInstance; }
 
        bool operator<=(const ComponentInstancePtr<TargetComponentType>& other) const   { return mInstance <= other.mInstance; }
 
        bool operator>=(const ComponentInstancePtr<TargetComponentType>& other) const   { return mInstance >= other.mInstance; }
 
        TargetComponentInstanceType* get() const                                        { return mInstance; }
 
        TargetComponentInstanceType* get()                                              { return mInstance; }
 
    private:
        template<typename TargetComponentType_, typename SourceComponentType_>
        friend std::vector<ComponentInstancePtr<TargetComponentType_>> initComponentInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<ComponentPtr<TargetComponentType_>>(SourceComponentType_::*componentMemberPointer));
 
    private:
        TargetComponentInstanceType* mInstance = nullptr;
    };
 
    template<typename TargetComponentType, typename SourceComponentType>
    ComponentInstancePtrInitProxy<TargetComponentType, SourceComponentType> initComponentInstancePtr(ComponentInstance* sourceComponentInstance, ComponentPtr<TargetComponentType>(SourceComponentType::*componentMemberPointer));
 
    template<typename TargetComponentType, typename SourceComponentType>
    std::vector<ComponentInstancePtr<TargetComponentType>> initComponentInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<ComponentPtr<TargetComponentType>>(SourceComponentType::*componentMemberPointer));
}
 
 
// The following construct is required to support ComponentPtr in RTTR as a regular pointer.
namespace rttr
{
    template<typename T>
    struct wrapper_mapper<nap::ComponentPtr<T>>
    {
        using wrapped_type = T*;
        using type = nap::ComponentPtr<T>;
        inline static wrapped_type get(const type& obj)         { return obj.get(); }
        inline static type create(const wrapped_type& value)    { return nap::ComponentPtr<T>(value); }
    };
}
 
 
namespace nap
{
    // Template definitions
 
    template<typename TargetComponentType, typename SourceComponentType>
    nap::ComponentInstancePtrInitProxy<TargetComponentType, SourceComponentType>
        initComponentInstancePtr(ComponentInstance* sourceComponentInstance, ComponentPtr<TargetComponentType>(SourceComponentType::*componentMemberPointer))
    {
        return{ sourceComponentInstance, componentMemberPointer };
    }
 
 
    template<typename TargetComponentType, typename SourceComponentType>
    std::vector<nap::ComponentInstancePtr<TargetComponentType>>
        initComponentInstancePtr(ComponentInstance* sourceComponentInstance, std::vector<ComponentPtr<TargetComponentType>>(SourceComponentType::*componentMemberPointer))
    {
        SourceComponentType* resource = sourceComponentInstance->getComponent<SourceComponentType>();
        std::vector<ComponentPtr<TargetComponentType>>& target_component_resource = resource->*componentMemberPointer;
 
        std::vector<ComponentInstancePtr<TargetComponentType>> result;
        result.resize(target_component_resource.size());
 
        for (int i = 0; i != result.size(); ++i)
            sourceComponentInstance->addToComponentLinkMap(target_component_resource[i].get(), target_component_resource[i].getInstancePath(), (ComponentInstance**)&result[i].mInstance);
 
        return result;
    }
}