Attribute.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/TVariant.h"
#include "Templates/Function.h"
#include "Templates/Identity.h"
#include "Templates/SharedPointer.h"
#include "Delegates/Delegate.h"
 
template< typename ObjectType >
class TAttribute
{
 
public:
 
    DECLARE_DELEGATE_RetVal( ObjectType, FGetter );
 
 
    TAttribute()
        : Value()         // NOTE: Potentially uninitialized for atomics!!
        , bIsSet(false)
        , Getter()
    {
    }
 
    template< typename OtherType >
    TAttribute( const OtherType& InInitialValue )
        : Value( static_cast<ObjectType>(InInitialValue) )
        , bIsSet(true)
        , Getter()
    {
    }
 
    TAttribute( ObjectType&& InInitialValue)
        : Value(MoveTemp(InInitialValue))
        , bIsSet(true)
        , Getter()
    {
    }
 
    template< class SourceType >
    TAttribute( TSharedRef< SourceType > InUserObject, typename FGetter::template TConstMethodPtr< SourceType > InMethodPtr )
        : Value()
        , bIsSet(true)
        , Getter(FGetter::CreateSP(InUserObject, InMethodPtr))
    {
    }
 
    template< class SourceType >
    TAttribute( SourceType* InUserObject, typename FGetter::template TConstMethodPtr< SourceType > InMethodPtr )
        : Value()
        , bIsSet(true)
        , Getter(FGetter::CreateSP(InUserObject, InMethodPtr))
    {
    }
 
    [[nodiscard]] static TAttribute Create( const FGetter& InGetter )
    {
        const bool bExplicitConstructor = true;
        return TAttribute( InGetter, bExplicitConstructor );
    }
 
    [[nodiscard]] static TAttribute Create(FGetter&& InGetter)
    {
        const bool bExplicitConstructor = true;
        return TAttribute(MoveTemp(InGetter), bExplicitConstructor);
    }
 
    template <typename FuncPtrType, typename... VarTypes >
    [[nodiscard]] static TAttribute CreateStatic(FuncPtrType&& InFuncPtr, VarTypes... Vars)
    {
        const bool bExplicitConstructor = true;
        return TAttribute(FGetter::CreateStatic(InFuncPtr, MoveTemp(Vars)...), bExplicitConstructor);
    }
 
    template<typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateRaw(const SourceType* InObject, ObjectType (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type... InputPayload)
    {
        return Create(FGetter::CreateRaw(InObject, InMethod, MoveTemp(InputPayload)...));
    }
 
    template<typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateSP(const SourceType* InObject, ObjectType (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type... InputPayload)
    {
        return Create(FGetter::CreateSP(InObject, InMethod, MoveTemp(InputPayload)...));
    }
 
    template<typename LambdaType, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateLambda(LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        return Create(FGetter::CreateLambda(Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
    }
 
    template<typename UserClass, ESPMode Mode, typename LambdaType, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateSPLambda(const TSharedRef<UserClass, Mode>& InUserObjectRef, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        return Create(FGetter::CreateSPLambda(InUserObjectRef, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
    }
    template <typename UserClass, typename LambdaType, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateSPLambda(UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        return Create(FGetter::CreateSPLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
    }
 
    template <typename UserClass, typename LambdaType, typename... PayloadTypes>
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute CreateWeakLambda(UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        return Create(FGetter::CreateWeakLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
    }
 
    template< class SourceType >
    [[nodiscard]] static TAttribute< ObjectType > Create(SourceType* InUserObject, const FName& InFunctionName)
    {
        TAttribute< ObjectType > Attrib;
        Attrib.BindUFunction<SourceType>(InUserObject, InFunctionName);
        return Attrib;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT static TAttribute< ObjectType > Create(TFunction<ObjectType(void)>&& InLambda)
    {
        return Create(TAttribute< ObjectType >::FGetter::CreateLambda(MoveTemp(InLambda)));
    }
 
    template< typename OtherType >
    void Set( const OtherType& InNewValue )
    {
        Getter.Unbind();
        Value = InNewValue;
        bIsSet = true;
    }
 
    void Set( ObjectType&& InNewValue )
    {
        Getter.Unbind();
        Value = MoveTemp(InNewValue);
        bIsSet = true;
    }
 
    bool IsSet() const
    {
        return bIsSet;
    }
 
    const ObjectType& Get() const
    {
        // If we have a getter delegate, then we'll call that to generate the value
        if( Getter.IsBound() )
        {
            // Call the delegate to get the value.  Note that this will assert if the delegate is not currently
            // safe to call (e.g. object was deleted and we could detect that)
 
            // NOTE: We purposely overwrite our value copy here so that we can return the value by address in
            // the most common case, which is an attribute that doesn't have a delegate bound to it at all.
            Value = Getter.Execute();
        }
 
        // Return the stored value
        return Value;
    }
 
    const ObjectType& Get( const ObjectType& DefaultValue ) const
    {
        return bIsSet ? Get() : DefaultValue;
    }
 
    void Bind( const FGetter& InGetter )
    {
        bIsSet = true;
        Getter = InGetter;
    }
    
 
    void Bind( FGetter&& InGetter )
    {
        bIsSet = true;
        Getter = MoveTemp(InGetter);
    }
 
    template < typename... VarTypes >
    void BindStatic( TIdentity_T< typename FGetter::template TFuncPtr< std::decay_t<VarTypes>... > > InFuncPtr, VarTypes&&... Vars )
    {
        bIsSet = true;
        Getter.BindStatic( InFuncPtr, Forward<VarTypes>(Vars)... );
    }
    
    template< class SourceType, typename... VarTypes >
    void BindRaw( SourceType* InUserObject, typename FGetter::template TConstMethodPtr< SourceType, std::decay_t<VarTypes>... > InMethodPtr, VarTypes&&... Vars )
    {
        bIsSet = true;
        Getter.BindRaw( InUserObject, InMethodPtr, Forward<VarTypes>(Vars)... );
    }
 
    template< class SourceType, typename... VarTypes >
    void Bind( TSharedRef< SourceType > InUserObject, typename FGetter::template TConstMethodPtr< SourceType, std::decay_t<VarTypes>... > InMethodPtr, VarTypes&&... Vars )
    {
        bIsSet = true;
        Getter.BindSP( InUserObject, InMethodPtr, Forward<VarTypes>(Vars)... );
    }
 
    template< class SourceType, typename... VarTypes >
    void Bind( SourceType* InUserObject, typename FGetter::template TConstMethodPtr< SourceType, std::decay_t<VarTypes>... > InMethodPtr, VarTypes&&... Vars )
    {
        bIsSet = true;
        Getter.BindSP( InUserObject, InMethodPtr, Forward<VarTypes>(Vars)... );
    }
 
    template< class SourceType, typename... VarTypes >  
    void BindUObject( SourceType* InUserObject, typename FGetter::template TConstMethodPtr< SourceType, std::decay_t<VarTypes>... > InMethodPtr, VarTypes&&... Vars)
    {
        bIsSet = true;
        Getter.BindUObject( InUserObject, InMethodPtr, Forward<VarTypes>(Vars)... );
    }
 
    template< class SourceType >
    void BindUFunction( SourceType* InUserObject, const FName& InFunctionName )
    {
        bIsSet = true;
        Getter.BindUFunction(InUserObject, InFunctionName);
    }
 
    template<typename LambdaType, typename... PayloadTypes>
    inline void BindLambda(LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        bIsSet = true;
        Getter.BindLambda(Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...);
    }
 
    template<typename UserClass, ESPMode Mode, typename LambdaType, typename... PayloadTypes>
    inline void BindSPLambda(const TSharedRef<UserClass, Mode>& InUserObjectRef, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        bIsSet = true;
        Getter.BindSPLambda(InUserObjectRef, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...);
    }
    template <typename UserClass, typename LambdaType, typename... PayloadTypes>
    inline void BindSPLambda(const UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        bIsSet = true;
        Getter.BindSPLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...);
    }
 
    template<typename UserClass, typename LambdaType, typename... PayloadTypes>
    inline void BindWeakLambda(UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
    {
        bIsSet = true;
        Getter.BindWeakLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...);
    }
 
    bool IsBound() const
    {
        return Getter.IsBound();
    }
 
    [[nodiscard]] const FGetter& GetBinding() const
    {
        return Getter;
    }
 
    [[nodiscard]] TVariant<ObjectType, FGetter> Steal()
    {
        checkf(IsSet(), TEXT("It is an error to call Steal() on an unset TAttribute. Check IsSet() before calling Steal()."));
        bIsSet = false;
        return IsBound() ? TVariant<ObjectType, FGetter>(TInPlaceType<FGetter>(), MoveTemp(Getter)) : TVariant<ObjectType, FGetter>(TInPlaceType<ObjectType>(), MoveTemp(Value));
    }
 
    bool IdenticalTo(const TAttribute& InOther) const
    {
        const bool bIsBound = IsBound();
 
        if ( bIsBound == InOther.IsBound() )
        {
            if ( bIsBound )
            {
                return Getter.GetHandle() == InOther.Getter.GetHandle();
            }
            else
            {
                return IsSet() == InOther.IsSet() && Value == InOther.Value;
            }
        }
 
        return false;
    }
 
private:
 
    TAttribute( const FGetter& InGetter, bool bExplicitConstructor )
        : Value()       
        , bIsSet( true )
        , Getter(InGetter)
    { }
 
    TAttribute(FGetter&& InGetter, bool bExplicitConstructor)
        : Value()
        , bIsSet(true)
        , Getter(MoveTemp(InGetter))
    { }
 
    // We declare ourselves as a friend (templated using OtherType) so we can access members as needed
    template< class OtherType > friend class TAttribute;
 
    mutable ObjectType Value;
 
    bool bIsSet;
 
    FGetter Getter;
};
 
 
template<typename T, typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
[[nodiscard]] UE_FORCEINLINE_HINT TAttribute<T> MakeAttributeRaw(const SourceType* InObject, T (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type... InputPayload)
{
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateRaw(InObject, InMethod, MoveTemp(InputPayload)...));
}
 
template<typename T, typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
[[nodiscard]] UE_FORCEINLINE_HINT TAttribute<T> MakeAttributeSP(const SourceType* InObject, T (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type...  InputPayload)
{
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateSP(InObject, InMethod, MoveTemp(InputPayload)...));
}
template<typename T, typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
[[nodiscard]] UE_FORCEINLINE_HINT TAttribute<T> MakeAttributeSP(TSharedRef<SourceType> InObject, T (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type...  InputPayload)
{
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateSP(InObject, InMethod, MoveTemp(InputPayload)...));
}
 
template<typename T, typename SourceType, typename SourceTypeOrBase, typename... PayloadTypes>
[[nodiscard]] UE_FORCEINLINE_HINT TAttribute<T> MakeAttributeUObject(const SourceType* InObject, T (SourceTypeOrBase::*InMethod)(PayloadTypes...) const, typename TDecay<PayloadTypes>::Type... InputPayload)
{
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateUObject(InObject, InMethod, MoveTemp(InputPayload)...));
}
 
template<typename LambdaType, typename... PayloadTypes>
[[nodiscard]] decltype(auto) MakeAttributeLambda(LambdaType&& InCallable, PayloadTypes&&... InputPayload)
{
    typedef decltype(InCallable(DeclVal<PayloadTypes>()...)) T;
 
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateLambda(Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
}
 
template<typename UserClass, ESPMode Mode, typename LambdaType, typename... PayloadTypes>
[[nodiscard]] decltype(auto) MakeAttributeSPLambda(const TSharedRef<UserClass, Mode>& InUserObjectRef, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
{
    typedef decltype(InCallable(DeclVal<PayloadTypes>()...)) T;
 
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateSPLambda(InUserObjectRef, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
}
template <typename UserClass, typename LambdaType, typename... PayloadTypes>
[[nodiscard]] decltype(auto) MakeAttributeSPLambda(UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
{
    typedef decltype(InCallable(DeclVal<PayloadTypes>()...)) T;
 
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateSPLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
}
 
template <typename UserClass, typename LambdaType, typename... PayloadTypes>
[[nodiscard]] decltype(auto) MakeAttributeWeakLambda(UserClass* InUserObject, LambdaType&& InCallable, PayloadTypes&&... InputPayload)
{
    typedef decltype(InCallable(DeclVal<PayloadTypes>()...)) T;
 
    return TAttribute<T>::Create(TAttribute<T>::FGetter::CreateWeakLambda(InUserObject, Forward<LambdaType>(InCallable), Forward<PayloadTypes>(InputPayload)...));
}