Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#ifndef QOBJECTDEFS_H
#error Do not include qobjectdefs_impl.h directly
#include <QtCore/qnamespace.h>
#endif
#if 0
#pragma qt_sync_skip_header_check
#pragma qt_sync_stop_processing
#endif
#include <QtCore/qfunctionaltools_impl.h>
#include <memory>
QT_BEGIN_NAMESPACE
class QObject;
class QObjectPrivate;
class QMetaMethod;
class QByteArray;
namespace QtPrivate {
template <typename T> struct RemoveRef { typedef T Type; };
template <typename T> struct RemoveRef<T&> { typedef T Type; };
template <typename T> struct RemoveConstRef { typedef T Type; };
template <typename T> struct RemoveConstRef<const T&> { typedef T Type; };
/*
The following List classes are used to help to handle the list of arguments.
It follow the same principles as the lisp lists.
List_Left<L,N> take a list and a number as a parameter and returns (via the Value typedef,
the list composed of the first N element of the list
*/
// With variadic template, lists are represented using a variadic template argument instead of the lisp way
template <typename... Ts> struct List { static constexpr size_t size = sizeof...(Ts); };
template<typename T> struct SizeOfList { static constexpr size_t value = 1; };
template<> struct SizeOfList<List<>> { static constexpr size_t value = 0; };
template<typename ...Ts> struct SizeOfList<List<Ts...>> { static constexpr size_t value = List<Ts...>::size; };
template <typename Head, typename... Tail> struct List<Head, Tail...> {
static constexpr size_t size = 1 + sizeof...(Tail);
typedef Head Car; typedef List<Tail...> Cdr;
};
template <typename, typename> struct List_Append;
template <typename... L1, typename...L2> struct List_Append<List<L1...>, List<L2...>> { typedef List<L1..., L2...> Value; };
template <typename L, int N> struct List_Left {
typedef typename List_Append<List<typename L::Car>,typename List_Left<typename L::Cdr, N - 1>::Value>::Value Value;
};
template <typename L> struct List_Left<L, 0> { typedef List<> Value; };
/*
This is used to store the return value from a slot, whether the caller
wants to store this value (QMetaObject::invokeMethod() with
qReturnArg() or non-void signal ) or not.
*/
struct FunctorCallBase
{
template <typename R, typename Lambda>
static void call_internal([[maybe_unused]] void **args, Lambda &&fn)
noexcept(std::is_nothrow_invocable_v<Lambda>)
{
if constexpr (std::is_void_v<R> || std::is_void_v<std::invoke_result_t<Lambda>>) {
std::forward<Lambda>(fn)();
} else {
if (args[0])
*reinterpret_cast<R *>(args[0]) = std::forward<Lambda>(fn)();
else
[[maybe_unused]] auto r = std::forward<Lambda>(fn)();
}
}
};
/*
The FunctionPointer<Func> struct is a type trait for function pointer.
- ArgumentCount is the number of argument, or -1 if it is unknown
- the Object typedef is the Object of a pointer to member function
- the Arguments typedef is the list of argument (in a QtPrivate::List)
- the Function typedef is an alias to the template parameter Func
- the call<Args, R>(f,o,args) method is used to call that slot
Args is the list of argument of the signal
R is the return type of the signal
f is the function pointer
o is the receiver object
and args is the array of pointer to arguments, as used in qt_metacall
The Functor<Func,N> struct is the helper to call a functor of N argument.
Its call function is the same as the FunctionPointer::call function.
*/
template<typename Func> struct FunctionPointer { enum {ArgumentCount = -1, IsPointerToMemberFunction = false}; };
template<typename ObjPrivate> inline void assertObjectType(QObjectPrivate *d);
template<typename Obj> inline void assertObjectType(QObject *o)
{
// ensure all three compile
[[maybe_unused]] auto staticcast = [](QObject *obj) { return static_cast<Obj *>(obj); };
[[maybe_unused]] auto qobjcast = [](QObject *obj) { return Obj::staticMetaObject.cast(obj); };
#ifdef __cpp_rtti
[[maybe_unused]] auto dyncast = [](QObject *obj) { return dynamic_cast<Obj *>(obj); };
auto cast = dyncast;
#else
auto cast = qobjcast;
#endif
Q_ASSERT_X(cast(o), Obj::staticMetaObject.className(),
"Called object is not of the correct type (class destructor may have already run)");
}
template <typename, typename, typename, typename> struct FunctorCall;
template <size_t... II, typename... SignalArgs, typename R, typename Function>
struct FunctorCall<std::index_sequence<II...>, List<SignalArgs...>, R, Function> : FunctorCallBase
{
static void call(Function &f, void **arg)
{
call_internal<R>(arg, [&] {
return f((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...);
});
}
};
template <size_t... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
struct FunctorCall<std::index_sequence<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...)> : FunctorCallBase
{
static void call(SlotRet (Obj::*f)(SlotArgs...), Obj *o, void **arg)
{
assertObjectType<Obj>(o);
call_internal<R>(arg, [&] {
return (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...);
});
}
};
template <size_t... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
struct FunctorCall<std::index_sequence<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) const> : FunctorCallBase
{
static void call(SlotRet (Obj::*f)(SlotArgs...) const, Obj *o, void **arg)
{
assertObjectType<Obj>(o);
call_internal<R>(arg, [&] {
return (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...);
});
}
};
template <size_t... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
struct FunctorCall<std::index_sequence<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) noexcept> : FunctorCallBase
{
static void call(SlotRet (Obj::*f)(SlotArgs...) noexcept, Obj *o, void **arg)
{
assertObjectType<Obj>(o);
call_internal<R>(arg, [&]() noexcept {
return (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...);
});
}
};
template <size_t... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
struct FunctorCall<std::index_sequence<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) const noexcept> : FunctorCallBase
{
static void call(SlotRet (Obj::*f)(SlotArgs...) const noexcept, Obj *o, void **arg)
{
assertObjectType<Obj>(o);
call_internal<R>(arg, [&]() noexcept {
return (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...);
});
}
};
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...)>
{
typedef Obj Object;
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (Obj::*Function) (Args...);
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
template <typename SignalArgs, typename R>
static void call(Function f, Obj *o, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, o, arg);
}
};
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) const>
{
typedef Obj Object;
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (Obj::*Function) (Args...) const;
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
template <typename SignalArgs, typename R>
static void call(Function f, Obj *o, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, o, arg);
}
};
template<typename Ret, typename... Args> struct FunctionPointer<Ret (*) (Args...)>
{
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (*Function) (Args...);
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = false};
template <typename SignalArgs, typename R>
static void call(Function f, void *, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, arg);
}
};
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) noexcept>
{
typedef Obj Object;
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (Obj::*Function) (Args...) noexcept;
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
template <typename SignalArgs, typename R>
static void call(Function f, Obj *o, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, o, arg);
}
};
template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) const noexcept>
{
typedef Obj Object;
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (Obj::*Function) (Args...) const noexcept;
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
template <typename SignalArgs, typename R>
static void call(Function f, Obj *o, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, o, arg);
}
};
template<typename Ret, typename... Args> struct FunctionPointer<Ret (*) (Args...) noexcept>
{
typedef List<Args...> Arguments;
typedef Ret ReturnType;
typedef Ret (*Function) (Args...) noexcept;
enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = false};
template <typename SignalArgs, typename R>
static void call(Function f, void *, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Function>::call(f, arg);
}
};
// Traits to detect if there is a conversion between two types,
// and that conversion does not include a narrowing conversion.
template <typename T>
struct NarrowingDetector { T t[1]; }; // from P0608
template <typename From, typename To, typename Enable = void>
struct IsConvertibleWithoutNarrowing : std::false_type {};
template <typename From, typename To>
struct IsConvertibleWithoutNarrowing<From, To,
std::void_t< decltype( NarrowingDetector<To>{ {std::declval<From>()} } ) >
> : std::true_type {};
// Check for the actual arguments. If they are exactly the same,
// then don't bother checking for narrowing; as a by-product,
// this solves the problem of incomplete types (which must be supported,
// or they would error out in the trait above).
template <typename From, typename To, typename Enable = void>
struct AreArgumentsConvertibleWithoutNarrowingBase : std::false_type {};
template <typename From, typename To>
struct AreArgumentsConvertibleWithoutNarrowingBase<From, To,
std::enable_if_t<
std::disjunction_v<std::is_same<From, To>, IsConvertibleWithoutNarrowing<From, To>>
>
> : std::true_type {};
/*
Logic that check if the arguments of the slot matches the argument of the signal.
To be used like this:
static_assert(CheckCompatibleArguments<FunctionPointer<Signal>::Arguments, FunctionPointer<Slot>::Arguments>::value)
*/
template<typename A1, typename A2> struct AreArgumentsCompatible {
static int test(const std::remove_reference_t<A2>&);
static char test(...);
enum { value = sizeof(test(std::declval<std::remove_reference_t<A1>>())) == sizeof(int) };
#ifdef QT_NO_NARROWING_CONVERSIONS_IN_CONNECT
using AreArgumentsConvertibleWithoutNarrowing = AreArgumentsConvertibleWithoutNarrowingBase<std::decay_t<A1>, std::decay_t<A2>>;
static_assert(AreArgumentsConvertibleWithoutNarrowing::value, "Signal and slot arguments are not compatible (narrowing)");
#endif
};
template<typename A1, typename A2> struct AreArgumentsCompatible<A1, A2&> { enum { value = false }; };
template<typename A> struct AreArgumentsCompatible<A&, A&> { enum { value = true }; };
// void as a return value
template<typename A> struct AreArgumentsCompatible<void, A> { enum { value = true }; };
template<typename A> struct AreArgumentsCompatible<A, void> { enum { value = true }; };
template<> struct AreArgumentsCompatible<void, void> { enum { value = true }; };
template <typename List1, typename List2> struct CheckCompatibleArguments { enum { value = false }; };
template <> struct CheckCompatibleArguments<List<>, List<>> { enum { value = true }; };
template <typename List1> struct CheckCompatibleArguments<List1, List<>> { enum { value = true }; };
template <typename Arg1, typename Arg2, typename... Tail1, typename... Tail2>
struct CheckCompatibleArguments<List<Arg1, Tail1...>, List<Arg2, Tail2...>>
{
enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
&& CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>::value };
};
/*
Find the maximum number of arguments a functor object can take and be still compatible with
the arguments from the signal.
Value is the number of arguments, or -1 if nothing matches.
*/
template <typename Functor, typename ArgList> struct ComputeFunctorArgumentCount;
template <typename Functor, typename ArgList, bool Done> struct ComputeFunctorArgumentCountHelper
{ enum { Value = -1 }; };
template <typename Functor, typename First, typename... ArgList>
struct ComputeFunctorArgumentCountHelper<Functor, List<First, ArgList...>, false>
: ComputeFunctorArgumentCount<Functor,
typename List_Left<List<First, ArgList...>, sizeof...(ArgList)>::Value> {};
template <typename Functor, typename... ArgList> struct ComputeFunctorArgumentCount<Functor, List<ArgList...>>
{
template <typename F> static auto test(F f) -> decltype(((f.operator()((std::declval<ArgList>())...)), int()));
static char test(...);
enum {
Ok = sizeof(test(std::declval<Functor>())) == sizeof(int),
Value = Ok ? int(sizeof...(ArgList)) : int(ComputeFunctorArgumentCountHelper<Functor, List<ArgList...>, Ok>::Value)
};
};
/* get the return type of a functor, given the signal argument list */
template <typename Functor, typename ArgList> struct FunctorReturnType;
template <typename Functor, typename... ArgList> struct FunctorReturnType<Functor, List<ArgList...>>
: std::invoke_result<Functor, ArgList...>
{ };
template<typename Func, typename... Args>
struct FunctorCallable
{
using ReturnType = std::invoke_result_t<Func, Args...>;
using Function = ReturnType(*)(Args...);
enum {ArgumentCount = sizeof...(Args)};
using Arguments = QtPrivate::List<Args...>;
template <typename SignalArgs, typename R>
static void call(Func &f, void *, void **arg) {
FunctorCall<std::index_sequence_for<Args...>, SignalArgs, R, Func>::call(f, arg);
}
};
template <typename Functor, typename... Args>
struct HasCallOperatorAcceptingArgs
{
private:
template <typename F, typename = void>
struct Test : std::false_type
{
};
// We explicitly use .operator() to not return true for pointers to free/static function
template <typename F>
struct Test<F, std::void_t<decltype(std::declval<F>().operator()(std::declval<Args>()...))>>
: std::true_type
{
};
public:
using Type = Test<Functor>;
static constexpr bool value = Type::value;
};
template <typename Functor, typename... Args>
constexpr bool
HasCallOperatorAcceptingArgs_v = HasCallOperatorAcceptingArgs<Functor, Args...>::value;
template <typename Func, typename... Args>
struct CallableHelper
{
private:
// Could've been std::conditional_t, but that requires all branches to
// be valid
static auto Resolve(std::true_type CallOperator) -> FunctorCallable<Func, Args...>;
static auto Resolve(std::false_type CallOperator) -> FunctionPointer<std::decay_t<Func>>;
public:
using Type = decltype(Resolve(typename HasCallOperatorAcceptingArgs<std::decay_t<Func>,
Args...>::Type{}));
};
template<typename Func, typename... Args>
struct Callable : CallableHelper<Func, Args...>::Type
{};
template<typename Func, typename... Args>
struct Callable<Func, List<Args...>> : CallableHelper<Func, Args...>::Type
{};
/*
Wrapper around ComputeFunctorArgumentCount and CheckCompatibleArgument,
depending on whether \a Functor is a PMF or not. Returns -1 if \a Func is
not compatible with the \a ExpectedArguments, otherwise returns >= 0.
*/
template<typename Prototype, typename Functor>
inline constexpr std::enable_if_t<!std::disjunction_v<std::is_convertible<Prototype, const char *>,
std::is_same<std::decay_t<Prototype>, QMetaMethod>,
std::is_convertible<Functor, const char *>,
std::is_same<std::decay_t<Functor>, QMetaMethod>
>,
int>
countMatchingArguments()
{
using ExpectedArguments = typename QtPrivate::FunctionPointer<Prototype>::Arguments;
using Actual = std::decay_t<Functor>;
if constexpr (QtPrivate::FunctionPointer<Actual>::IsPointerToMemberFunction
|| QtPrivate::FunctionPointer<Actual>::ArgumentCount >= 0) {
// PMF or free function
using ActualArguments = typename QtPrivate::FunctionPointer<Actual>::Arguments;
if constexpr (QtPrivate::CheckCompatibleArguments<ExpectedArguments, ActualArguments>::value)
return QtPrivate::FunctionPointer<Actual>::ArgumentCount;
else
return -1;
} else {
// lambda or functor
return QtPrivate::ComputeFunctorArgumentCount<Actual, ExpectedArguments>::Value;
}
}
// internal base class (interface) containing functions required to call a slot managed by a pointer to function.
class QSlotObjectBase
{
// Don't use virtual functions here; we don't want the
// compiler to create tons of per-polymorphic-class stuff that
// we'll never need. We just use one function pointer, and the
// Operations enum below to distinguish requests
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
QAtomicInt m_ref = 1;
typedef void (*ImplFn)(int which, QSlotObjectBase* this_, QObject *receiver, void **args, bool *ret);
const ImplFn m_impl;
#else
using ImplFn = void (*)(QSlotObjectBase* this_, QObject *receiver, void **args, int which, bool *ret);
const ImplFn m_impl;
QAtomicInt m_ref = 1;
#endif
protected:
// The operations that can be requested by calls to m_impl,
// see the member functions that call m_impl below for details
enum Operation {
Destroy,
Call,
Compare,
NumOperations
};
public:
explicit QSlotObjectBase(ImplFn fn) : m_impl(fn) {}
// A custom deleter compatible with std protocols (op()()) we well as
// the legacy QScopedPointer protocol (cleanup()).
struct Deleter {
void operator()(QSlotObjectBase *p) const noexcept
{ if (p) p->destroyIfLastRef(); }
// for the non-standard QScopedPointer protocol:
static void cleanup(QSlotObjectBase *p) noexcept { Deleter{}(p); }
};
bool ref() noexcept { return m_ref.ref(); }
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
inline void destroyIfLastRef() noexcept
{ if (!m_ref.deref()) m_impl(Destroy, this, nullptr, nullptr, nullptr); }
inline bool compare(void **a) { bool ret = false; m_impl(Compare, this, nullptr, a, &ret); return ret; }
inline void call(QObject *r, void **a) { m_impl(Call, this, r, a, nullptr); }
#else
inline void destroyIfLastRef() noexcept
{ if (!m_ref.deref()) m_impl(this, nullptr, nullptr, Destroy, nullptr); }
inline bool compare(void **a)
{
bool ret = false;
m_impl(this, nullptr, a, Compare, &ret);
return ret;
}
inline void call(QObject *r, void **a) { m_impl(this, r, a, Call, nullptr); }
#endif
bool isImpl(ImplFn f) const { return m_impl == f; }
protected:
~QSlotObjectBase() {}
private:
Q_DISABLE_COPY_MOVE(QSlotObjectBase)
};
using SlotObjUniquePtr = std::unique_ptr<QSlotObjectBase,
QSlotObjectBase::Deleter>;
inline SlotObjUniquePtr copy(const SlotObjUniquePtr &other) noexcept
{
if (other)
other->ref();
return SlotObjUniquePtr{other.get()};
}
class SlotObjSharedPtr {
SlotObjUniquePtr obj;
public:
Q_NODISCARD_CTOR Q_IMPLICIT SlotObjSharedPtr() noexcept = default;
Q_NODISCARD_CTOR Q_IMPLICIT SlotObjSharedPtr(std::nullptr_t) noexcept : SlotObjSharedPtr() {}
Q_NODISCARD_CTOR explicit SlotObjSharedPtr(SlotObjUniquePtr o)
: obj(std::move(o))
{
// does NOT ref() (takes unique_ptr by value)
// (that's why (QSlotObjectBase*) ctor doesn't exisit: don't know whether that one _should_)
}
Q_NODISCARD_CTOR SlotObjSharedPtr(const SlotObjSharedPtr &other) noexcept
: obj{copy(other.obj)} {}
SlotObjSharedPtr &operator=(const SlotObjSharedPtr &other) noexcept
{ auto copy = other; swap(copy); return *this; }
Q_NODISCARD_CTOR SlotObjSharedPtr(SlotObjSharedPtr &&other) noexcept = default;
SlotObjSharedPtr &operator=(SlotObjSharedPtr &&other) noexcept = default;
~SlotObjSharedPtr() = default;
void swap(SlotObjSharedPtr &other) noexcept { obj.swap(other.obj); }
auto get() const noexcept { return obj.get(); }
auto operator->() const noexcept { return get(); }
explicit operator bool() const noexcept { return bool(obj); }
};
// Implementation of QSlotObjectBase for which the slot is a callable (function, PMF, functor, or lambda).
// Args and R are the List of arguments and the return type of the signal to which the slot is connected.
template <typename Func, typename Args, typename R>
class QCallableObject : public QSlotObjectBase,
private QtPrivate::CompactStorage<std::decay_t<Func>>
{
using FunctorValue = std::decay_t<Func>;
using Storage = QtPrivate::CompactStorage<FunctorValue>;
using FuncType = Callable<Func, Args>;
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
Q_DECL_HIDDEN static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
#else
// Design note: the first three arguments match those for typical Call
// and Destroy uses. We return void to enable tail call optimization
// for those too.
Q_DECL_HIDDEN static void impl(QSlotObjectBase *this_, QObject *r, void **a, int which, bool *ret)
#endif
{
const auto that = static_cast<QCallableObject*>(this_);
switch (which) {
case Destroy:
delete that;
break;
case Call:
if constexpr (std::is_member_function_pointer_v<FunctorValue>)
FuncType::template call<Args, R>(that->object(), static_cast<typename FuncType::Object *>(r), a);
else
FuncType::template call<Args, R>(that->object(), r, a);
break;
case Compare:
if constexpr (std::is_member_function_pointer_v<FunctorValue>) {
*ret = *reinterpret_cast<FunctorValue *>(a) == that->object();
break;
}
// not implemented otherwise
Q_FALLTHROUGH();
case NumOperations:
Q_UNUSED(ret);
}
}
public:
explicit QCallableObject(Func &&f) : QSlotObjectBase(&impl), Storage{std::move(f)} {}
explicit QCallableObject(const Func &f) : QSlotObjectBase(&impl), Storage{f} {}
};
// Helper to detect the context object type based on the functor type:
// QObject for free functions and lambdas; the callee for member function
// pointers. The default declaration doesn't have the ContextType typedef,
// and so non-functor APIs (like old-style string-based slots) are removed
// from the overload set.
template <typename Func, typename = void>
struct ContextTypeForFunctor {};
template <typename Func>
struct ContextTypeForFunctor<Func,
std::enable_if_t<!std::disjunction_v<std::is_convertible<Func, const char *>,
std::is_member_function_pointer<Func>
>
>
>
{
using ContextType = QObject;
};
template <typename Func>
struct ContextTypeForFunctor<Func,
std::enable_if_t<std::conjunction_v<std::negation<std::is_convertible<Func, const char *>>,
std::is_member_function_pointer<Func>,
std::is_convertible<typename QtPrivate::FunctionPointer<Func>::Object *, QObject *>
>
>
>
{
using ContextType = typename QtPrivate::FunctionPointer<Func>::Object;
};
/*
Returns a suitable QSlotObjectBase object that holds \a func, if possible.
Not available (and thus produces compile-time errors) if the Functor provided is
not compatible with the expected Prototype.
*/
template <typename Prototype, typename Functor>
inline constexpr std::enable_if_t<QtPrivate::countMatchingArguments<Prototype, Functor>() >= 0,
QtPrivate::QSlotObjectBase *>
makeCallableObject(Functor &&func)
{
using ExpectedSignature = QtPrivate::FunctionPointer<Prototype>;
using ExpectedReturnType = typename ExpectedSignature::ReturnType;
using ExpectedArguments = typename ExpectedSignature::Arguments;
using ActualSignature = QtPrivate::FunctionPointer<Functor>;
constexpr int MatchingArgumentCount = QtPrivate::countMatchingArguments<Prototype, Functor>();
using ActualArguments = typename QtPrivate::List_Left<ExpectedArguments, MatchingArgumentCount>::Value;
static_assert(int(ActualSignature::ArgumentCount) <= int(ExpectedSignature::ArgumentCount),
"Functor requires more arguments than what can be provided.");
// NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
return new QtPrivate::QCallableObject<std::decay_t<Functor>, ActualArguments, ExpectedReturnType>(std::forward<Functor>(func));
}
template<typename Prototype, typename Functor, typename = void>
struct AreFunctionsCompatible : std::false_type {};
template<typename Prototype, typename Functor>
struct AreFunctionsCompatible<Prototype, Functor, std::enable_if_t<
std::is_same_v<decltype(QtPrivate::makeCallableObject<Prototype>(std::forward<Functor>(std::declval<Functor>()))),
QtPrivate::QSlotObjectBase *>>
> : std::true_type {};
template<typename Prototype, typename Functor>
inline constexpr bool AssertCompatibleFunctions() {
static_assert(AreFunctionsCompatible<Prototype, Functor>::value,
"Functor is not compatible with expected prototype!");
return true;
}
} // namespace QtPrivate
QT_END_NAMESPACE