Invoke.h File Reference

#include "uLang/Common/Common.h"
#include "uLang/Common/Templates/References.h"
#include "uLang/Common/Templates/TypeTraits.h"

Go to the source code of this file.

Classes
struct	uLang::Private::TVoid< T >
struct	uLang::Private::TIsInvocableImpl< typename, CallableType, ArgTypes >
struct	uLang::Private::TIsInvocableImpl< typename TVoid< decltype(uLang::Invoke(DeclVal< CallableType >(), DeclVal< ArgTypes >()...))>::Type, CallableType, ArgTypes... >
struct	uLang::TIsInvocable< CallableType, ArgTypes >

Namespaces
namespace	uLang
namespace	uLang::Private

Macros
#define	ULANG_PROJECTION(FuncName)
#define	ULANG_PROJECTION_MEMBER(Type, FuncName)

Functions
template<typename BaseType , typename CallableType >
ULANG_FORCEINLINE auto	uLang::Private::DereferenceIfNecessary (CallableType &&Callable) -> typename TEnableIf< TPointerIsConvertibleFromTo< typename TDecay< CallableType >::Type, typename TDecay< BaseType >::Type >::Value, decltype((CallableType &&) Callable)>::Type
template<typename FuncType , typename... ArgTypes>
ULANG_FORCEINLINE auto	uLang::Invoke (FuncType &&Func, ArgTypes &&... Args) -> decltype(uLang::ForwardArg< FuncType >(Func)(uLang::ForwardArg< ArgTypes >(Args)...))
template<typename ReturnType , typename ObjType , typename CallableType >
ULANG_FORCEINLINE auto	uLang::Invoke (ReturnType ObjType::*pdm, CallableType &&Callable) -> decltype(Private::DereferenceIfNecessary< ObjType >(uLang::ForwardArg< CallableType >(Callable)).*pdm)
template<typename ReturnType , typename ObjType , typename... PMFArgTypes, typename CallableType , typename... ArgTypes>
ULANG_FORCEINLINE auto	uLang::Invoke (ReturnType(ObjType::*PtrMemFun)(PMFArgTypes...), CallableType &&Callable, ArgTypes &&... Args) -> decltype((Private::DereferenceIfNecessary< ObjType >(uLang::ForwardArg< CallableType >(Callable)).*PtrMemFun)(uLang::ForwardArg< ArgTypes >(Args)...))
template<typename T >
T &&	uLang::Private::DeclVal ()

Macro Definition Documentation

ULANG_PROJECTION

#define ULANG_PROJECTION

(

FuncName

)

Value:

    [](auto&&... Args) \
    { \
        return FuncName(uLang::ForwardArg<decltype(Args)>(Args)...); \
    }

Wraps up a named non-member function so that it can easily be passed as a callable. This allows functions with overloads or default arguments to be treated correctly.

Example:

TArray<FMyType> Array = ...;

// Doesn't compile, because you can't take the address of an overloaded function when its type needs to be deduced. Algo::SortBy(Array, &LexToString);

// Works as expected Algo::SortBy(Array, PROJECTION(LexToString));

ULANG_PROJECTION_MEMBER

#define ULANG_PROJECTION_MEMBER	(		Type,
			FuncName
	)

Value:

    [](auto&& Obj, auto&&... Args) \
    { \
        return Private::DereferenceIfNecessary<Type>(uLang::ForwardArg<decltype(Obj)>(Obj)).FuncName(uLang::ForwardArg<decltype(Args)>(Args)...); \
    }

Wraps up a named member function so that it can easily be passed as a callable. This allows functions with overloads or default arguments to be treated correctly.

Example:

TArray<UObject*> Array = ...;

// Doesn't compile, because &UObject::GetFullName loses the default argument and passes // FString (UObject::*)(const UObject*) to Algo::SortBy<>(), which is not a valid projection. Algo::SortBy(Array, &UObject::GetFullName);

// Works as expected Algo::SortBy(Array, PROJECTION_MEMBER(UObject, GetFullName));