├── FunctionTraits.h
├── FunctionUtils.h
├── QtCallback.cpp
├── QtCallback.h
├── QtMetacallAdapter.h
├── QtSignalForwarder.cpp
├── QtSignalForwarder.h
├── README.md
├── SafeBinder.h
├── examples
    ├── common.pri
    ├── ui-controls
    │   ├── UiDemo.cpp
    │   └── ui-controls.pro
    └── web-page-fetcher
    │   ├── WebPageDownloader.cpp
    │   ├── WebPageDownloader.h
    │   └── web-page-fetcher.pro
├── qt-callbacks.pro
└── tests
    ├── TestQtSignalTools.cpp
    ├── TestQtSignalTools.h
    └── tests.pro


/FunctionTraits.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "FunctionUtils.h"
 4 | 
 5 | namespace QtSignalTools
 6 | {
 7 | 
 8 | // extract the argument count and types
 9 | // from a function signature
10 | template <class T>
11 | struct FunctionTraits;
12 | 
13 | template <class R>
14 | struct FunctionTraits<R()>
15 | {
16 | 	enum { count = 0 };
17 | 	typedef R result_type;
18 | };
19 | 
20 | template <class R, class T>
21 | struct FunctionTraits<R(T)> : FunctionTraits<R()>
22 | {
23 | 	enum { count = 1 };
24 | 	typedef T arg0_type;
25 | };
26 | 
27 | template <class R, class T1, class T2>
28 | struct FunctionTraits<R(T1,T2)> : FunctionTraits<R(T1)>
29 | {
30 | 	enum { count = 2 };
31 | 	typedef T2 arg1_type;
32 | };
33 | 
34 | template <class R, class T1, class T2, class T3>
35 | struct FunctionTraits<R(T1,T2,T3)> : FunctionTraits<R(T1,T2)>
36 | {
37 | 	enum { count = 3 };
38 | 	typedef T3 arg2_type;
39 | };
40 | 
41 | template <class R, class T1, class T2, class T3, class T4>
42 | struct FunctionTraits<R(T1,T2,T3,T4)> : FunctionTraits<R(T1,T2,T3)>
43 | {
44 | 	enum { count = 4 };
45 | 	typedef T4 arg3_type;
46 | };
47 | 
48 | template <class R, class T1, class T2, class T3, class T4, class T5>
49 | struct FunctionTraits<R(T1,T2,T3,T4,T5)> : FunctionTraits<R(T1,T2,T3,T4)>
50 | {
51 | 	enum { count = 5 };
52 | 	typedef T5 arg4_type;
53 | };
54 | 
55 | // extract the function signature from an input type T,
56 | // where T may be a function pointer or function object
57 | template <class T>
58 | struct ExtractSignature
59 | {
60 | 	typedef T type;
61 | };
62 | 
63 | template <class T>
64 | struct ExtractSignature<T*>
65 | {
66 | 	typedef T type;
67 | };
68 | 
69 | template <template <class S> class Function, class S>
70 | struct ExtractSignature<Function<S> >
71 | {
72 | 	typedef S type;
73 | };
74 | 
75 | template <class Signature, class Class>
76 | struct ExtractSignature<Signature Class::*>
77 | {
78 | 	typedef Signature type;
79 | };
80 | 
81 | template <class MemberFunc>
82 | struct MemberFuncResultType
83 | {
84 | #ifdef QST_COMPILER_SUPPORTS_DECLTYPE
85 | 	typedef decltype(QtSignalTools::mem_fn(static_cast<MemberFunc>(0))) MemFnType;
86 | #else
87 | 	typedef __typeof__(QtSignalTools::mem_fn(static_cast<MemberFunc>(0))) MemFnType;
88 | #endif
89 | 	typedef typename MemFnType::result_type type;
90 | };
91 | 
92 | }
93 | 
94 | 


--------------------------------------------------------------------------------
/FunctionUtils.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | // tests for relevant C++11 features
 4 | //
 5 | // Qt 5 provides all of the compiler feature detection we need
 6 | // in qcompilerdetection.h via Q_COMPILER_XXX macros.
 7 | // 
 8 | // Qt 4 is missing defines for
 9 | // certain compilers (eg. new versions of Clang and VC++) and
10 | // features.
11 | 
12 | // Visual C++
13 | // See http://blogs.msdn.com/b/vcblog/archive/2011/09/12/10209291.aspx
14 | #if (_MSC_VER >= 1600)
15 | #define QST_COMPILER_SUPPORTS_LAMBDAS
16 | #define QST_COMPILER_SUPPORTS_DECLTYPE
17 | #endif
18 | 
19 | // GCC
20 | // See http://gcc.gnu.org/projects/cxx0x.html
21 | #if (__GNUC__ >= 4) && defined(__GXX_EXPERIMENTAL_CXX0X__)
22 | #if (__GNUC_MINOR__ >= 3)
23 | #define QST_COMPILER_SUPPORTS_DECLTYPE
24 | #define QST_COMPILER_SUPPORTS_VARIADIC_TEMPLATES
25 | #endif
26 | #if (__GNUC_MINOR__ >= 5)
27 | #define QST_COMPILER_SUPPORTS_LAMBDAS
28 | #endif
29 | #endif
30 | 
31 | // Clang
32 | // See http://clang.llvm.org/docs/LanguageExtensions.html
33 | #if __clang__
34 | #if __has_feature(cxx_lambdas)
35 | #define QST_COMPILER_SUPPORTS_LAMBDAS
36 | #define QST_COMPILER_SUPPORTS_DECLTYPE
37 | #endif
38 | #if __has_feature(cxx_variadic_templates)
39 | #define QST_COMPILER_SUPPORTS_VARIADIC_TEMPLATES
40 | #endif
41 | #endif
42 | 
43 | #ifdef QST_COMPILER_SUPPORTS_LAMBDAS
44 | // sets whether the C++11 standard libraries should
45 | // be used.  If not, we fall back to the TR1 versions.
46 | // A similar define could also be used to use Boost instead.
47 | #define QST_USE_CPP11_LIBS
48 | #endif
49 | 
50 | // include headers that provide function<> and bind()
51 | #if defined(_MSC_VER) || defined(QST_USE_CPP11_LIBS)
52 | #include <functional>
53 | #include <memory>
54 | #include <type_traits>
55 | 
56 | #ifndef _MSC_VER
57 | // even under C++11, we are still using the TR1 version
58 | // of result_of<>
59 | #include <tr1/functional>
60 | #endif
61 | 
62 | #else
63 | #include <tr1/functional>
64 | #include <tr1/memory>
65 | #include <tr1/type_traits>
66 | #endif
67 | 
68 | #define QST_COMMA ,
69 | 
70 | namespace QtSignalTools
71 | {
72 | 
73 | // enable_if is actually provided by all
74 | // supported compilers, but is under an extension
75 | // namespace under GCC
76 | template <bool, class T>
77 | struct enable_if;
78 | 
79 | template <class T>
80 | struct enable_if<true,T>
81 | {
82 | 	typedef T type;
83 | };
84 | 
85 | #if defined(QST_USE_CPP11_LIBS)
86 | namespace qst_functional = std;
87 | #else
88 | namespace qst_functional = std::tr1;
89 | #endif
90 | 
91 | using qst_functional::is_base_of;
92 | using qst_functional::mem_fn;
93 | using qst_functional::shared_ptr;
94 | 
95 | }
96 | 
97 | 


--------------------------------------------------------------------------------
/QtCallback.cpp:
--------------------------------------------------------------------------------
  1 | #include "QtCallback.h"
  2 | 
  3 | #include <QtCore/QDebug>
  4 | #include <QtCore/QMetaMethod>
  5 | #include <QtCore/QMetaObject>
  6 | 
  7 | const char* variantTypeName(const QVariant& value)
  8 | {
  9 | 	return QMetaType::typeName(value.userType());
 10 | }
 11 | 
 12 | QtCallbackBase::QtCallbackBase()
 13 | 	: d(new Data)
 14 | {
 15 | }
 16 | 
 17 | QtCallbackBase::QtCallbackBase(QObject* receiver, const char* method)
 18 | 	: d(new Data)
 19 | {
 20 | 	Q_ASSERT(receiver);
 21 | 	Q_ASSERT(method);
 22 | 
 23 | 	d->receiver = receiver;
 24 | 
 25 | 	int methodIndex = receiver->metaObject()->indexOfMethod(method+1);
 26 | 	if (methodIndex >= 0) {
 27 | 		d->method = receiver->metaObject()->method(methodIndex);
 28 | 	} else {
 29 | 		qWarning() << "Receiver" << receiver << "has no such method" << method;
 30 | 	}
 31 | }
 32 | 
 33 | int QtCallbackBase::parameterCount() const
 34 | {
 35 | 	return d->method.parameterTypes().count();
 36 | }
 37 | 
 38 | int QtCallbackBase::parameterType(int index) const
 39 | {
 40 | 	return QMetaType::type(d->method.parameterTypes().at(index));
 41 | }
 42 | 
 43 | bool QtCallbackBase::isBound(int index) const
 44 | {
 45 | 	for (int i=0; i < d->args.count(); i++) {
 46 | 		if (d->args[i].position == index) {
 47 | 			return true;
 48 | 		}
 49 | 	}
 50 | 	return false;
 51 | }
 52 | 
 53 | int QtCallbackBase::unboundParameterCount() const
 54 | {
 55 | 	int unboundCount = 0;
 56 | 	int count = parameterCount();
 57 | 	for (int i=0; i < count; i++) {
 58 | 		if (!isBound(i)) {
 59 | 			++unboundCount;
 60 | 		}
 61 | 	}
 62 | 	return unboundCount;
 63 | }
 64 | 
 65 | int QtCallbackBase::unboundParameterType(int index) const
 66 | {
 67 | 	int count = parameterCount();
 68 | 	int unboundCount = 0;
 69 | 	for (int i=0; i < count; i++) {
 70 | 		if (!isBound(i)) {
 71 | 			if (unboundCount == index) {
 72 | 				return parameterType(i);
 73 | 			}
 74 | 			++unboundCount;
 75 | 		}
 76 | 	}
 77 | 	return -1;
 78 | }
 79 | 
 80 | QtCallbackBase::QtCallbackBase(const QtCallbackBase& other)
 81 | 	: d(other.d)
 82 | {
 83 | }
 84 | 
 85 | void QtCallbackBase::bind(int index, const QVariant& value)
 86 | {
 87 | 	Q_ASSERT_X(index < parameterCount(), Q_FUNC_INFO, "Argument index is out of range");
 88 | 	Q_ASSERT_X(parameterType(index) == value.userType(), Q_FUNC_INFO, "Argument type is incorrect");
 89 | 	Q_ASSERT_X(value.userType() != 0, Q_FUNC_INFO, "Argument type is unknown");
 90 | 
 91 | 	for (int i=0; i < d->args.count(); i++)
 92 | 	{
 93 | 		if (d->args[i].position == index)
 94 | 		{
 95 | 			d->args[i].value = value;
 96 | 			return;
 97 | 		}
 98 | 	}
 99 | 	Data::Arg newArg;
100 | 	newArg.position = index;
101 | 	newArg.value = value;
102 | 	d->args.append(newArg);
103 | }
104 | 
105 | void QtCallbackBase::bind(const QVariant& value)
106 | {
107 | 	int minUnusedArg = 0;
108 | 	for (int i=0; i < d->args.count(); i++) {
109 | 		if (d->args[i].position == minUnusedArg) {
110 | 			++minUnusedArg;
111 | 		}
112 | 	}
113 | 	Q_ASSERT_X(minUnusedArg < parameterCount(), Q_FUNC_INFO, "More parameters have been bound to the callback that the connected method accepts");
114 | 	bind(minUnusedArg, value);
115 | }
116 | 
117 | bool QtCallbackBase::invokeWithArgs(const QGenericArgument& a1, const QGenericArgument& a2, const QGenericArgument& a3,
118 |                                     const QGenericArgument& a4, const QGenericArgument& a5, const QGenericArgument& a6) const
119 | {
120 | 	if (!d->receiver) {
121 | 		// receiver was destroyed before callback could be invoked
122 | 		qWarning() << "Unable to invoke callback.  Receiver was destroyed";
123 | 		return false;
124 | 	}
125 | 	if (d->method.methodIndex() < 0) {
126 | 		// method was not found on receiver
127 | 		qWarning() << "Unable to invoke callback.  Method not found";
128 | 		return false;
129 | 	}
130 | 
131 | 	int invokeArgIndex = 0;
132 | 	QGenericArgument invokeArgs[] = {a1,a2,a3,a4,a5,a6};
133 | 	QGenericArgument args[7] = {QGenericArgument()};
134 | 	QList<QByteArray> params = d->method.parameterTypes();
135 | 	
136 | 	int paramCount = parameterCount();
137 | 	for (int i = 0; i < paramCount; i++) {
138 | 		for (int k = 0; k < d->args.count(); k++) {
139 | 			const Data::Arg& boundArg = d->args[k];
140 | 			if (boundArg.position == i) {
141 | 				// in Qt 4, QMetaMethod only provides access to the type name string.
142 | 				// in Qt 5 we could compare the type IDs instead
143 | 				const char* expectedType = params[i].constData();
144 | 				const char* actualType = variantTypeName(boundArg.value);
145 | 				if (strcmp(expectedType, actualType) != 0)
146 | 				{
147 | 					qWarning() << "Unable to invoke callback.  Type of bound arg at index" << i << QString(actualType)
148 | 					           << "does not match expected type" << QString(expectedType);
149 | 					return false;
150 | 				}
151 | 
152 | 				args[i] = QGenericArgument(actualType, boundArg.value.constData());
153 | 				break;
154 | 			}
155 | 		}
156 | 
157 | 		if (!args[i].data()) {
158 | 			args[i] = invokeArgs[invokeArgIndex];
159 | 			if (!args[i].data()) {
160 | 				// not enough arguments supplied
161 | 				qWarning() << "Unable to invoke callback.  Argument" << i << "was not bound";
162 | 				return false;
163 | 			}
164 | 			++invokeArgIndex;
165 | 		}
166 | 	}
167 | 
168 | 	if (!d->method.invoke(d->receiver.data(), args[0], args[1], args[2], args[3], args[4], args[5], args[6])) {
169 | #if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
170 | 		qWarning() << "Failed to invoke method" << d->method.methodSignature();
171 | #else
172 | 		qWarning() << "Failed to invoke method" << d->method.signature();
173 | #endif
174 | 		return false;
175 | 	}
176 | 	return true;
177 | }
178 | 
179 | 


--------------------------------------------------------------------------------
/QtCallback.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <QtCore/QMetaMethod>
  4 | #include <QtCore/QMetaType>
  5 | #include <QtCore/QPointer>
  6 | #include <QtCore/QSharedData>
  7 | #include <QtCore/QSharedDataPointer>
  8 | #include <QtCore/QVarLengthArray>
  9 | #include <QtCore/QVariant>
 10 | #include <QtCore/QWeakPointer>
 11 | 
 12 | /** QtCallbackBase is an object which stores the receiver, method name
 13 |  * and optionally, some of the arguments for a Qt signal or slot function call.
 14 |  *
 15 |  * The method can then be invoked on the receiver using the invokeWithArgs() method.
 16 |  *
 17 |  * This is conceptually similar to std::function and std::bind except:
 18 |  *
 19 |  *  - If the receiver is destroyed before the bound function is invoked, attempting to
 20 |  *    call the method has no effect.
 21 |  *  - Type matches between the supplied arguments and those expected by the method
 22 |  *    are not checked until the call is made.
 23 |  *
 24 |  * QtCallbackBase can be invoked with any number of arguments and the types are not
 25 |  * checked at compile time.  The QtCallback<N> subclasses provide function objects
 26 |  * which take N arguments that are passed to the method.
 27 |  *
 28 |  * Example Usage:
 29 |  *
 30 |  *   QtCallbackBase callback(myLabel, SLOT(setText(QString)));
 31 |  *   callback.invokeWithArgs(Q_ARG(QString, "Hello World"))
 32 |  *
 33 |  * Or using QtCallback:
 34 |  *
 35 |  *   QtCallback1<QString> callback(myLabel, SLOT(setText(QString)));
 36 |  *   callback("Hello World");
 37 |  */
 38 | class QtCallbackBase
 39 | {
 40 | 	public:
 41 | 		QtCallbackBase();
 42 | 
 43 | 		/** Constructs a callback which will call @p method on @p receiver.
 44 | 		 */
 45 | 		QtCallbackBase(QObject* receiver, const char* method);
 46 | 
 47 | 		QtCallbackBase(const QtCallbackBase& other);
 48 | 
 49 | 		/** Bind the @p index'th parameter in the method to call to @p value. */
 50 | 		void bind(int index, const QVariant& value);
 51 | 
 52 | 		/** Bind the next currently unbound parameter in the method to call to @p value. */
 53 | 		void bind(const QVariant& value);
 54 | 
 55 | 		/** Attempt to invoke the stored method on the receiver.
 56 | 		 * Returns false if the types do not match or the receiver has been destroyed.
 57 | 		 */
 58 | 		bool invokeWithArgs(const QGenericArgument& arg1 = QGenericArgument(),
 59 | 		                    const QGenericArgument& arg2 = QGenericArgument(),
 60 | 					        const QGenericArgument& arg3 = QGenericArgument(),
 61 | 							const QGenericArgument& arg4 = QGenericArgument(),
 62 | 							const QGenericArgument& arg5 = QGenericArgument(),
 63 | 							const QGenericArgument& arg6 = QGenericArgument()) const;
 64 | 
 65 | 		/** Returns the number of parameters that the bound method has. */
 66 | 		int parameterCount() const;
 67 | 
 68 | 		/** Returns the Qt type ID of the @p index'th parameter to the bound method. */
 69 | 		int parameterType(int index) const;
 70 | 
 71 | 		/** Returns the number of parameters to the method which have not been bound
 72 | 		 * with bind()
 73 | 		 */
 74 | 		int unboundParameterCount() const;
 75 | 
 76 | 		/** Returns the Qt type ID of the @p index'th parameter to the method
 77 | 		 * which has not yet been bound.
 78 | 		 */
 79 | 		int unboundParameterType(int index) const;
 80 | 
 81 | 		/** Returns true if the @p index'th argument to the bound method
 82 | 		 * has been set using bind()
 83 | 		 */
 84 | 		bool isBound(int index) const;
 85 | 
 86 | 	private:
 87 | 		struct Data : public QSharedData
 88 | 		{
 89 | 			struct Arg
 90 | 			{
 91 | 				int position;
 92 | 				QVariant value;
 93 | 			};
 94 | 
 95 | #if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
 96 | 			QPointer<QObject> receiver;
 97 | #else
 98 | 			// QWeakPointer is much more efficient under Qt 4
 99 | 			// when large numbers of weak pointers exist
100 | 			QWeakPointer<QObject> receiver;
101 | #endif
102 | 			QMetaMethod method;
103 | 			QVarLengthArray<Arg,5> args;
104 | 		};
105 | 		QSharedDataPointer<Data> d;
106 | };
107 | 
108 | template <class T>
109 | QGenericArgument makeQtArg(const T& arg)
110 | {
111 | 	return QGenericArgument(QMetaType::typeName(qMetaTypeId<T>()), &arg);
112 | }
113 | 
114 | /** Declare a QtCallback<> variant with |typeCount| type arguments called
115 |  *  QtCallback<typeCount>
116 |  */
117 | #define DECLARE_QTCALLBACK_TEMPLATE(typeCount, typeList, argList, makeQtArgList) \
118 | 	typeList \
119 | 	class QtCallback ## typeCount : public QtCallbackBase \
120 | 	{ \
121 | 		public:\
122 | 			   QtCallback ## typeCount() {}\
123 | 			   QtCallback ## typeCount(QObject* receiver, const char* method)\
124 | 				: QtCallbackBase(receiver,method) {} \
125 | 			   bool invoke(argList) const \
126 | 			   { return invokeWithArgs(makeQtArgList); } \
127 | 			   bool operator()(argList) const \
128 | 			   { return invokeWithArgs(makeQtArgList); } \
129 | 			   using QtCallbackBase::bind; \
130 | 			   template <class T> \
131 | 		       QtCallback ## typeCount& bind(const T& value) \
132 | 			   { bind(QVariant::fromValue(value)); return *this; } \
133 |     }
134 | 
135 | #define MACRO_COMMA ,
136 | 
137 | DECLARE_QTCALLBACK_TEMPLATE(,,,);
138 | DECLARE_QTCALLBACK_TEMPLATE(1, template<class T1>, const T1& arg1, makeQtArg(arg1));
139 | DECLARE_QTCALLBACK_TEMPLATE(2, template<class T1 MACRO_COMMA class T2>,
140 |                  const T1& arg1 MACRO_COMMA const T2& arg2,
141 |                  makeQtArg(arg1) MACRO_COMMA makeQtArg(arg2));
142 | DECLARE_QTCALLBACK_TEMPLATE(3, template<class T1 MACRO_COMMA class T2 MACRO_COMMA class T3>,
143 |                  const T1& arg1 MACRO_COMMA const T2& arg2 MACRO_COMMA const T3& arg3,
144 |                  makeQtArg(arg1) MACRO_COMMA makeQtArg(arg2) MACRO_COMMA makeQtArg(arg3));
145 | DECLARE_QTCALLBACK_TEMPLATE(4, template<class T1 MACRO_COMMA class T2 MACRO_COMMA class T3 MACRO_COMMA class T4>,
146 |                  const T1& arg1 MACRO_COMMA const T2& arg2 MACRO_COMMA const T3& arg3 MACRO_COMMA const T4& arg4,
147 |                  makeQtArg(arg1) MACRO_COMMA makeQtArg(arg2) MACRO_COMMA makeQtArg(arg3) MACRO_COMMA makeQtArg(arg4));
148 | 
149 | 


--------------------------------------------------------------------------------
/QtMetacallAdapter.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "FunctionTraits.h"
  4 | #include "QtCallback.h"
  5 | 
  6 | #include <QtCore/QSharedData>
  7 | #include <QtCore/QMetaObject>
  8 | 
  9 | static const int QTMETACALL_MAX_ARGS = 6;
 10 | typedef int QtMetacallArgsArray[QTMETACALL_MAX_ARGS];
 11 | 
 12 | namespace QtSignalTools
 13 | {
 14 | 
 15 | // interface for implementations of QtMetacallAdapter
 16 | struct QtMetacallAdapterImplIface : public QSharedData
 17 | {
 18 | 	virtual ~QtMetacallAdapterImplIface() {}
 19 | 	virtual bool invoke(const QGenericArgument* args, int count) const = 0;
 20 | 	virtual int getArgTypes(QtMetacallArgsArray args) const  = 0;
 21 | };
 22 | 
 23 | struct QtCallbackImpl : public QtMetacallAdapterImplIface
 24 | {
 25 | 	QtCallback callback;
 26 | 
 27 | 	QtCallbackImpl(const QtCallback& _callback)
 28 | 	: callback(_callback)
 29 | 	{}
 30 | 
 31 | 	virtual bool invoke(const QGenericArgument* _args, int count) const {
 32 | 		const int MAX_ARGS = 6;
 33 | 		QGenericArgument args[MAX_ARGS];
 34 | 		for (int i=0; i < MAX_ARGS; i++) {
 35 | 			if (i < count) {
 36 | 				args[i] = _args[i];
 37 | 			} else {
 38 | 				args[i] = QGenericArgument();
 39 | 			}
 40 | 		}
 41 | 		return callback.invokeWithArgs(args[0], args[1], args[2], args[3], args[4], args[5]);
 42 | 	}
 43 | 
 44 | 	virtual int getArgTypes(QtMetacallArgsArray args) const {
 45 | 		int count = qMin(callback.unboundParameterCount(), QTMETACALL_MAX_ARGS);
 46 | 		for (int i=0; i < count; i++) {
 47 | 			args[i] = callback.unboundParameterType(i);
 48 | 		}
 49 | 		return count;
 50 | 	}
 51 | };
 52 | 
 53 | template <class Functor>
 54 | struct QtMetacallAdapterImplBase : QtMetacallAdapterImplIface
 55 | {
 56 | 	// 'traits' type provides access to the number and types of
 57 | 	// the functor's arguments
 58 | 	typedef FunctionTraits<typename ExtractSignature<Functor>::type> traits;
 59 | 
 60 | 	// the function pointer or function object to invoke
 61 | 	Functor functor;
 62 | 
 63 | 	QtMetacallAdapterImplBase(const Functor& _f)
 64 | 	: functor(_f)
 65 | 	{}
 66 | 
 67 | 	// helper for checking at runtime that the type of a signal
 68 | 	// argument matches the type of the receiver's corresponding argument
 69 | 	template <class T>
 70 | 	static bool argMatch(int argType) {
 71 | 		return qMetaTypeId<T>() == argType;
 72 | 	}
 73 | 
 74 | 	template <class T>
 75 | 	static int argType() {
 76 | 		return qMetaTypeId<T>();
 77 | 	}
 78 | 
 79 | 	static int fillArgTypes(QtMetacallArgsArray args, int count, ...) {
 80 | 		va_list list;
 81 | 		va_start(list, count);
 82 | 		for (int i=0; i < count; i++) {
 83 | 			args[i] = va_arg(list, int);
 84 | 		}
 85 | 		va_end(list);
 86 | 		return count;
 87 | 	}
 88 | };
 89 | 
 90 | template <class Functor, int ArgCount>
 91 | struct QtMetacallAdapterImpl;
 92 | 
 93 | // extract the Nth argument from a QGenericArgument array and cast
 94 | // to the type expected by the Nth functor parameter
 95 | #define QMA_CAST_ARG(N) *reinterpret_cast<typename Base::traits::arg##N##_type*>(args[N].data())
 96 | 
 97 | // returns the type of the Nth argument that the receiver expects
 98 | #define QMA_ARG_TYPE(N) Base::template argType<typename Base::traits::arg##N##_type>()
 99 | 
100 | // declares an implementation of QtMetacallAdapterImpl for functors
101 | // that take 'argCount' arguments.
102 | //
103 | // 'invokeExpr' is the expression passed to the functor to call it with
104 | // the appropriate args
105 | //
106 | // 'argTypesExpr' is a comma-separated list of argument type IDs for
107 | // the arguments which the receiver expects.
108 | //
109 | // In C++11, this macro could be replaced with variadic templates
110 | #define QMA_DECLARE_ADAPTER_IMPL(argCount, invokeExpr, argTypesExpr) \
111 |   template <class Functor> \
112 |   struct QtMetacallAdapterImpl<Functor,argCount> \
113 |    : QtMetacallAdapterImplBase<Functor> \
114 |   { \
115 |     typedef QtMetacallAdapterImplBase<Functor> Base;\
116 |     QtMetacallAdapterImpl(const Functor& functor) : Base(functor) {} \
117 |     virtual bool invoke(const QGenericArgument* args, int count) const { \
118 | 	  (void)args;\
119 | 	  if (count < argCount) {\
120 | 	    return false; \
121 | 	  }\
122 | 	  Base::functor(invokeExpr);\
123 | 	  return true;\
124 | 	}\
125 | 	virtual int getArgTypes(QtMetacallArgsArray args) const {\
126 | 		(void)args;\
127 | 		return Base::fillArgTypes(args, argCount, argTypesExpr);\
128 | 	}\
129 |   };
130 | 
131 | QMA_DECLARE_ADAPTER_IMPL(0,/* empty */, 0 /* empty */)
132 | 
133 | QMA_DECLARE_ADAPTER_IMPL(1,
134 |   QMA_CAST_ARG(0),
135 |   QMA_ARG_TYPE(0)
136 | )
137 | 
138 | #define QMA_COMMA ,
139 | 
140 | QMA_DECLARE_ADAPTER_IMPL(2,
141 |   QMA_CAST_ARG(0) QMA_COMMA QMA_CAST_ARG(1),
142 |   QMA_ARG_TYPE(0) QMA_COMMA QMA_ARG_TYPE(1)
143 | )
144 | 
145 | QMA_DECLARE_ADAPTER_IMPL(3,
146 |   QMA_CAST_ARG(0) QMA_COMMA QMA_CAST_ARG(1) QMA_COMMA QMA_CAST_ARG(2),
147 |   QMA_ARG_TYPE(0) QMA_COMMA QMA_ARG_TYPE(1) QMA_COMMA QMA_ARG_TYPE(2)
148 | )
149 | 	
150 | QMA_DECLARE_ADAPTER_IMPL(4,
151 |   QMA_CAST_ARG(0) QMA_COMMA QMA_CAST_ARG(1) QMA_COMMA QMA_CAST_ARG(2) QMA_COMMA QMA_CAST_ARG(3),
152 |   QMA_ARG_TYPE(0) QMA_COMMA QMA_ARG_TYPE(1) QMA_COMMA QMA_ARG_TYPE(2) QMA_COMMA QMA_ARG_TYPE(3)
153 | )
154 | 
155 | QMA_DECLARE_ADAPTER_IMPL(5,
156 |   QMA_CAST_ARG(0) QMA_COMMA QMA_CAST_ARG(1) QMA_COMMA QMA_CAST_ARG(2) QMA_COMMA QMA_CAST_ARG(3) QMA_COMMA QMA_CAST_ARG(4),
157 |   QMA_ARG_TYPE(0) QMA_COMMA QMA_ARG_TYPE(1) QMA_COMMA QMA_ARG_TYPE(2) QMA_COMMA QMA_ARG_TYPE(3) QMA_COMMA QMA_ARG_TYPE(4)
158 | )
159 | 
160 | }
161 | 
162 | /** A wrapper around either a QtCallback or a function object (eg.
163 |  * std::tr1::function, boost::function, a C++11 lambda)
164 |  * which can invoke the function given an array of QGenericArgument objects.
165 |  */
166 | class QtMetacallAdapter
167 | {
168 | public:
169 | 	QtMetacallAdapter()
170 | 	{}
171 | 
172 | 	QtMetacallAdapter(const QtCallback& callback)
173 | 	: m_impl(new QtSignalTools::QtCallbackImpl(callback))
174 | 	{}
175 | 
176 | 	/** Construct a QtMetacallAdapter which invokes a function object
177 | 	 * (eg. std::function or boost::function)
178 | 	 */
179 | 	template <template <class Signature> class FunctionObject, class Signature>
180 | 	QtMetacallAdapter(const FunctionObject<Signature>& t)
181 | 	: m_impl(new QtSignalTools::QtMetacallAdapterImpl<FunctionObject<Signature>,QtSignalTools::FunctionTraits<Signature>::count>(t))
182 | 	{
183 | 	}
184 | 
185 | 	/** Construct a QtMetacallAdapter which invokes a plain function */
186 | 	template <class Functor>
187 | 	QtMetacallAdapter(Functor f)
188 | 	: m_impl(new QtSignalTools::QtMetacallAdapterImpl<Functor, QtSignalTools::FunctionTraits<typename QtSignalTools::ExtractSignature<Functor>::type>::count>(f))
189 | 	{
190 | 	}
191 | 
192 | 	QtMetacallAdapter(const QtMetacallAdapter& other)
193 | 	: m_impl(other.m_impl)
194 | 	{}
195 | 
196 | 	/** Attempts to invoke the receiver with a given set of arguments from
197 | 	 * a signal invocation.
198 | 	 */
199 | 	bool invoke(const QGenericArgument* args, int count) const
200 | 	{
201 | 		if (!m_impl) {
202 | 			return false;
203 | 		}
204 | 		return m_impl->invoke(args, count);
205 | 	}
206 | 
207 | 	/** Retrieves the count and types of arguments expected by the receiver */
208 | 	int getArgTypes(QtMetacallArgsArray args) const
209 | 	{
210 | 		if (!m_impl) {
211 | 			return 0;
212 | 		}
213 | 		return m_impl->getArgTypes(args);
214 | 	}
215 | 
216 | 	bool isNull() const
217 | 	{
218 | 		return m_impl.data() == 0;
219 | 	}
220 | 
221 | 	bool operator==(const QtMetacallAdapter& other) const
222 | 	{
223 | 		return m_impl == other.m_impl;
224 | 	}
225 | 
226 | 	bool operator!=(const QtMetacallAdapter& other) const
227 | 	{
228 | 		return m_impl != other.m_impl;
229 | 	}
230 | 
231 | private:
232 | 	QSharedDataPointer<QtSignalTools::QtMetacallAdapterImplIface> m_impl;
233 | };
234 | 
235 | 


--------------------------------------------------------------------------------
/QtSignalForwarder.cpp:
--------------------------------------------------------------------------------
  1 | #include "QtSignalForwarder.h"
  2 | 
  3 | #include <QtCore/QDebug>
  4 | #include <QtCore/QMutex>
  5 | #include <QtCore/QMutexLocker>
  6 | #include <QtCore/QSharedPointer>
  7 | #include <QtCore/QThread>
  8 | #include <QtCore/QTimer>
  9 | #include <QThreadStorage>
 10 | 
 11 | // method index of QObject::destroyed(QObject*) signal
 12 | const int DESTROYED_SIGNAL_INDEX = 0;
 13 | 
 14 | // minimum ID for method IDs used in signal bindings.
 15 | //
 16 | // These IDs are used by QtSignalForwarder::qt_metacall() to
 17 | // determine which binding to invoke.
 18 | const int BINDING_METHOD_MIN_ID = 1000;
 19 | 
 20 | // limit on number of signal bindings per proxy.
 21 | // Internally Qt stores receiver method IDs for signal connections
 22 | // in a 16-bit uint, so there is a constraint that
 23 | // BINDING_METHOD_MIN_ID + MAX_BINDINGS_PER_PROXY <= 2^16
 24 | const int MAX_BINDINGS_PER_PROXY = 10000;
 25 | 
 26 | // dummy function for use with the sentinel callback for when
 27 | // an object is destroyed. It should never actually be called.
 28 | void destroyBindingFunc()
 29 | {
 30 | 	Q_ASSERT(false);
 31 | }
 32 | QtMetacallAdapter QtSignalForwarder::s_senderDestroyedCallback(destroyBindingFunc);
 33 | 	
 34 | // per-thread arrays of shared proxies used by the static connect() method
 35 | Q_GLOBAL_STATIC(QThreadStorage<QVector<QSharedPointer<QtSignalForwarder> > >, sharedProxyList)
 36 | 
 37 | int qtObjectSignalIndex(const QObject* object, const char* signal)
 38 | {
 39 | 	const QMetaObject* metaObject = object->metaObject();
 40 | 	int signalIndex = metaObject->indexOfMethod(signal + 1);
 41 | 	if (signalIndex < 0) {
 42 | 		QByteArray normalizedSignature = QMetaObject::normalizedSignature(signal + 1);
 43 | 		signalIndex = metaObject->indexOfMethod(normalizedSignature.constData());
 44 | 	}
 45 | 	return signalIndex;
 46 | }
 47 | 
 48 | QtSignalForwarder::QtSignalForwarder(QObject* parent)
 49 | 	: QObject(parent)
 50 | {
 51 | }
 52 | 
 53 | QtSignalForwarder::~QtSignalForwarder()
 54 | {
 55 | }
 56 | 
 57 | bool QtSignalForwarder::checkTypeMatch(const QtMetacallAdapter& callback, const QList<QByteArray>& paramTypes)
 58 | {
 59 | 	int receiverArgTypes[QTMETACALL_MAX_ARGS] = {-1};
 60 | 	int receiverArgCount = callback.getArgTypes(receiverArgTypes);
 61 | 
 62 | 	for (int i=0; i < receiverArgCount; i++) {
 63 | 		if (i >= paramTypes.count()) {
 64 | 			qWarning() << "Missing argument" << i << ": "
 65 | 			  << "Receiver expects" << QLatin1String(QMetaType::typeName(receiverArgTypes[i]));
 66 | 			return false;
 67 | 		}
 68 | 		int type = QMetaType::type(paramTypes.at(i).data());
 69 | 		if (type != receiverArgTypes[i]) {
 70 | 			qWarning() << "Type mismatch for argument" << i << ": "
 71 | 			  << "Signal sends" << QLatin1String(QMetaType::typeName(type))
 72 | 			  << "receiver expects" << QLatin1String(QMetaType::typeName(receiverArgTypes[i]));
 73 | 			return false;
 74 | 		}
 75 | 	}
 76 | 
 77 | 	return true;
 78 | }
 79 | 
 80 | void QtSignalForwarder::setupDestroyNotify(QObject* sender)
 81 | {
 82 | 	if (!m_senderSignalBindingIds.contains(sender)) {
 83 | 		bind(sender, SIGNAL(destroyed(QObject*)), s_senderDestroyedCallback);
 84 | 	}
 85 | }
 86 | 
 87 | bool QtSignalForwarder::bind(QObject* sender, const char* signal, QObject *context,
 88 | 	const QtMetacallAdapter& callback
 89 | )
 90 | {
 91 | 	int signalIndex = qtObjectSignalIndex(sender, signal);
 92 | 	if (signalIndex < 0) {
 93 | 		qWarning() << "No such signal" << signal << "for" << sender;
 94 | 		return false;
 95 | 	}
 96 | 
 97 | 	Binding binding(sender, signalIndex, context, callback);
 98 | 	binding.paramTypes = sender->metaObject()->method(signalIndex).parameterTypes();
 99 | 
100 | 	if (!checkTypeMatch(callback, binding.paramTypes)) {
101 | 		qWarning() << "Sender and receiver types do not match for" << signal+1;
102 | 		return false;
103 | 	}
104 | 
105 | 	if (!canAddSignalBindings()) {
106 | 		qWarning() << "Limit of bindings per proxy has been reached";
107 | 		return false;
108 | 	}
109 | 
110 | 	if (m_freeSignalBindingIds.isEmpty()) {
111 | 		m_freeSignalBindingIds << BINDING_METHOD_MIN_ID + m_signalBindings.count();
112 | 	}
113 | 	int bindingId = m_freeSignalBindingIds.takeFirst();
114 | 	Q_ASSERT(!m_signalBindings.contains(bindingId));
115 | 
116 | 	// we use Qt::DirectConnection here, so the callback will always be invoked on the same
117 | 	// thread that the signal was delivered.  This ensures that we can rely on the object
118 | 	// still existing in the qt_metacall() implementation.  This also means that we don't
119 | 	// retain any QObject* pointers in the internal maps once the destroyed(QObject*) signal
120 | 	// has been emitted.
121 | 	//
122 | 	// If the binding's callback uses QtCallback, that will use a queued connection if the receiver
123 | 	// actually lives in a different thread.
124 | 	//
125 | 	if (!QMetaObject::connect(sender, signalIndex, this, bindingId, Qt::DirectConnection, 0)) {
126 | 		qWarning() << "Unable to connect signal" << signal << "for" << sender;
127 | 		return false;
128 | 	}
129 | 
130 | 	m_signalBindings.insert(bindingId, binding);
131 | 
132 | 	if (callback != s_senderDestroyedCallback) {
133 | 		// listen for destroyed(QObject*) signal to remove
134 | 		// all bindings.  setupDestroyNotify() in turn calls bind()
135 | 		// with s_senderDestroyedCallback as the callback
136 | 		setupDestroyNotify(sender);
137 | 	}
138 | 	
139 | 	m_senderSignalBindingIds.insertMulti(sender, bindingId);
140 | 
141 | 	if (context) {
142 | 		setupDestroyNotify(context);
143 | 		m_contextBindingIds.insertMulti(context, bindingId);
144 | 	}
145 | 
146 | 	return true;
147 | }
148 | 
149 | bool QtSignalForwarder::bind(QObject* sender, QEvent::Type event, const QtMetacallAdapter& callback, EventFilterFunc filter)
150 | {
151 | 	if (!checkTypeMatch(callback, QList<QByteArray>())) {
152 | 		qWarning() << "Callback does not take 0 arguments";
153 | 		return false;
154 | 	}
155 | 
156 | 	setupDestroyNotify(sender);
157 | 	sender->installEventFilter(this);
158 | 
159 | 	EventBinding binding(sender, event, callback, filter);
160 | 	m_eventBindings.insertMulti(sender, binding);
161 | 
162 | 	return true;
163 | }
164 | 
165 | void QtSignalForwarder::unbind(QObject* sender, const char* signal)
166 | {
167 | 	int signalIndex = qtObjectSignalIndex(sender, signal);
168 | 	QHash<QObject*,int>::iterator iter = m_senderSignalBindingIds.find(sender);
169 | 	while (iter != m_senderSignalBindingIds.end() && iter.key() == sender) {
170 | 		Q_ASSERT(m_signalBindings.contains(*iter));
171 | 		const Binding& binding = m_signalBindings.value(*iter);
172 | 		if (binding.signalIndex == signalIndex) {
173 | 			m_freeSignalBindingIds << *iter;
174 | 			QObject* context = m_signalBindings.take(*iter).context;
175 | 			m_contextBindingIds.remove(context, *iter);
176 | 			iter = m_senderSignalBindingIds.erase(iter);
177 | 		} else {
178 | 			++iter;
179 | 		}
180 | 	}
181 | 
182 | 	if (!isConnected(sender)) {
183 | 		// disconnect destruction notifications
184 | 		unbind(sender);
185 | 	}
186 | }
187 | 
188 | void QtSignalForwarder::unbind(QObject* sender, QEvent::Type event)
189 | {
190 | 	QHash<QObject*,EventBinding>::iterator iter = m_eventBindings.find(sender);
191 | 	while (iter != m_eventBindings.end() && iter.key() == sender) {
192 | 		if (iter->eventType == event) {
193 | 			iter = m_eventBindings.erase(iter);
194 | 		} else {
195 | 			++iter;
196 | 		}
197 | 	}
198 | 	if (!isConnected(sender)) {
199 | 		// disconnect destruction notifications
200 | 		unbind(sender);
201 | 	}
202 | }
203 | 
204 | void QtSignalForwarder::unbind(QObject* sender)
205 | {
206 | 	{
207 | 		QHash<QObject*,int>::iterator iter = m_senderSignalBindingIds.find(sender);
208 | 		while (iter != m_senderSignalBindingIds.end() && iter.key() == sender) {
209 | 			m_freeSignalBindingIds << *iter;
210 | 			QObject* context = m_signalBindings.take(*iter).context;
211 | 			m_contextBindingIds.remove(context, *iter);
212 | 			iter = m_senderSignalBindingIds.erase(iter);
213 | 		}
214 | 	}
215 | 	m_eventBindings.remove(sender);
216 | 
217 | 	sender->removeEventFilter(this);
218 | 	disconnect(sender, 0, this, 0);
219 | 
220 | 	{
221 | 		QHash<QObject*,int>::iterator iter = m_contextBindingIds.find(sender);
222 | 		while (iter != m_contextBindingIds.end() && iter.key() == sender) {
223 | 			m_freeSignalBindingIds << *iter;
224 | 			int id = *iter;
225 | 			Binding x = m_signalBindings.take(id);
226 | 			m_senderSignalBindingIds.remove(x.sender, *iter);
227 | 			iter = m_contextBindingIds.erase(iter);
228 | 			QMetaObject::disconnect(x.sender, x.signalIndex, this, id);
229 | 		}
230 | 	}
231 | 
232 | }
233 | 
234 | bool QtSignalForwarder::canAddSignalBindings() const
235 | {
236 | 	return m_signalBindings.count() < MAX_BINDINGS_PER_PROXY;
237 | }
238 | 
239 | QtSignalForwarder* QtSignalForwarder::sharedProxy(QObject* sender)
240 | {
241 | 	Q_UNUSED(sender);
242 | 
243 | 	// We try to use a small number of shared proxy objects to minimize
244 | 	// the overhead of each binding.
245 | 	//
246 | 	// There are some issues to consider when re-using proxies however:
247 | 	//
248 | 	// - Some operations in QObject's internals are linear in the number of
249 | 	//   connected senders, eg. sender(), senderSignalIndex()
250 | 	// - There is a limit on the number of signal bindings for any given proxy
251 | 	// - When using Qt::AutoConnection to connect the sender and receiver, the
252 | 	//   delivery method depends on the sender/receiver threads
253 | 	//
254 | 	QVector<QSharedPointer<QtSignalForwarder> > &proxies = sharedProxyList()->localData();
255 | 	if (proxies.isEmpty() || !proxies.last()->canAddSignalBindings()) {
256 | 		QtSignalForwarder* newProxy = new QtSignalForwarder();
257 | 		proxies << QSharedPointer<QtSignalForwarder>(newProxy);
258 | 	}
259 | 	return proxies.last().data();
260 | }
261 | 
262 | bool QtSignalForwarder::connect(QObject* sender, const char* signal, QObject *context, const QtMetacallAdapter& callback)
263 | {
264 | 	return sharedProxy(sender)->bind(sender, signal, context, callback);
265 | }
266 | 
267 | void QtSignalForwarder::disconnect(QObject* sender, const char* signal)
268 | {
269 | 	sharedProxy(sender)->unbind(sender, signal);
270 | }
271 | 
272 | bool QtSignalForwarder::connect(QObject* sender, QEvent::Type event, const QtMetacallAdapter& callback, EventFilterFunc filter)
273 | {
274 | 	return sharedProxy(sender)->bind(sender, event, callback, filter);
275 | }
276 | 
277 | void QtSignalForwarder::disconnect(QObject* sender, QEvent::Type event)
278 | {
279 | 	sharedProxy(sender)->unbind(sender, event);
280 | }
281 | 
282 | void QtSignalForwarder::failInvoke(const QString& error)
283 | {
284 | 	qWarning() << "Failed to invoke callback" << error;
285 | }
286 | 
287 | void QtSignalForwarder::invokeBinding(const Binding& binding, void** arguments)
288 | {
289 | 	const int MAX_ARGS = 10;
290 | 	int argCount = binding.paramTypes.count();
291 | 	QGenericArgument args[MAX_ARGS];
292 | 	for (int i=0; i < argCount; i++) {
293 | 		args[i] = QGenericArgument(binding.paramType(0), arguments[i+1]);
294 | 	}
295 | 	binding.callback.invoke(args, argCount);
296 | }
297 | 
298 | int QtSignalForwarder::qt_metacall(QMetaObject::Call call, int methodId, void** arguments)
299 | {
300 | 	if (methodId >= BINDING_METHOD_MIN_ID && call == QMetaObject::InvokeMetaMethod) {
301 | 		// signal binding invocation
302 | 		//
303 | 		// note: Avoid using sender() and senderSignalIndex() here as:
304 | 		// - The cost is linear in the number of connected senders
305 | 		// - Both functions involve a mutex lock on the sender
306 | 		// - The functions do not work for queued signals
307 | 		//
308 | 		QHash<int,Binding>::const_iterator iter = m_signalBindings.find(methodId);
309 | 		if (iter != m_signalBindings.end()) {
310 | 			if (iter->callback == s_senderDestroyedCallback) {
311 | 				unbind(iter->sender);
312 | 			} else {
313 | 				invokeBinding(*iter, arguments);
314 | 			}
315 | 		} else {
316 | 			failInvoke(QString("Unable to find matching binding for signal %1").arg(methodId));
317 | 		}
318 | 		return -1;
319 | 	} else {
320 | 		// standard qt_metacall() implementation
321 | 		return QObject::qt_metacall(call, methodId, arguments);
322 | 	}
323 | }
324 | 
325 | bool QtSignalForwarder::eventFilter(QObject* watched, QEvent* event)
326 | {
327 | 	QHash<QObject*,EventBinding>::iterator iter = m_eventBindings.find(watched);
328 | 	for (;iter != m_eventBindings.end() && iter.key() == watched; iter++) {
329 | 		const EventBinding& binding = iter.value();
330 | 		if (binding.eventType == event->type() &&
331 | 		    (!binding.filter || binding.filter(watched,event))) {
332 | 			binding.callback.invoke(0, 0);
333 | 		}
334 | 	}
335 | 	return QObject::eventFilter(watched, event);
336 | }
337 | 
338 | int QtSignalForwarder::bindingCount() const
339 | {
340 | 	int totalSignalBindings = 0;
341 | 	Q_FOREACH(const Binding& binding, m_signalBindings) {
342 | 		if (binding.callback != s_senderDestroyedCallback) {
343 | 			++totalSignalBindings;
344 | 		}
345 | 	}
346 | 	return totalSignalBindings + m_eventBindings.size();
347 | }
348 | 
349 | bool QtSignalForwarder::isConnected(QObject* sender) const
350 | {
351 | 	QHash<QObject*,int>::const_iterator signalBindingIter = m_senderSignalBindingIds.find(sender);
352 | 	while (signalBindingIter != m_senderSignalBindingIds.end() &&
353 | 	       signalBindingIter.key() == sender) {
354 | 		Q_ASSERT(m_signalBindings.contains(*signalBindingIter));
355 | 		const Binding& binding = m_signalBindings.value(*signalBindingIter);
356 | 		if (binding.callback != s_senderDestroyedCallback) {
357 | 			return true;
358 | 		}
359 | 		++signalBindingIter;
360 | 	}
361 | 	return m_eventBindings.contains(sender);
362 | }
363 | 
364 | void QtSignalForwarder::delayedCall(int ms, QObject *context, const QtMetacallAdapter& adapter)
365 | {
366 | 	QTimer* timer = new QTimer;
367 | 	timer->setSingleShot(true);
368 | 	timer->setInterval(ms);
369 | 	QtSignalForwarder::connect(timer, SIGNAL(timeout()), context, adapter);
370 | 	QObject::connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
371 | 	timer->start();
372 | }
373 | 
374 | bool QtSignalForwarder::connectWithSender(QObject* sender, const char* signal, QObject* receiver, const char* slot)
375 | {
376 | 	QtCallback callback(receiver, slot);
377 | 	int senderType = callback.parameterType(0);
378 | 	if (senderType == 0) {
379 | 		qWarning() << "Sender type for first argument of" << slot << "has not been registered with qRegisterMetaType<T>()";
380 | 		return false;
381 | 	}
382 | 	callback.bind(0, QVariant(senderType, &sender));
383 | 	return connect(sender, signal, callback);
384 | }
385 | 
386 | 


--------------------------------------------------------------------------------
/QtSignalForwarder.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "QtMetacallAdapter.h"
  4 | 
  5 | #include <QtCore/QEvent>
  6 | #include <QtCore/QVector>
  7 | 
  8 | /** QtSignalForwarder provides a way to connect Qt signals to QtCallback objects
  9 |  * or function objects (wrappers around functions such as std::tr1::function,
 10 |  * boost::function or std::function).
 11 |  * 
 12 |  * In Qt 5, this is supported natively using the new signal and slot syntax:
 13 |  * http://qt-project.org/wiki/New_Signal_Slot_Syntax .  This is especially useful
 14 |  * when combined with C++11's lambdas.
 15 |  *
 16 |  * QtSignalForwarder provides a way to simulate this under Qt 4 with C++03 by installing
 17 |  * a proxy object between the original sender of the signal and the receiver.  The proxy
 18 |  * receives the signal and then invokes the callback functor with the signal's arguments.
 19 |  *
 20 |  * Checking of signal and receiver argument types is done at runtime when setting up
 21 |  * a connection, as with normal signals and slots in Qt 4.
 22 |  *
 23 |  * Example usage, binding a signal with no arguments to a callback which invokes
 24 |  * a slot with one fixed argument:
 25 |  *
 26 |  *  MyObject receiver;
 27 |  *  QPushButton button;
 28 |  *  QtCallback callback(&receiver, SLOT(buttonClicked(int)));
 29 |  *  callback.bind(42);
 30 |  *  QtSignalForwarder::connect(&button, SIGNAL(clicked(bool)), callback);
 31 |  *  button.click();
 32 |  *
 33 |  * Will invoke Receiver::buttonClicked(42)
 34 |  *
 35 |  * You can also use QtSignalForwarder to invoke callbacks when an object receives an event
 36 |  * (as opposed to emits a signal).  For example:
 37 |  *
 38 |  *   QtSignalForwarder::connect(widget, QEvent::Enter,
 39 |  *     QtCallback(otherWidget, SLOT(setVisible(bool))).bind(true));
 40 |  *   QtSignalForwarder::connect(widget, QEvent::Leave,
 41 |  *     QtCallback(otherWidget, SLOT(setVisible(bool))).bind(false));
 42 |  *
 43 |  * Will show 'otherWidget' when the mouse hovers over 'widget' and hide it otherwise.
 44 |  */
 45 | class QtSignalForwarder : public QObject
 46 | {
 47 | 	// no Q_OBJECT macro here - see qt_metacall() re-implementation
 48 | 	// below
 49 | 	
 50 | 	public:
 51 | 		using QObject::connect;
 52 | 		using QObject::disconnect;
 53 | 
 54 | 		typedef bool (*EventFilterFunc)(QObject*,QEvent*);
 55 | 
 56 | 		QtSignalForwarder(QObject* parent = 0);
 57 | 		virtual ~QtSignalForwarder();
 58 | 
 59 | 		/** Set up a binding so that @p callback is invoked when
 60 | 		 * @p sender emits @p signal.  If @p signal has default arguments,
 61 | 		 * they must be specified.  eg. Use SLOT(clicked(bool)) for a button
 62 | 		 * rather than SLOT(clicked()).
 63 | 		 *
 64 | 		 * The @p callback argument can be a QtCallback object or a function
 65 | 		 * object (eg. std::tr1::function).
 66 | 		 *
 67 | 		 * The connection will automatically disconnect if the sender or the
 68 | 		 * @p context context is destroyed.
 69 | 		 */
 70 | 		bool bind(QObject* sender, const char* signal, QObject *context,
 71 | 			const QtMetacallAdapter& callback
 72 | 		);
 73 | 		bool bind(QObject* sender, const char* signal, const QtMetacallAdapter& callback)
 74 | 		{
 75 | 			return bind(sender, signal, 0, callback);
 76 | 		}
 77 | 
 78 | 		/** Set up a binding so that @p callback is invoked when @p sender
 79 | 		 * receives @p event.
 80 | 		 */
 81 | 		bool bind(QObject* sender, QEvent::Type event, const QtMetacallAdapter& callback, EventFilterFunc filter = 0);
 82 | 
 83 | 		/** Remove all bindings from a given @p sender and signal. */
 84 | 		void unbind(QObject* sender, const char* signal);
 85 | 
 86 | 		/** Remove all bindings from a given @p sender and event. */
 87 | 		void unbind(QObject* sender, QEvent::Type event);
 88 | 
 89 | 		/** Remove all bindings from a given @p sender. */
 90 | 		void unbind(QObject* sender);
 91 | 
 92 | 		/** Returns the total number of active bindings for this
 93 | 		 * QtSignalForwarder instance.
 94 | 		 */
 95 | 		int bindingCount() const;
 96 | 
 97 | 		bool isConnected(QObject* sender) const;
 98 | 
 99 | 		/** Schedule a delayed call to @p callback after @p minDelay ms.
100 | 		 *
101 | 		 * The connection will automatically disconnect if the
102 | 		 * @p context context is destroyed.
103 | 		 */
104 | 		static void delayedCall(int minDelay, QObject *context,
105 | 			const QtMetacallAdapter& callback
106 | 		);
107 | 		static void delayedCall(int minDelay, const QtMetacallAdapter& callback)
108 | 		{
109 | 			delayedCall(minDelay, 0, callback);
110 | 		}
111 | 
112 | 		// re-implemented from QObject (this method is normally declared via the Q_OBJECT
113 | 		// macro and implemented by the code generated by moc)
114 | 		virtual int qt_metacall(QMetaObject::Call call, int methodId, void** arguments);
115 | 
116 | 		// note: The static connect() and disconnect() functions may currently only
117 | 		// be used from the main application thread
118 | 
119 | 		/** Install a proxy which invokes @p callback when @p sender emits @p signal.
120 | 		 *
121 | 		 * The connection will automatically disconnect if the sender or the
122 | 		 * @p context context is destroyed.
123 | 		 */
124 | 		static bool connect(QObject* sender, const char* signal, QObject *context,
125 | 			const QtMetacallAdapter& callback
126 | 		);
127 | 		static bool connect(QObject* sender, const char* signal,
128 | 			const QtMetacallAdapter& callback
129 | 		)
130 | 		{
131 | 			return connect(sender, signal, 0, callback);
132 | 		}
133 | 
134 | 		static void disconnect(QObject* sender, const char* signal);
135 | 
136 | 		/** Install a proxy which invokes @p callback when @p sender receives @p event.
137 | 		 */
138 | 		static bool connect(QObject* sender, QEvent::Type event, const QtMetacallAdapter& callback, EventFilterFunc filter = 0);
139 | 		static void disconnect(QObject* sender, QEvent::Type event);
140 | 
141 | 		/** Convenience method which connects a signal to a slot which takes a pointer
142 | 		 * to the sender as the first argument. This can be used as an alternative to explicitly checking
143 | 		 * the sender in the slot itself or using QSignalMapper.
144 | 		 *
145 | 		 * In the current implementation, the receiver type must be registered using
146 | 		 * qRegisterMetaType<T>().
147 | 		 *
148 | 		 * For example: connectWithSender(myButton, SIGNAL(clicked()), myForm, SLOT(buttonClicked(QPushButton*)))
149 | 		 */
150 | 		static bool connectWithSender(QObject* sender, const char* signal, QObject* receiver, const char* slot);
151 | 
152 | 		// re-implemented from QObject
153 | 		virtual bool eventFilter(QObject* watched, QEvent* event);
154 | 
155 | 	private:
156 | 		struct Binding
157 | 		{
158 | 			Binding(QObject* _sender = 0, int _signalIndex = -1,
159 | 				QObject *_context = 0,
160 | 				const QtMetacallAdapter& _callback = QtMetacallAdapter()
161 | 			)
162 | 				: sender(_sender)
163 | 				, context(_context)
164 | 				, signalIndex(_signalIndex)
165 | 				, callback(_callback)
166 | 			{}
167 | 
168 | 			const char* paramType(int index) const
169 | 			{
170 | 				if (index >= paramTypes.count()) {
171 | 					return 0;
172 | 				}
173 | 				return paramTypes.at(index).constData();
174 | 			}
175 | 
176 | 			QObject* sender;
177 | 			QObject* context;
178 | 			int signalIndex;
179 | 			QList<QByteArray> paramTypes;
180 | 			QtMetacallAdapter callback;
181 | 		};
182 | 
183 | 		struct EventBinding
184 | 		{
185 | 			EventBinding(QObject* _sender = 0, QEvent::Type _type = QEvent::None, const QtMetacallAdapter& _callback = QtMetacallAdapter(),
186 | 			             EventFilterFunc _filter = 0)
187 | 				: sender(_sender)
188 | 				, eventType(_type)
189 | 				, filter(_filter)
190 | 				, callback(_callback)
191 | 			{}
192 | 
193 | 			QObject* sender;
194 | 			QEvent::Type eventType;
195 | 			EventFilterFunc filter;
196 | 			QtMetacallAdapter callback;
197 | 		};
198 | 
199 | 		// returns the first binding for (sender, signalIndex)
200 | 		const Binding* matchBinding(QObject* sender, int signalIndex) const;
201 | 		void failInvoke(const QString& error);
202 | 		void setupDestroyNotify(QObject* sender);
203 | 
204 | 		// returns false if the limit on the number of signal bindings
205 | 		// per proxy has been reached
206 | 		bool canAddSignalBindings() const;
207 | 
208 | 		static bool checkTypeMatch(const QtMetacallAdapter& callback, const QList<QByteArray>& paramTypes);
209 | 		static QtSignalForwarder* sharedProxy(QObject* sender);
210 | 		static void invokeBinding(const Binding& binding, void** arguments);
211 | 
212 | 		// map of sender -> signal binding IDs
213 | 		QMultiHash<QObject*,int> m_senderSignalBindingIds;
214 | 		// map of context -> signal binding IDs
215 | 		QMultiHash<QObject*,int> m_contextBindingIds;
216 | 		// map of binding ID -> binding
217 | 		QHash<int,Binding> m_signalBindings;
218 | 		QHash<QObject*,EventBinding> m_eventBindings;
219 | 
220 | 		// list of available method IDs for new signal
221 | 		// bindings
222 | 		QList<int> m_freeSignalBindingIds;
223 | 
224 | 		// a sentinel callback object for use with the automatically created
225 | 		// bindings to QObject::destroy(QObject*) used to detect when a bound
226 | 		// sender is destroyed
227 | 		static QtMetacallAdapter s_senderDestroyedCallback;
228 | };
229 | 
230 | Q_DECLARE_METATYPE(QtSignalForwarder*)
231 | 
232 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Qt Signal Tools
  2 | 
  3 | qt-signal-tools is a collection of utility classes related to signal and slots in Qt.  It includes:
  4 |  * QtCallback - Package up a receiver and slot arguments into an object for invoking later.
  5 |  * QtSignalForwarder - Connect signals and events from objects to QtCallback or arbitrary functions.
  6 |  * QtMetacallAdapter - Low-level interface for calling a function using a list of QGenericArgument() arguments.
  7 |  * safe_bind() - Create a wrapper around a method call which does nothing and returns a default value if
  8 |   the object is destroyed before the wrapper is called.
  9 | 
 10 | ## Requirements
 11 | 
 12 |  * Qt 4.6 (earliest version tested, may also work with older Qt 4.x releases) or Qt 5.x
 13 |  * The TR1 standard library (for C++03 compilers) or the C++11 standard library
 14 |   (for newer compilers when C++11 support is enabled).
 15 | 
 16 | ## Classes
 17 | 
 18 | ### QtCallback
 19 | 
 20 | QtCallback is a binder class which provides a way to create callbacks that invoke a signal or slot
 21 | when invoked, using a mixture of pre-bound arguments and arguments passed to QtCallback::invoke().
 22 | 
 23 | Usage:
 24 | ```cpp
 25 | QtCallback1<int> callback(myWidget, SLOT(someSlot(int,QString)));
 26 | callback.bind(42);
 27 | 
 28 | // invokes the MyWidget::someSlot() slot with arguments (42, "Hello World")
 29 | callback.invoke("Hello World");
 30 | 
 31 | void MyWidget::someSlot(int firstArg, const QString& secondArg)
 32 | {
 33 | }
 34 | ```
 35 | 
 36 | ### QtSignalForwarder
 37 | 
 38 | QtSignalForwarder provides a way to invoke callbacks when an object emits a signal or receives
 39 | a particular type of event.  The callbacks can be signals and slots
 40 | (via `QtCallback`) or arbitrary functions using `tr1::function`, `std::function`, `boost::function` or
 41 | a similar wrapper.
 42 | 
 43 | Qt 5 provides support for connecting signals to arbitrary functions out of the box and to lambdas
 44 | when using C++11.  QtSignalForwarder emulates this for Qt 4.
 45 | 
 46 | As well as being able to connect signals to functions that are not slots, this also provides
 47 | a way to pass additional arguments to the receiver other than those from the signal using `QtCallback::bind()`
 48 | or `std::tr1::bind()`.
 49 | 
 50 | Usage:
 51 | 
 52 | Connecting a signal to a slot with pre-bound arguments:
 53 | ```cpp
 54 | MyObject receiver;
 55 | QPushButton button;
 56 | QtSignalForwarder::connect(&button, SIGNAL(clicked(bool)),
 57 |   QtCallback(&receiver, SLOT(buttonClicked(int))).bind(42));
 58 | 
 59 | // invokes MyObject::buttonClicked() slot with arguments (42)
 60 | button.click();
 61 | ```
 62 | 
 63 | Connecting a signal to an arbitrary function:
 64 | ```cpp
 65 | using namespace std::tr1;
 66 | using namespace std::tr1::placeholders;
 67 | 
 68 | SomeObject receiver;
 69 | QLineEdit editor;
 70 | 
 71 | // function which calls someMethod() with the first-argument fixed (42) and the
 72 | // second string argument from the signal
 73 | function<void(int,QString)> callback(bind(&SomeObject::someMethod, &receiver, 42, _1));
 74 | 
 75 | QtSignalForwarder::connect(&editor, SIGNAL(textChanged(QString)), callback);
 76 |   
 77 | // invokes SomeObject::someMethod(42, "Hello World")
 78 | editor.setText("Hello World");
 79 | ```
 80 | 
 81 | ### Automatic disconnection
 82 | 
 83 | For standard signal-slot connections, Qt automatically removes the connection if either the sender
 84 | or receiver objects are destroyed.
 85 | 
 86 | When using QtSignalForwarder::connect(), the connection is automatically removed if the sender
 87 | is destroyed. However there is no receiver since the callback is a `function` object - which may
 88 | call a method on a QObject or it may call a function which is not a QObject method at all.
 89 | 
 90 | QtSignalTools provides two solutions to this:
 91 | 
 92 |  * `QtSignalForwarder::connect()` accepts an optional _context_ QObject*. The signal will automatically be
 93 |    disconnected if either the sender or the context object is destroyed. This is the approach that should be
 94 |    used if the callback is a method on a QObject. This behaves the same as the _context_ argument
 95 |    to `QObject::connect()` in Qt 5.2 and later. 
 96 |  * A more generic facility is to use the `safe_bind()` function which creates a wrapper around an object
 97 |    and a method call.  The wrapper can then be called with the same arguments as the wrapped method.
 98 |    When a call happens, either the wrapped method is called with the provided arguments, or if the object has
 99 |    been destroyed, nothing happens and a default value is returned. The wrapper created by `safe_bind()`
100 |    can be used with `bind()` and `function` and can be used together with `QtSignalForwarder` to
101 |    automatically 'disconnect' if the receiver is destroyed.
102 | 
103 | ```cpp
104 | QScopedPointer<QLabel> label(new QLabel);
105 | 
106 | // create a wrapper around label->setText() which can be run using
107 | // setTextWrapper(text).
108 | function<void(QString)> setTextWrapper = safe_bind(label.data(), &QLabel::setText);
109 | 
110 | // create a wrapper around label->text() which either calls label->text() and returns
111 | // the same result or returns an empty string if the label has been destroyed
112 | function<QString()> getTextWrapper = safe_bind(label.data(), &QLabel::text);
113 | 
114 | setTextWrapper("first update"); // sets the label's text to "first update"
115 | qDebug() << "label text" << getTextWrapper(); // prints "first update"
116 | label.reset(); // destroy the label
117 | setTextWrapper("second update"); // does nothing, as the label has been destroyed
118 | qDebug() << "label text" << getTextWrapper(); // prints an empty string
119 | ```
120 | 
121 | ### QtMetacallAdapter
122 | 
123 | QtMetacallAdapter is a low-level wrapper around a function or function object (eg. `std::function`)
124 | which can be used to invoke the function with a list of QGenericArgument (created by the Q_ARG() macro)
125 | and introspect the function's argument types at runtime.
126 | 
127 | ## License
128 | 
129 | qt-signal-tools is licensed under the BSD license.
130 | 
131 | ## Related Projects & Reading
132 | 
133 |  * Qt Signal Adapters - Library for connecting signals to Boost function objects: http://sourceforge.net/projects/qtsignaladapter/
134 |  * sigfwd - Library for connecting signals to function objects.  Uses Boost. https://bitbucket.org/edd/sigfwd/wiki/Home
135 |  * Qt 5 meta-object system changes - http://blog.qt.digia.com/blog/2012/06/22/changes-to-the-meta-object-system-in-qt-5/
136 | 


--------------------------------------------------------------------------------
/SafeBinder.h:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include "FunctionUtils.h"
  4 | #include "FunctionTraits.h"
  5 | 
  6 | #include <QtCore/QDebug>
  7 | #include <QtCore/QPointer>
  8 | #include <QtCore/QSharedPointer>
  9 | 
 10 | namespace QtSignalTools
 11 | {
 12 | 
 13 | // StrongRef is a helper class which takes
 14 | // a weak reference to an object and promotes
 15 | // it to a strong reference for the lifetime of the StrongRef instance,
 16 | // providing access to the underlying object via a data() method.
 17 | //
 18 | template <class T>
 19 | struct StrongRef;
 20 | 
 21 | // version for QWeakPointer<T>
 22 | template <class T>
 23 | struct StrongRef<QWeakPointer<T> >
 24 | {
 25 | 	StrongRef(QWeakPointer<T>& ref)
 26 | 		: m_strongRef(ref.toStrongRef())
 27 | 		, m_weakRef(ref)
 28 | 	{}
 29 | 
 30 | 	T* data() const {
 31 | 		if (m_strongRef) {
 32 | 			return m_strongRef.data();
 33 | 		} else {
 34 | 			// this may either be a QWeakPointer constructed
 35 | 			// from a QObject* which is not tracked by a QSharedPointer or
 36 | 			// the object may have been deleted, in which case data() will
 37 | 			// return 0
 38 | 			return m_weakRef.data();
 39 | 		}
 40 | 	}
 41 | 
 42 | 	QSharedPointer<T> m_strongRef;
 43 | 	QWeakPointer<T> m_weakRef;
 44 | };
 45 | 
 46 | // version for QPointer<T>.
 47 | template <class T>
 48 | struct StrongRef<QPointer<T> >
 49 | {
 50 | 	StrongRef(QPointer<T>& ref)
 51 | 		: m_ref(ref)
 52 | 	{
 53 | 		// There is no way to actually promote QPointer<T> to
 54 | 		// a strong reference, so we can't do that here as
 55 | 		// we do for other StrongRef implementations
 56 | 	}
 57 | 
 58 | 	T* data() const {
 59 | 		return m_ref.data();
 60 | 	}
 61 | 
 62 | 	QPointer<T> m_ref;
 63 | };
 64 | 
 65 | // version for weak_ptr<T>
 66 | template <template <class T> class WeakPointer, class T>
 67 | struct StrongRef<WeakPointer<T> >
 68 | {
 69 | 	StrongRef(WeakPointer<T>& ref)
 70 | 		: m_strongRef(ref.lock())
 71 | 	{}
 72 | 
 73 | 	T* data() const {
 74 | 		return m_strongRef.get();
 75 | 	}
 76 | 
 77 | 	shared_ptr<T> m_strongRef;
 78 | };
 79 | 
 80 | template <class Receiver, class MemberFunc>
 81 | class SafeBinder
 82 | {
 83 | 	public:
 84 | 		typedef typename MemberFuncResultType<MemberFunc>::type result_type;
 85 | 
 86 | 		SafeBinder(Receiver receiver, MemberFunc func)
 87 | 		: m_receiver(receiver)
 88 | 		, m_func(func)
 89 | 		{}
 90 | 
 91 | #define SAFE_BINDER_CALL_OP(typesExpr, paramExpr, argsExpr) \
 92 | 		typesExpr\
 93 | 		result_type operator()(paramExpr) {\
 94 | 			StrongRef<Receiver> strongRef(m_receiver);\
 95 | 			if (strongRef.data()) {\
 96 | 				return (strongRef.data()->*m_func)(argsExpr);\
 97 | 			} else {\
 98 | 				return result_type();\
 99 | 			}\
100 | 		}
101 | 
102 | #ifdef QST_COMPILER_SUPPORTS_VARIADIC_TEMPLATES
103 | 		SAFE_BINDER_CALL_OP(template <typename... Args>, Args... args, args...)
104 | #else
105 | 		SAFE_BINDER_CALL_OP(,,)
106 | 		SAFE_BINDER_CALL_OP(template <class T1>, const T1& arg1, arg1)
107 | 		SAFE_BINDER_CALL_OP(template <class T1 QST_COMMA class T2>,
108 | 							const T1& arg1 QST_COMMA const T2& arg2,
109 | 							arg1 QST_COMMA arg2);
110 | 		SAFE_BINDER_CALL_OP(template <class T1 QST_COMMA class T2 QST_COMMA class T3>,
111 | 							const T1& arg1 QST_COMMA const T2& arg2 QST_COMMA const T3& arg3,
112 | 							arg1 QST_COMMA arg2 QST_COMMA arg3);
113 | #endif
114 | 
115 | 	private:
116 | 		Receiver m_receiver;
117 | 		MemberFunc m_func;
118 | };
119 | 
120 | /** safe_bind() is a wrapper around a method call which does
121 |  * nothing and returns a default value if the object is destroyed
122 |  * before the call is invoked.
123 |  *
124 |  * The syntax is:
125 |  *   safe_bind(object, method)
126 |  *
127 |  * Where 'object' is either a QObject, a QWeakPointer<T> or a weak_ptr<T>
128 |  * that can be used to detect when the object is destroyed.
129 |  *
130 |  * Usage with QObject:
131 |  *
132 |  *   QObject* myObject = new QObject;
133 |  *   myObject->setObjectName("myObject");
134 |  *   function<QString()> getName(safe_bind(myObject, &QObject::objectName));
135 |  *   qDebug() << getName(); // prints "myObject"
136 |  *   delete myObject;
137 |  *   qDebug() << getName(); // prints ""
138 |  *
139 |  * Usage with a non-QObject class:
140 |  *
141 |  *   shared_ptr<Object> myObject(new Object);
142 |  *   myObject->setSomeProperty("foo");
143 |  *   function<QString()> getProperty(safe_bind(weak_ptr<Object>(myObject), &Object::someProperty));
144 |  *   qDebug() << getProperty(); // prints "foo"
145 |  *   myObject.reset();
146 |  *   qDebug() << getProperty(); // prints ""
147 |  */
148 | template <template <class T> class WeakPointer, class MemberFunc, class T>
149 | SafeBinder<WeakPointer<T>,MemberFunc> safe_bind(const WeakPointer<T>& r, MemberFunc f)
150 | {
151 | 	return SafeBinder<WeakPointer<T>,MemberFunc>(r,f);
152 | }
153 | 
154 | // Under Qt 4 QWeakPointer is the most efficient weak reference
155 | // to QObject.  Under Qt 5, QWeakPointer no longer integrates with
156 | // QObject but QPointer was instead re-written to be more efficient
157 | #if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
158 | template <class T, class MemberFunc>
159 | SafeBinder<QPointer<T>,MemberFunc> safe_bind(T* r, MemberFunc f,
160 |   typename enable_if<is_base_of<QObject,T>::value,T>::type* = 0)
161 | {
162 | 	return SafeBinder<QPointer<T>,MemberFunc>(r,f);
163 | }
164 | #else
165 | template <class T, class MemberFunc>
166 | SafeBinder<QWeakPointer<T>,MemberFunc> safe_bind(T* r, MemberFunc f,
167 |   typename enable_if<is_base_of<QObject,T>::value,T>::type* = 0)
168 | {
169 | 	return SafeBinder<QWeakPointer<T>,MemberFunc>(r,f);
170 | }
171 | #endif
172 | 
173 | }
174 | 
175 | 


--------------------------------------------------------------------------------
/examples/common.pri:
--------------------------------------------------------------------------------
1 | QT += network
2 | INCLUDEPATH += ../..
3 | HEADERS += ../../QtCallback.h ../../QtSignalForwarder.h
4 | SOURCES += ../../QtCallback.cpp ../../QtSignalForwarder.cpp
5 | 
6 | CONFIG -= app_bundle
7 | 


--------------------------------------------------------------------------------
/examples/ui-controls/UiDemo.cpp:
--------------------------------------------------------------------------------
 1 | #include "QtSignalForwarder.h"
 2 | 
 3 | #include <QApplication>
 4 | #include <QLabel>
 5 | #include <QMouseEvent>
 6 | #include <QPushButton>
 7 | #include <QSlider>
 8 | #include <QVBoxLayout>
 9 | 
10 | bool matchRightClick(QObject*, QEvent* event)
11 | {
12 | 	return static_cast<QMouseEvent*>(event)->button() == Qt::RightButton;
13 | }
14 | 
15 | int main(int argc, char** argv)
16 | {
17 | 	QApplication app(argc, argv);
18 | 
19 | 	QWidget* widget = new QWidget;
20 | 	
21 | 	QVBoxLayout* layout = new QVBoxLayout(widget);
22 | 
23 | 	QPushButton* button1 = new QPushButton("Set to 10%");
24 | 	QPushButton* button2 = new QPushButton("Set to 50%");
25 | 	QPushButton* button3 = new QPushButton("Set to 80%");
26 | 
27 | 	QLabel* hideMeLabel = new QLabel("Right click me to close");
28 | 
29 | 	QLabel* focusLabel = new QLabel("Slider is hovered");
30 | 	focusLabel->setVisible(false);
31 | 	QSlider* slider = new QSlider(Qt::Horizontal);
32 | 
33 | 	// create a callback object which sets the slider's value
34 | 	// and use QtSignalForwarder to invoke it when the button is
35 | 	// clicked
36 | 	QtCallback button1Callback(slider, SLOT(setValue(int)));
37 | 	button1Callback.bind(10);
38 | 	QtSignalForwarder::connect(button1, SIGNAL(clicked(bool)), button1Callback);
39 | 
40 | 	// setup another couple of buttons.
41 | 	// Here we use a more succinct syntax to create the callback
42 | 	QtSignalForwarder::connect(button2, SIGNAL(clicked(bool)),
43 | 	  QtCallback(slider, SLOT(setValue(int))).bind(50));
44 | 
45 | #ifdef ENABLE_QTCALLBACK_TR1_FUNCTION
46 | 	// if tr1/function is available, use that to create a callback
47 | 	QtSignalForwarder::connect(button3, SIGNAL(clicked(bool)),
48 | 	  std::tr1::function<void()>(std::tr1::bind(&QAbstractSlider::setValue, slider, 80)));
49 | #else
50 | 	QtSignalForwarder::connect(button3, SIGNAL(clicked(bool)),
51 | 	  QtCallback(slider, SLOT(setValue(int))).bind(80));
52 | #endif
53 | 
54 | 	QtSignalForwarder::connect(slider, QEvent::Enter,
55 | 	  QtCallback(focusLabel, SLOT(setVisible(bool))).bind(true));
56 | 
57 | 	QtSignalForwarder::connect(slider, QEvent::Leave,
58 | 	  QtCallback(focusLabel, SLOT(setVisible(bool))).bind(false));
59 | 
60 | 	QtSignalForwarder::connect(hideMeLabel, QEvent::MouseButtonRelease,
61 | 	  QtCallback(widget, SLOT(close())), matchRightClick);
62 | 
63 | 	layout->addWidget(button1);
64 | 	layout->addWidget(button2);
65 | 	layout->addWidget(button3);
66 | 	layout->addWidget(slider);
67 | 	layout->addWidget(focusLabel);
68 | 	
69 | 	layout->addStretch();
70 | 	
71 | 	layout->addWidget(hideMeLabel);
72 | 
73 | 	widget->show();
74 | 
75 | 	return app.exec();
76 | }
77 | 
78 | 


--------------------------------------------------------------------------------
/examples/ui-controls/ui-controls.pro:
--------------------------------------------------------------------------------
1 | include(../common.pri)
2 | 
3 | TEMPLATE = app
4 | QT += widgets
5 | 
6 | SOURCES += UiDemo.cpp
7 | 


--------------------------------------------------------------------------------
/examples/web-page-fetcher/WebPageDownloader.cpp:
--------------------------------------------------------------------------------
 1 | #include "WebPageDownloader.h"
 2 | 
 3 | #include "QtSignalForwarder.h"
 4 | 
 5 | #include <QtConcurrentRun>
 6 | #include <QtCore/QCoreApplication>
 7 | #include <QtCore/QDebug>
 8 | #include <QtCore/QFile>
 9 | 
10 | #include <QtNetwork/QNetworkReply>
11 | 
12 | Q_DECLARE_METATYPE(QNetworkReply*)
13 | 
14 | PageFetcher::PageFetcher(QObject* parent)
15 | 	: QObject(parent)
16 | {
17 | 	m_manager = new QNetworkAccessManager(this);
18 | }
19 | 
20 | void PageFetcher::fetchPage(const QUrl& url, const QtCallback1<QByteArray>& callback)
21 | {
22 | 	QNetworkReply* reply = m_manager->get(QNetworkRequest(url));
23 | 
24 | 	QtCallback finishedCallback(this, SLOT(requestFinished(QNetworkReply*,QtCallback1<QByteArray>)));
25 | 	finishedCallback.bind(reply);
26 | 	finishedCallback.bind(callback);
27 | 
28 | 	QtSignalForwarder::connect(reply, SIGNAL(finished()), finishedCallback);
29 | }
30 | 
31 | void PageFetcher::requestFinished(QNetworkReply* reply, const QtCallback1<QByteArray>& callback)
32 | {
33 | 	reply->deleteLater();
34 | 	callback.invoke(reply->readAll());
35 | }
36 | 
37 | WebPageDownloader::WebPageDownloader()
38 | 	: m_pendingRequests(0)
39 | {
40 | 	m_pageFetcher = new PageFetcher(this);
41 | }
42 | 
43 | void WebPageDownloader::savePage(const QUrl& url, const QString& fileName)
44 | {
45 | 	QtCallback1<QByteArray> callback(this, SLOT(fetchedPage(QString,QUrl,QByteArray)));
46 | 	callback.bind(fileName);
47 | 	callback.bind(url);
48 | 	m_pageFetcher->fetchPage(url, callback);
49 | 
50 | 	++m_pendingRequests;
51 | }
52 | 
53 | void WebPageDownloader::fetchedPage(const QString& fileName, const QUrl& url, const QByteArray& content)
54 | {
55 | 	qDebug() << "Saved" << url.toString() << "to" << fileName;
56 | 
57 | 	QFile file(fileName);
58 | 	file.open(QIODevice::WriteOnly);
59 | 	file.write(content);
60 | 	file.close();
61 | 
62 | 	--m_pendingRequests;
63 | 	if (m_pendingRequests == 0) {
64 | 		emit finished();
65 | 	}
66 | }
67 | 
68 | int main(int argc, char** argv)
69 | {
70 | 	QCoreApplication app(argc,argv);
71 | 
72 | 	WebPageDownloader client;
73 | 	client.savePage(QUrl("http://www.mendeley.com"), "mendeley.html");
74 | 	client.savePage(QUrl("http://www.google.com"), "google.html");
75 | 
76 | 	QObject::connect(&client, SIGNAL(finished()), &app, SLOT(quit()));
77 | 
78 | 	return app.exec();
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/examples/web-page-fetcher/WebPageDownloader.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "QtCallback.h"
 4 | 
 5 | #include <QtCore/QObject>
 6 | #include <QtNetwork/QNetworkAccessManager>
 7 | 
 8 | class PageFetcher : public QObject
 9 | {
10 | 	Q_OBJECT
11 | 
12 | 	public:
13 | 		PageFetcher(QObject* parent = 0);
14 | 
15 | 		/** Fetch the content of a URL and invoke a given callback when completed. */
16 | 		void fetchPage(const QUrl& url, const QtCallback1<QByteArray>& callback);
17 | 
18 | 	private Q_SLOTS:
19 | 		void requestFinished(QNetworkReply*, const QtCallback1<QByteArray>& callback);
20 | 
21 | 	private:
22 | 		QNetworkAccessManager* m_manager;
23 | };
24 | 
25 | Q_DECLARE_METATYPE(QtCallback1<QByteArray>);
26 | 
27 | /** Downloads web pages and saves them to a file.
28 |  *  This is acts as a client of the PageFetcher class.
29 |  */
30 | class WebPageDownloader : public QObject
31 | {
32 | 	Q_OBJECT
33 | 
34 | 	public:
35 | 		WebPageDownloader();
36 | 
37 | 		void savePage(const QUrl& url, const QString& fileName);
38 | 
39 | 	Q_SIGNALS:
40 | 		void finished();
41 | 
42 | 	private Q_SLOTS:
43 | 		void fetchedPage(const QString& fileName, const QUrl& url, const QByteArray& content);
44 | 
45 | 	private:
46 | 		PageFetcher* m_pageFetcher;
47 | 
48 | 		int m_pendingRequests;
49 | };
50 | 
51 | 


--------------------------------------------------------------------------------
/examples/web-page-fetcher/web-page-fetcher.pro:
--------------------------------------------------------------------------------
1 | include(../common.pri)
2 | 
3 | TEMPLATE = app
4 | QT += concurrent
5 | 
6 | HEADERS += WebPageDownloader.h
7 | SOURCES += WebPageDownloader.cpp
8 | 


--------------------------------------------------------------------------------
/qt-callbacks.pro:
--------------------------------------------------------------------------------
1 | TEMPLATE = subdirs
2 | SUBDIRS = tests \
3 |           examples/web-page-fetcher \
4 |           examples/ui-controls
5 | 


--------------------------------------------------------------------------------
/tests/TestQtSignalTools.cpp:
--------------------------------------------------------------------------------
  1 | #include "TestQtSignalTools.h"
  2 | 
  3 | #include "SafeBinder.h"
  4 | 
  5 | #include <QtCore/QDebug>
  6 | #include <QtCore/QEventLoop>
  7 | 
  8 | #if QT_VERSION >= QT_VERSION_CHECK(4,8,0)
  9 | #include <QtCore/QElapsedTimer>
 10 | #endif
 11 | 
 12 | #include <QtCore/QThread>
 13 | 
 14 | #include <iostream>
 15 | 
 16 | #if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
 17 | #define SKIP_TEST(message) QSKIP(message)
 18 | #else
 19 | #define SKIP_TEST(message) QSKIP(message, SkipAll)
 20 | #endif
 21 | 
 22 | #if defined(QST_USE_CPP11_LIBS)
 23 | using namespace std;
 24 | using namespace std::placeholders;
 25 | #else
 26 | using namespace std::tr1;
 27 | using namespace std::tr1::placeholders;
 28 | #endif
 29 | 
 30 | using namespace QtSignalTools;
 31 | 
 32 | struct CallCounter
 33 | {
 34 | 	CallCounter()
 35 | 		: count(0)
 36 | 	{}
 37 | 
 38 | 	int count;
 39 | 
 40 | 	void increment() {
 41 | 		++count;
 42 | 	}
 43 | };
 44 | 
 45 | struct TestThread : public QThread
 46 | {
 47 | 	TestThread(const function<void()>& func, QObject* parent)
 48 | 		: QThread(parent)
 49 | 		, threadFunc(func)
 50 | 	{}
 51 | 
 52 | 	virtual void run()
 53 | 	{
 54 | 		threadFunc();
 55 | 	}
 56 | 
 57 | 	function<void()> threadFunc;
 58 | };
 59 | 
 60 | void TestQtSignalTools::testInvoke()
 61 | {
 62 | 	CallbackTester tester;
 63 | 	QtCallback callback1(&tester, SLOT(addValue(int)));
 64 | 	callback1.bind(42);
 65 | 	callback1.invoke();
 66 | 	QCOMPARE(tester.values, QList<int>() << 42);
 67 | 	tester.values.clear();
 68 | 
 69 | 	QtCallback1<int> callback2(&tester, SLOT(addValue(int)));
 70 | 	callback2.invoke(27);
 71 | 	QCOMPARE(tester.values, QList<int>() << 27);
 72 | }
 73 | 
 74 | void TestQtSignalTools::testSignalProxy()
 75 | {
 76 | 	CallbackTester tester;
 77 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)),
 78 | 	  QtCallback(&tester, SLOT(addValue(int))));
 79 | 	tester.emitASignal(32);
 80 | 
 81 | 	QCOMPARE(tester.values, QList<int>() << 32);
 82 | 	tester.values.clear();
 83 | 
 84 | 	QtSignalForwarder::disconnect(&tester, SIGNAL(aSignal(int)));
 85 | 
 86 | 	tester.emitASignal(15);
 87 | 	QCOMPARE(tester.values, QList<int>());
 88 | 	tester.values.clear();
 89 | 
 90 | 	QVERIFY(QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)),
 91 | 	  QtCallback(&tester, SLOT(addValue(int))).bind(10)));
 92 | 	tester.emitASignal(11);
 93 | 	QCOMPARE(tester.values, QList<int>() << 10);
 94 | 	tester.values.clear();
 95 | 
 96 | 	QVERIFY(!QtSignalForwarder::connect(&tester, SIGNAL(noArgSignal()),
 97 | 	  QtCallback(&tester, SLOT(addValue(int)))));
 98 | 	tester.emitNoArgSignal();
 99 | 	QCOMPARE(tester.values, QList<int>());
100 | }
101 | 
102 | void TestQtSignalTools::testEventProxy()
103 | {
104 | 	CallbackTester tester;
105 | 	QtSignalForwarder::connect(&tester, QEvent::MouseButtonPress,
106 | 	  QtCallback(&tester, SLOT(addValue(int))).bind(1));
107 | 	QMouseEvent event(QEvent::MouseButtonPress, QPoint(0,0), Qt::LeftButton, Qt::LeftButton, 0);
108 | 	QCoreApplication::sendEvent(&tester, &event);
109 | 	QCOMPARE(tester.values, QList<int>() << 1);
110 | 	tester.values.clear();
111 | 
112 | 	QtSignalForwarder::disconnect(&tester, QEvent::MouseButtonPress);
113 | 	QCoreApplication::sendEvent(&tester, &event);
114 | 	QCOMPARE(tester.values, QList<int>());
115 | }
116 | 
117 | void TestQtSignalTools::testSignalToFunctionObject()
118 | {
119 | 	CallbackTester tester;
120 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)),
121 | 	  function<void()>(bind(&CallbackTester::addValue, &tester, 18)));
122 | 	tester.emitASignal(42);
123 | 	QCOMPARE(tester.values, QList<int>() << 18);
124 | 	tester.values.clear();
125 | 
126 | 	QtSignalForwarder::disconnect(&tester, SIGNAL(aSignal(int)));
127 | 	tester.emitASignal(19);
128 | 	QCOMPARE(tester.values, QList<int>());
129 | 	tester.values.clear();
130 | 
131 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)),
132 | 	  function<void(int)>(bind(&CallbackTester::addValue, &tester, _1)));
133 | 	tester.emitASignal(39);
134 | 	QCOMPARE(tester.values, QList<int>() << 39);
135 | 
136 | 	// check that a signal arg count mismatch
137 | 	// is caught
138 | 	tester.values.clear();
139 | 	QtSignalForwarder::connect(&tester, SIGNAL(noArgSignal()),
140 | 	  function<void(int)>(bind(&CallbackTester::addValue, &tester, _1)));
141 | 	tester.emitNoArgSignal();
142 | 	QCOMPARE(tester.values, QList<int>());
143 | }
144 | 
145 | int sumInputs(int value)
146 | {
147 | 	static int total = 0;
148 | 	total += value;
149 | 	return total;
150 | }
151 | 
152 | void TestQtSignalTools::testSignalToPlainFunc()
153 | {
154 | 	CallbackTester tester;
155 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), sumInputs);
156 | 	tester.emitASignal(5);
157 | 	tester.emitASignal(8);
158 | 	QCOMPARE(sumInputs(0), 13);
159 | }
160 | 
161 | void TestQtSignalTools::testArgCast()
162 | {
163 | 	// use function and bind() to perform a cast of the argument
164 | 	// when it is emitted.
165 | 	QList<qint64> list;
166 | 	CallbackTester tester;
167 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)),
168 | 	  function<void(int)>(bind(&QList<qint64>::push_back, &list, _1)));
169 | 	tester.emitASignal(42);
170 | 	QCOMPARE(list, QList<qint64>() << 42LL);
171 | }
172 | 
173 | void floatFunc(float) {}
174 | void intFunc(int) {}
175 | void noArgsFunc() {}
176 | void twoArgsFunc(int,int) {}
177 | 
178 | void TestQtSignalTools::testArgTypeCheck()
179 | {
180 | 	CallbackTester tester;
181 | 	QVERIFY(QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), intFunc));
182 | 	QVERIFY(!QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), floatFunc));
183 | 	QVERIFY(QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), noArgsFunc));
184 | 	QVERIFY(!QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), twoArgsFunc));
185 | }
186 | 
187 | void fiveArgFunc(int,bool,float,char,double) {}
188 | 
189 | void TestQtSignalTools::testArgLimit()
190 | {
191 | 	QtMetacallAdapter adapter(fiveArgFunc);
192 | 	QtMetacallArgsArray args = {-1};
193 | 	int count = adapter.getArgTypes(args);
194 | 	QStringList argList;
195 | 	for (int i=0; i < count; i++) {
196 | 		argList << QMetaType::typeName(args[i]);
197 | 	}
198 | 	QCOMPARE(argList, QStringList() << "int" << "bool" << "float" << "char" << "double");
199 | }
200 | 
201 | void TestQtSignalTools::testSignalToLambda()
202 | {
203 | #ifdef QST_COMPILER_SUPPORTS_LAMBDAS
204 | 	CallbackTester tester;
205 | 	int sum = 0;
206 | 	QtSignalForwarder::connect(&tester, SIGNAL(aSignal(int)), function<void(int)>(
207 | 										 [&](int value) { sum += value; }
208 | 	));
209 | 	tester.emitASignal(12);
210 | 	tester.emitASignal(7);
211 | 	QCOMPARE(sum, 19);
212 | #else
213 | 	SKIP_TEST("Compiler does not support C++11 lambdas");
214 | #endif
215 | }
216 | 
217 | void TestQtSignalTools::testSenderDestroyed()
218 | {
219 | 	QScopedPointer<CallbackTester> tester(new CallbackTester);
220 | 	QtSignalForwarder proxy;
221 | 	proxy.bind(tester.data(), SIGNAL(aSignal(int)),
222 | 	  noArgsFunc);
223 | 	QCOMPARE(proxy.bindingCount(), 1);
224 | 	tester.reset();
225 | 	QCOMPARE(proxy.bindingCount(), 0);
226 | 
227 | 	tester.reset(new CallbackTester);
228 | 	proxy.bind(tester.data(), QEvent::MouseButtonPress, noArgsFunc);
229 | 	QCOMPARE(proxy.bindingCount(), 1);
230 | 	tester.reset();
231 | 	QCOMPARE(proxy.bindingCount(), 0);
232 | }
233 | 
234 | void TestQtSignalTools::testUnbind()
235 | {
236 | 	CallbackTester tester;
237 | 	QtSignalForwarder proxy;
238 | 	
239 | 	proxy.bind(&tester, SIGNAL(aSignal(int)), noArgsFunc);
240 | 	QCOMPARE(proxy.bindingCount(), 1);
241 | 	QVERIFY(proxy.isConnected(&tester));
242 | 
243 | 	QCOMPARE(tester.receiverCount(SIGNAL(aSignal(int))), 1);
244 | 	QCOMPARE(tester.receiverCount(SIGNAL(destroyed(QObject*))), 1);
245 | 
246 | 	proxy.bind(&tester, QEvent::MouseButtonPress, noArgsFunc);
247 | 	QCOMPARE(proxy.bindingCount(), 2);
248 | 
249 | 	proxy.unbind(&tester, SIGNAL(aSignal(int)));
250 | 	QCOMPARE(proxy.bindingCount(), 1);
251 | 	QVERIFY(proxy.isConnected(&tester));
252 | 
253 | 	// check that the proxy is still listening for destruction
254 | 	// of the sender
255 | 	QCOMPARE(tester.receiverCount(SIGNAL(destroyed(QObject*))), 1);
256 | 
257 | 	proxy.unbind(&tester, QEvent::MouseButtonPress);
258 | 	QCOMPARE(proxy.bindingCount(), 0);
259 | 	QVERIFY(!proxy.isConnected(&tester));
260 | 
261 | 	// check that the proxy is no longer listening for destruction
262 | 	// of the sender
263 | 	QCOMPARE(tester.receiverCount(SIGNAL(destroyed(QObject*))), 0);
264 | }
265 | 
266 | void TestQtSignalTools::testProxyBindingLimits()
267 | {
268 | 	CallbackTester tester;
269 | 	CallCounter counter;
270 | 
271 | 	int bindingCount = 100000;
272 | 	function<void()> incrementFunc = bind(&CallCounter::increment, &counter);
273 | 	for (int i=0; i < bindingCount; i++) {
274 | 		if (!QtSignalForwarder::connect(&tester, SIGNAL(noArgSignal()), incrementFunc)) {
275 | 			// note - we don't use QVERIFY() around the call to QtSignalForwarder::connect() because it
276 | 			// is slow
277 | 			QVERIFY(false);
278 | 		}
279 | 	}
280 | 	tester.emitNoArgSignal();
281 | 	QCOMPARE(counter.count, bindingCount);
282 | }
283 | 
284 | void TestQtSignalTools::testConnectPerf()
285 | {
286 | #if QT_VERSION >= QT_VERSION_CHECK(4,8,0)
287 | 	SKIP_TEST("Benchmark disabled");
288 | 
289 | 	CallbackTester receiver;
290 | 
291 | 	int objCount = 2;
292 | 
293 | 	for (int i = 0; i < 15; i++) {
294 | 		qDebug() << "testing with step" << i;
295 | 		QElapsedTimer timer;
296 | 		timer.start();
297 | 
298 | 		QVector<CallbackTester*> objectList;
299 | 		for (int k=0; k < objCount; k++) {
300 | 			objectList << new CallbackTester;
301 | 			if (!QtSignalForwarder::connect(objectList.last(), SIGNAL(aSignal(int)),
302 | 					function<void(int)>(bind(&CallbackTester::addValue, &receiver, 42)))) {
303 | 				qWarning() << "Failed to connect signal";
304 | 			}
305 | 			objectList.last()->emitASignal(32);
306 | 		}
307 | 		qDeleteAll(objectList);
308 | 		objectList.clear();
309 | 
310 | 		qreal totalMs = timer.nsecsElapsed() / (1000 * 1000);
311 | 		qreal meanMs = totalMs/objCount;
312 | 		qDebug() << "cost per obj for" << objCount << "objects" << meanMs << "total" << totalMs;
313 | 
314 | 		objCount *= 2;
315 | 	}
316 | #endif
317 | }
318 | 
319 | void TestQtSignalTools::testDelayedCall()
320 | {
321 | #if QT_VERSION >= QT_VERSION_CHECK(4,8,0)
322 | 	CallbackTester tester;
323 | 	QEventLoop loop;
324 | 
325 | 	connect(&tester, SIGNAL(valuesChanged()), &loop, SLOT(quit()));
326 | 	
327 | 	// on Windows under Qt 4, the timeout occasionally expires
328 | 	// slightly before the specified interval, so here we
329 | 	// only check that there was some delay before
330 | 	// the timeout occurred.
331 | 	const int CALL_DELAY = 50;
332 | 	const int MIN_ACTUAL_DELAY = 25;
333 | 
334 | 	QElapsedTimer timer;
335 | 	timer.start();
336 | 	QtSignalForwarder::delayedCall(CALL_DELAY, function<void()>(bind(&CallbackTester::addValue, &tester, 42)));
337 | 	loop.exec();
338 | 
339 | 	QVERIFY(timer.elapsed() >= MIN_ACTUAL_DELAY);
340 | 	QCOMPARE(tester.values, QList<int>() << 42);
341 | #endif
342 | }
343 | 
344 | void TestQtSignalTools::testSafeBinder()
345 | {
346 | 	// test with a QObject
347 | 	QObject* object = new QObject;
348 | 	object->setObjectName("testObject");
349 | 	function<QString()> getName(safe_bind(object, &QObject::objectName));
350 | 	QCOMPARE(getName(), QString("testObject"));
351 | 	delete object;
352 | 	object = 0;
353 | 	QCOMPARE(getName(), QString());
354 | 
355 | 	CallbackTester tester;
356 | 	object = new QObject;
357 | 
358 | 	// test with QObject + QtSignalForwarder
359 | 	QtSignalForwarder::connect(&tester, SIGNAL(stringSignal(QString)),
360 | 	  function<void(QString)>(safe_bind(object, &QObject::setObjectName)));
361 | 	tester.emitStringSignal("testObject2");
362 | 	QCOMPARE(object->objectName(), QString("testObject2"));
363 | 	delete object;
364 | 
365 | 	// try changing the name, this will have no effect now
366 | 	// as the object has been destroyed
367 | 	tester.emitStringSignal("newName");
368 | 
369 | 	// test with something that is not
370 | 	// a QObject
371 | 	shared_ptr<QString> string(new QString);
372 | 	string->append("testString");
373 | 	function<QString()> getTrimmed(safe_bind(weak_ptr<QString>(string), &QString::trimmed));
374 | 	QCOMPARE(getTrimmed(), QString("testString"));
375 | 	string.reset();
376 | 	QCOMPARE(getTrimmed(), QString());
377 | }
378 | 
379 | function<void()> incrementFunc(CallCounter& counter)
380 | {
381 | 	return bind(&CallCounter::increment, &counter);
382 | }
383 | 
384 | void TestQtSignalTools::testBindingCount()
385 | {
386 | 	CallCounter firstSignalCall;
387 | 	CallCounter secondSignalCall;
388 | 
389 | 	CallCounter firstEventCall;
390 | 	CallCounter secondEventCall;
391 | 
392 | 	CallbackTester tester;
393 | 
394 | 	QtSignalForwarder forwarder;
395 | 	forwarder.bind(&tester, SIGNAL(aSignal(int)), incrementFunc(firstSignalCall));
396 | 	forwarder.bind(&tester, SIGNAL(aSignal(int)), incrementFunc(secondSignalCall));
397 | 	QCOMPARE(forwarder.bindingCount(), 2);
398 | 
399 | 	tester.emitASignal(1);
400 | 	QCOMPARE(firstSignalCall.count, 1);
401 | 	QCOMPARE(secondSignalCall.count, 1);
402 | 
403 | 	forwarder.unbind(&tester);
404 | 	QCOMPARE(forwarder.bindingCount(), 0);
405 | 
406 | 	forwarder.bind(&tester, QEvent::Enter, incrementFunc(firstEventCall));
407 | 	forwarder.bind(&tester, QEvent::Leave, incrementFunc(secondEventCall));
408 | 	QCOMPARE(forwarder.bindingCount(), 2);
409 | 
410 | 	QEvent enterEvent(QEvent::Enter);
411 | 	QEvent leaveEvent(QEvent::Leave);
412 | 	QCoreApplication::sendEvent(&tester, &enterEvent);
413 | 	QCoreApplication::sendEvent(&tester, &leaveEvent);
414 | 
415 | 	QCOMPARE(firstEventCall.count, 1);
416 | 	QCOMPARE(secondEventCall.count, 1);
417 | 
418 | 	forwarder.unbind(&tester);
419 | 	QCOMPARE(forwarder.bindingCount(), 0);
420 | }
421 | 
422 | void TestQtSignalTools::testManySenders()
423 | {
424 | 	typedef QSet<CallbackTester*>::const_iterator SetIter;
425 | 
426 | 	QList<CallbackTester*> senders;
427 | 	QSet<CallbackTester*> receivedSenders;
428 | 	for (int i=0; i < 100; i++) {
429 | 		senders << new CallbackTester;
430 | 		function<SetIter()> insertFunc = bind(&QSet<CallbackTester*>::insert, &receivedSenders, senders.last());
431 | 		QtSignalForwarder::connect(senders.last(), SIGNAL(noArgSignal()), insertFunc);
432 | 	}
433 | 	Q_FOREACH(CallbackTester* sender, senders) {
434 | 		sender->emitNoArgSignal();
435 | 	}
436 | 	QCOMPARE(receivedSenders.count(), senders.count());
437 | }
438 | 
439 | void TestQtSignalTools::testConnectWithSender()
440 | {
441 | 	qRegisterMetaType<CallbackTester*>("CallbackTester*");
442 | 
443 | 	CallbackTester sender;
444 | 	QtSignalForwarder::connectWithSender(&sender, SIGNAL(aSignal(int)),
445 | 	  &sender, SLOT(addValueIfSenderIsSelf(CallbackTester*,int)));
446 | 	sender.emitASignal(34);
447 | 	QCOMPARE(sender.values, QList<int>() << 34);
448 | }
449 | 
450 | class TestRef
451 | {
452 | public:
453 | 	static int s_count;
454 | 	TestRef() { s_count++; }
455 | 	TestRef(const TestRef &) { s_count++; }
456 | 	~TestRef() { s_count--; }
457 | };
458 | 
459 | int TestRef::s_count;
460 | 
461 | void testContext(const TestRef &, int *x)
462 | {
463 | 	if (x) {
464 | 		(*x)++;
465 | 	}
466 | };
467 | 
468 | void TestQtSignalTools::testContextDestroyed()
469 | {
470 | 	QCOMPARE(TestRef::s_count, 0);
471 | 	CallbackTester tester;
472 | 	QObject* context = new QObject();
473 | 	int x = 0;
474 | 	QtSignalForwarder::connect(&tester, SIGNAL(noArgSignal()), context,
475 | 		function<void()>(bind(testContext, TestRef(), &x))
476 | 	);
477 | 	QtSignalForwarder::connect(&tester, SIGNAL(noArgSignal()),
478 | 		function<void()>(bind(testContext, TestRef(), &x))
479 | 	);
480 | 	QCOMPARE(TestRef::s_count, 2);
481 | 	QCOMPARE(x, 0);
482 | 	QCOMPARE(tester.receiverCount(SIGNAL(noArgSignal())), 2);
483 | 	tester.emitNoArgSignal();
484 | 	QCOMPARE(x, 2);
485 | 	delete context;
486 | 	QCOMPARE(tester.receiverCount(SIGNAL(noArgSignal())), 1);
487 | 	tester.emitNoArgSignal();
488 | 	QCOMPARE(TestRef::s_count, 1);
489 | 	QCOMPARE(x, 3);
490 | }
491 | 
492 | void TestQtSignalTools::testContextDestroyedEqualsSender()
493 | {
494 | 	QCOMPARE(TestRef::s_count, 0);
495 | 	CallbackTester* tester = new CallbackTester();
496 | 	QtSignalForwarder::connect(tester, SIGNAL(noArgSignal()), tester,
497 | 		function<void()>(bind(testContext, TestRef(), (int *) 0))
498 | 	);
499 | 	delete tester;
500 | 	QCOMPARE(TestRef::s_count, 0);
501 | }
502 | 
503 | void TestQtSignalTools::testContextDestroyedShared()
504 | {
505 | 	QCOMPARE(TestRef::s_count, 0);
506 | 	CallbackTester* tester1 = new CallbackTester();
507 | 	CallbackTester* tester2 = new CallbackTester();
508 | 	QObject* context = new QObject();
509 | 	QtSignalForwarder::connect(tester1, SIGNAL(noArgSignal()), tester2,
510 | 		function<void()>(bind(testContext, TestRef(), (int *) 0))
511 | 	);
512 | 	QtSignalForwarder::connect(tester2, SIGNAL(noArgSignal()), context,
513 | 		function<void()>(bind(testContext, TestRef(), (int *) 0))
514 | 	);
515 | 	QCOMPARE(TestRef::s_count, 2);
516 | 	delete tester2;
517 | 	QCOMPARE(TestRef::s_count, 0);
518 | 	delete tester1;
519 | 	QCOMPARE(TestRef::s_count, 0);
520 | }
521 | 
522 | void testConnectFromThread()
523 | {
524 | 	CallbackTester t1;
525 | 	QtSignalForwarder::connect(&t1, SIGNAL(aSignal(int)),
526 | 	  QtCallback(&t1, SLOT(addValue(int))));
527 | 	t1.emitASignal(32);
528 | 	QCOMPARE(t1.values, QList<int>() << 32);
529 | }
530 | 
531 | void TestQtSignalTools::testThread()
532 | {
533 | 	TestThread t1(testConnectFromThread, 0);
534 | 	TestThread t2(testConnectFromThread, 0);
535 | 	t1.start();
536 | 	t2.start();
537 | 	QVERIFY(t1.wait());
538 | 	QVERIFY(t2.wait());
539 | }
540 | 
541 | QTEST_MAIN(TestQtSignalTools)
542 | 


--------------------------------------------------------------------------------
/tests/TestQtSignalTools.h:
--------------------------------------------------------------------------------
 1 | #include <QtTest/QTest>
 2 | 
 3 | #include "QtCallback.h"
 4 | #include "QtSignalForwarder.h"
 5 | #include "FunctionUtils.h"
 6 | 
 7 | class TestQtSignalTools : public QObject
 8 | {
 9 | 	Q_OBJECT
10 | 
11 | 	private Q_SLOTS:
12 | 		void testInvoke();
13 | 		void testSignalProxy();
14 | 		void testEventProxy();
15 | 		void testSignalToFunctionObject();
16 | 		void testSignalToPlainFunc();
17 | 		void testArgCast();
18 | 		void testArgTypeCheck();
19 | 		void testArgLimit();
20 | 		void testSignalToLambda();
21 | 		void testSenderDestroyed();
22 | 		void testUnbind();
23 | 		void testDelayedCall();
24 | 		void testSafeBinder();
25 | 		void testBindingCount();
26 | 		void testManySenders();
27 | 		void testProxyBindingLimits();
28 | 		void testConnectWithSender();
29 | 		void testContextDestroyed();
30 | 		void testContextDestroyedEqualsSender();
31 | 		void testContextDestroyedShared();
32 | 		void testThread();
33 | 
34 | 		void testConnectPerf();
35 | };
36 | 
37 | class CallbackTester : public QObject
38 | {
39 | 	Q_OBJECT
40 | 
41 | 	public:
42 | 		QList<int> values;
43 | 
44 | 		void emitASignal(int arg)
45 | 		{
46 | 			emit aSignal(arg);
47 | 		}
48 | 
49 | 		void emitNoArgSignal()
50 | 		{
51 | 			emit noArgSignal();
52 | 		}
53 | 
54 | 		void emitStringSignal(const QString& arg)
55 | 		{
56 | 			emit stringSignal(arg);
57 | 		}
58 | 
59 | 		// expose protected QObject::receivers() method
60 | 		int receiverCount(const char* signal) const
61 | 		{
62 | 			return receivers(signal);
63 | 		}
64 | 
65 | 	public Q_SLOTS:
66 | 		void addValue(int value)
67 | 		{
68 | 			values << value;
69 | 			emit valuesChanged();
70 | 		}
71 | 
72 | 		void addValueIfSenderIsSelf(CallbackTester* sender, int value)
73 | 		{
74 | 			if (sender == this) {
75 | 				addValue(value);
76 | 			}
77 | 		}
78 | 
79 | 	Q_SIGNALS:
80 | 		void aSignal(int arg);
81 | 		void noArgSignal();
82 | 		void valuesChanged();
83 | 		void stringSignal(const QString& arg);
84 | };
85 | 


--------------------------------------------------------------------------------
/tests/tests.pro:
--------------------------------------------------------------------------------
1 | QT += testlib
2 | 
3 | CONFIG -= app_bundle
4 | INCLUDEPATH += ..
5 | HEADERS += ../QtCallback.h ../QtSignalForwarder.cpp TestQtSignalTools.h
6 | SOURCES += ../QtCallback.cpp ../QtSignalForwarder.cpp TestQtSignalTools.cpp
7 | 


--------------------------------------------------------------------------------