Delegate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "UObject/NameTypes.h"
#include "Templates/SharedPointer.h"
#include "UObject/WeakObjectPtrTemplates.h"
#include "Delegates/MulticastDelegateBase.h" // IWYU pragma: export
#include "Delegates/IntegerSequence.h" // IWYU pragma: export
#include "AutoRTFM.h"
 
#define HEADER_GENERATED_DELEGATE_SIGNATURE_SUFFIX TEXT("__DelegateSignature")
 
#define FUNC_CONCAT( ... ) __VA_ARGS__
 
#define FUNC_DECLARE_DELEGATE( DelegateName, ReturnType, ... ) \
    typedef TDelegate<ReturnType(__VA_ARGS__)> DelegateName;
 
#define FUNC_DECLARE_MULTICAST_DELEGATE( MulticastDelegateName, ReturnType, ... ) \
    typedef TMulticastDelegate<ReturnType(__VA_ARGS__)> MulticastDelegateName;
 
#define FUNC_DECLARE_TS_MULTICAST_DELEGATE( MulticastDelegateName, ReturnType, ... ) \
    typedef TMulticastDelegate<ReturnType(__VA_ARGS__), FDefaultTSDelegateUserPolicy> MulticastDelegateName;
 
#define FUNC_DECLARE_EVENT( OwningType, EventName, ReturnType, ... ) \
    class EventName : public TMulticastDelegate<ReturnType(__VA_ARGS__)> \
    { \
        friend class OwningType; \
    };
 
#define DECLARE_DERIVED_EVENT( OwningType, BaseTypeEvent, EventName ) \
    class EventName : public BaseTypeEvent { friend class OwningType; };
 
#define FUNC_DECLARE_DYNAMIC_DELEGATE( DynamicDelegateClassName, ExecFunction, FuncParamList, FuncParamPassThru, ... ) \
    class DynamicDelegateClassName : public TBaseDynamicDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__> \
    { \
    public: \
 \
        DynamicDelegateClassName() \
        { \
        } \
        \
 \
        explicit DynamicDelegateClassName( const TScriptDelegate<>& InScriptDelegate ) \
            : TBaseDynamicDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__>( InScriptDelegate ) \
        { \
        } \
        \
 \
        inline void Execute( FuncParamList ) const \
        { \
            /* Verify that the user object is still valid.  We only have a weak reference to it. */ \
            checkSlow( IsBound() ); \
            ExecFunction( FuncParamPassThru ); \
        } \
 \
        inline bool ExecuteIfBound( FuncParamList ) const \
        { \
            if( IsBound() ) \
            { \
                ExecFunction( FuncParamPassThru ); \
                return true; \
            } \
            return false; \
        } \
    };
 
#define FUNC_DECLARE_DYNAMIC_DELEGATE_RETVAL(DynamicDelegateRetValClassName, ExecFunction, RetValType, FuncParamList, FuncParamPassThru, ...) \
    class DynamicDelegateRetValClassName : public TBaseDynamicDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__> \
    { \
    public: \
 \
        DynamicDelegateRetValClassName() \
        { \
        } \
        \
 \
        explicit DynamicDelegateRetValClassName( const TScriptDelegate<>& InScriptDelegate ) \
            : TBaseDynamicDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__>( InScriptDelegate ) \
        { \
        } \
        \
 \
        inline RetValType Execute( FuncParamList ) const \
        { \
            /* Verify that the user object is still valid.  We only have a weak reference to it. */ \
            checkSlow( IsBound() ); \
            return ExecFunction( FuncParamPassThru ); \
        } \
    };
 
 
#define FUNC_DECLARE_DYNAMIC_MULTICAST_DELEGATE(DynamicMulticastDelegateClassName, ExecFunction, FuncParamList, FuncParamPassThru, ...) \
class DynamicMulticastDelegateClassName : public TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__> \
    { \
    public: \
 \
        DynamicMulticastDelegateClassName() \
        { \
        } \
        \
 \
        explicit DynamicMulticastDelegateClassName( const TMulticastScriptDelegate<>& InMulticastScriptDelegate ) \
            : TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, __VA_ARGS__>( InMulticastScriptDelegate ) \
        { \
        } \
        \
 \
        void Broadcast( FuncParamList ) const \
        { \
            ExecFunction( FuncParamPassThru ); \
        } \
    };
 
 
#define ENABLE_STATIC_FUNCTION_FNAMES (PLATFORM_COMPILER_CLANG && (__clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 5)))
 
#if ENABLE_STATIC_FUNCTION_FNAMES
 
    namespace NStrAfterLastDoubleColon_Private
    {
        template <typename T>
        struct TTypedImpl
        {
            // Dummy bool parameter needed so that we can ensure the last specialization is partial
            template <bool Dummy, T... Chars>
            struct Inner;
 
            template <typename SecondMatch, T... Chars>
            struct Inner2
            {
                typedef typename TTypedImpl<T>::template Inner<true, Chars...>::Type Type;
            };
 
            template <T... Chars>
            struct Inner2<TIntegerSequence<T>, Chars...>
            {
                typedef TIntegerSequence<T, Chars...> Type;
            };
 
            template <bool Dummy, T Char, T... Chars>
            struct Inner<Dummy, Char, Chars...>
            {
                typedef typename Inner<Dummy, Chars...>::Type Type;
            };
 
            template <bool Dummy, T... Chars>
            struct Inner<Dummy, ':', ':', Chars...>
            {
                typedef typename Inner2<typename Inner<Dummy, Chars...>::Type, Chars...>::Type Type;
            };
 
            // Without the dummy bool parameter, this would not compile, as full specializations
            // of nested class templates is not allowed.
            template <bool Dummy>
            struct Inner<Dummy>
            {
                typedef TIntegerSequence<T> Type;
            };
        };
 
 
        template <typename IntSeq>
        struct TStaticFNameFromCharSequence;
 
        template <typename T, T... Chars>
        struct TStaticFNameFromCharSequence<TIntegerSequence<T, Chars...>>
        {
            static FName Get()
            {
                static const T Str[sizeof...(Chars) + 1] = { Chars..., 0 };
                FName* Result = nullptr;
                UE_AUTORTFM_OPEN
                {
                    static FName StaticResult{Str};
                    Result = &StaticResult;
                };
                return *Result;
            }
        };
 
        template <typename T>
        struct TStrAfterLastDoubleColon;
 
        template <typename T, T... Chars>
        struct TStrAfterLastDoubleColon<TIntegerSequence<T, Chars...>>
        {
            typedef typename NStrAfterLastDoubleColon_Private::TTypedImpl<T>::template Inner<true, Chars...>::Type Type;
        };
    }
 
    template <typename T, T... Chars>
    UE_FORCEINLINE_HINT constexpr TIntegerSequence<T, Chars...> operator""_intseq()
    {
        return {};
    }
 
    #define STATIC_FUNCTION_FNAME(str) NStrAfterLastDoubleColon_Private::TStaticFNameFromCharSequence<typename NStrAfterLastDoubleColon_Private::TStrAfterLastDoubleColon<decltype(PREPROCESSOR_JOIN(str, _intseq))>::Type>::Get()
 
#else
 
    #define STATIC_FUNCTION_FNAME(str) UE::Delegates::Private::GetTrimmedMemberFunctionName(str)
 
#endif
 
 
#define BindDynamic( UserObject, FuncName ) __Internal_BindDynamic( UserObject, FuncName, STATIC_FUNCTION_FNAME( #FuncName ) )
 
#define AddDynamic( UserObject, FuncName ) __Internal_AddDynamic( UserObject, FuncName, STATIC_FUNCTION_FNAME( #FuncName ) )
 
#define AddUniqueDynamic( UserObject, FuncName ) __Internal_AddUniqueDynamic( UserObject, FuncName, STATIC_FUNCTION_FNAME( #FuncName ) )
 
#define RemoveDynamic( UserObject, FuncName ) __Internal_RemoveDynamic( UserObject, FuncName, STATIC_FUNCTION_FNAME( #FuncName ) )
 
#define IsAlreadyBound( UserObject, FuncName ) __Internal_IsAlreadyBound( UserObject, FuncName, STATIC_FUNCTION_FNAME( #FuncName ) )
 
 
namespace UE::Delegates::Private
{
    inline FName GetTrimmedMemberFunctionName(const ANSICHAR* InMacroFunctionName)
    {
        // We strip off the class prefix and just return the function name by itself.
        check(InMacroFunctionName);
        const ANSICHAR* Result = FCStringAnsi::Strrstr( InMacroFunctionName,  "::" );
        checkf(Result && Result[2] != '0', TEXT("'%hs' does not look like a member function"), InMacroFunctionName);
        return FName(Result + 2);
    }
}
 
 
/*********************************************************************************************************************/
 
// We define this as a guard to prevent DelegateSignatureImpl.inl being included outside of this file
#define __Delegate_h__
#define FUNC_INCLUDING_INLINE_IMPL
 
#if !UE_BUILD_DOCS
    #include "Delegates/DelegateInstanceInterface.h"
    #include "Delegates/DelegateInstancesImpl.h"
    #include "Delegates/DelegateSignatureImpl.inl" // IWYU pragma: export
    #include "Delegates/DelegateCombinations.h" // IWYU pragma: export
#endif
 
// No longer allowed to include DelegateSignatureImpl.inl
#undef FUNC_INCLUDING_INLINE_IMPL
#undef __Delegate_h__
 
/*********************************************************************************************************************/
 
// Simple delegate used by various utilities such as timers
DECLARE_DELEGATE( FSimpleDelegate );
DECLARE_MULTICAST_DELEGATE( FSimpleMulticastDelegate );
DECLARE_TS_MULTICAST_DELEGATE( FTSSimpleMulticastDelegate );