ScriptInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ScriptInterface.h: Script interface definitions.
=============================================================================*/
 
#pragma once
 
#include "UObject/UObjectGlobals.h"
#include "Templates/Casts.h"
#include "Templates/UnrealTemplate.h"
 
#include <type_traits>
 
class FScriptInterface
{
private:
    TObjectPtr<UObject> ObjectPointer = nullptr;
 
    void*       InterfacePointer = nullptr;
 
protected:
    COREUOBJECT_API FArchive& Serialize(FArchive& Ar, class UClass* InterfaceType);
 
public:
    FScriptInterface() = default;
 
    FScriptInterface( UObject* InObjectPointer, void* InInterfacePointer )
    : ObjectPointer(InObjectPointer), InterfacePointer(InInterfacePointer)
    {}
 
    FScriptInterface(const FScriptInterface&) = default;
    FScriptInterface& operator=(const FScriptInterface&) = default;
 
    UE_FORCEINLINE_HINT UObject* GetObject() const
    {
        return ObjectPointer;
    }
 
    UE_FORCEINLINE_HINT TObjectPtr<UObject>& GetObjectRef()
    {
        return ObjectPointer;
    }
 
    UE_FORCEINLINE_HINT void* GetInterface() const
    {
        // Only access the InterfacePointer if we have a valid ObjectPointer. This is necessary because garbage collection may only clear the ObjectPointer.
        // This will also return null for objects that only implement the interface in a blueprint class because there is no native representation.
        return ObjectPointer ? InterfacePointer : nullptr;
    }
 
    inline void SetObject( UObject* InObjectPointer )
    {
        ObjectPointer = InObjectPointer;
        if ( ObjectPointer == nullptr )
        {
            SetInterface(nullptr);
        }
    }
 
    UE_FORCEINLINE_HINT void SetInterface( void* InInterfacePointer )
    {
        InterfacePointer = InInterfacePointer;
    }
 
    UE_FORCEINLINE_HINT bool operator==( const FScriptInterface& Other ) const
    {
        return GetInterface() == Other.GetInterface() && ObjectPointer == Other.GetObject();
    }
    UE_FORCEINLINE_HINT bool operator!=( const FScriptInterface& Other ) const
    {
        return GetInterface() != Other.GetInterface() || ObjectPointer != Other.GetObject();
    }
 
    void AddReferencedObjects(FReferenceCollector& Collector)
    {
        Collector.AddReferencedObject(ObjectPointer);
    }
 
    friend inline uint32 GetTypeHash(const FScriptInterface& Instance)
    {
        return GetTypeHash(Instance.InterfacePointer);
    }
};
 
 
 
template<> struct TIsPODType<class FScriptInterface> { enum { Value = true }; };
template<> struct TIsZeroConstructType<class FScriptInterface> { enum { Value = true }; };
 
template <typename InInterfaceType>
class TScriptInterface : public FScriptInterface
{
public:
    using InterfaceType = InInterfaceType;
    using UObjectType = TCopyQualifiersFromTo_T<InterfaceType, UObject>;
 
    TScriptInterface() = default;
 
    TScriptInterface(TYPE_OF_NULLPTR) {}
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U, UObjectType*>)
    >
    inline TScriptInterface(U&& Source)
    {
        // Always set the object
        UObjectType* SourceObject = ImplicitConv<UObjectType*>(Source);
        SetObject(SourceObject);
 
        if constexpr (std::is_base_of<InInterfaceType, std::remove_pointer_t<std::remove_reference_t<U>>>::value)
        {
            // If we know at compile time that we got passed some subclass of InInterfaceType, set it
            // without a cast (avoiding the cast also allows us to not require linking to its module)
            SetInterface(Source);
        }
        else
        {
            // Tries to set the native interface instance, this will set it to null for BP-implemented interfaces
            InInterfaceType* SourceInterface = Cast<InInterfaceType>(SourceObject);
            SetInterface(SourceInterface);
        }
    }
 
    template <
        typename OtherInterfaceType
        UE_REQUIRES(std::is_convertible_v<OtherInterfaceType*, InInterfaceType*>)
    >
    inline TScriptInterface(const TScriptInterface<OtherInterfaceType>& Other)
    {
        SetObject(Other.GetObject());
 
        InInterfaceType* SourceInterface = Other.GetInterface();
        SetInterface(SourceInterface);
    }
 
    template <typename ObjectType>
    TScriptInterface(TObjectPtr<ObjectType> SourceObject)
    {
        // Always set the object
        SetObject(SourceObject);
 
        if constexpr (std::is_base_of<InInterfaceType, ObjectType>::value)
        {
            // If we know at compile time that we got passed some subclass of InInterfaceType, set it
            // without a cast (avoiding the cast also allows us to not require linking to its module)
            SetInterface(SourceObject.Get());
        }
        else
        {
            // Tries to set the native interface instance, this will set it to null for BP-implemented interfaces
            InInterfaceType* SourceInterface = Cast<InInterfaceType>(ToRawPtr(SourceObject));
            SetInterface(SourceInterface);
        }
    }
 
    TScriptInterface(const TScriptInterface&) = default;
    TScriptInterface& operator=(const TScriptInterface&) = default;
 
    TScriptInterface& operator=(TYPE_OF_NULLPTR)
    {
        *this = TScriptInterface();
        return *this;
    }
 
    template <
        typename U
        UE_REQUIRES(std::is_convertible_v<U, UObjectType*>)
    >
    TScriptInterface& operator=(U&& Source)
    {
        *this = TScriptInterface(Source);
        return *this;
    }
 
    template <
        typename OtherInterfaceType
        UE_REQUIRES(std::is_convertible_v<OtherInterfaceType*, InInterfaceType*>)
    >
    TScriptInterface& operator=(const TScriptInterface<OtherInterfaceType>& Other)
    {
        *this = TScriptInterface(Other);
        return *this;
    }
 
    template <typename ObjectType>
    TScriptInterface& operator=(TObjectPtr<ObjectType> SourceObject)
    {
        *this = TScriptInterface(SourceObject);
        return *this;
    }
 
    template <
        typename OtherInterface
        UE_REQUIRES(std::is_convertible_v<OtherInterface*, InInterfaceType*>)
    >
    UE_FORCEINLINE_HINT bool operator==( const OtherInterface* Other ) const
    {
        return GetInterface() == Other;
    }
    template <
        typename OtherInterface
        UE_REQUIRES(std::is_convertible_v<OtherInterface*, InInterfaceType*>)
    >
    UE_FORCEINLINE_HINT bool operator!=( const OtherInterface* Other ) const
    {
        return GetInterface() != Other;
    }
 
    UE_FORCEINLINE_HINT bool operator==( const TScriptInterface& Other ) const
    {
        return GetInterface() == Other.GetInterface() && GetObject() == Other.GetObject();
    }
    UE_FORCEINLINE_HINT bool operator!=( const TScriptInterface& Other ) const
    {
        return GetInterface() != Other.GetInterface() || GetObject() != Other.GetObject();
    }
 
    UE_FORCEINLINE_HINT bool operator==(TYPE_OF_NULLPTR) const
    {
        return GetInterface() == nullptr;
    }
    UE_FORCEINLINE_HINT bool operator!=(TYPE_OF_NULLPTR) const
    {
        return GetInterface() != nullptr;
    }
 
    UE_FORCEINLINE_HINT InInterfaceType* operator->() const
    {
        return GetInterface();
    }
 
    UE_FORCEINLINE_HINT InInterfaceType& operator*() const
    {
        return *GetInterface();
    }
 
    UE_FORCEINLINE_HINT InInterfaceType* GetInterface() const
    {
        return (InInterfaceType*)FScriptInterface::GetInterface();
    }
 
    UE_FORCEINLINE_HINT void SetInterface(InInterfaceType* InInterfacePointer)
    {
        FScriptInterface::SetInterface((void*)InInterfacePointer);
    }
 
    UE_FORCEINLINE_HINT UObjectType* GetObject() const
    {
        return FScriptInterface::GetObject();
    }
 
    UE_FORCEINLINE_HINT TObjectPtr<UObjectType>& GetObjectRef()
    {
        return *(TObjectPtr<UObjectType>*)&FScriptInterface::GetObjectRef();
    }
 
    UE_FORCEINLINE_HINT void SetObject( UObjectType* InObjectPointer )
    {
        FScriptInterface::SetObject(const_cast<UObject*>(InObjectPointer));
    }
 
    UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return GetInterface() != nullptr;
    }
 
    friend FArchive& operator<<( FArchive& Ar, TScriptInterface& Interface )
    {
        return Interface.Serialize(Ar, InInterfaceType::UClassType::StaticClass());
    }
};
 
template <typename InterfaceType>
struct TCallTraits<TScriptInterface<InterfaceType>> : public TCallTraitsBase<TScriptInterface<InterfaceType>>
{
    using ConstPointerType = TScriptInterface<const InterfaceType>;
};