NuriaProject Framework  0.1
The NuriaProject Framework
callback.hpp
1 /* Copyright (c) 2014-2015, The Nuria Project
2  * The NuriaProject Framework is free software: you can redistribute it and/or
3  * modify it under the terms of the GNU Lesser General Public License as
4  * published by the Free Software Foundation, either version 3 of the License,
5  * or (at your option) any later version.
6  *
7  * The NuriaProject Framework is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU Lesser General Public License for more details.
11  *
12  * You should have received a copy of the GNU Lesser General Public License
13  * along with The NuriaProject Framework.
14  * If not, see <http://www.gnu.org/licenses/>.
15  */
16 
17 #ifndef NURIA_CALLBACK_HPP
18 #define NURIA_CALLBACK_HPP
19 
20 #include <type_traits>
21 #include <functional>
22 
23 #include <QSharedData>
24 #include <QMetaType>
25 #include <QVariant>
26 #include <QList>
27 
28 #include "essentials.hpp"
29 #include "variant.hpp"
30 
31 namespace Nuria {
32 class CallbackPrivate;
33 
35 namespace CallbackHelper {
36  template< int ... Index >
37  struct IndexTuple {
38  template< int N >
39  using append = IndexTuple< Index ..., N >;
40  };
41 
42  template< int Size >
43  struct CreateIndexTuple {
44  typedef typename CreateIndexTuple< Size - 1 >::type::template append< Size - 1 > type;
45  };
46 
47  template< >
48  struct CreateIndexTuple< 1 > {
49  typedef IndexTuple< > type;
50  };
51 
52  template< typename... Types >
53  using buildIndexTuple = typename CreateIndexTuple< sizeof...(Types) + 1 >::type;
54 
55  // qMetaTypeId wrapper, which returns 0 for T = void.
56  template< typename T >
57  constexpr int typeId () { return qMetaTypeId< T > (); }
58 
59  template< >
60  constexpr int typeId< void > () { return 0; }
61 
62  // Creates a raw list of type ids and values from 'args'
63  template< typename T >
64  void getArguments (void **list, int *types, int idx, T *cur) {
65  list[idx] = cur;
66  types[idx] = qMetaTypeId< typename std::remove_const< T >::type > ();
67  }
68 
69  template< typename T, typename T2, typename ... Args >
70  void getArguments (void **list, int *types, int idx,
71  T *cur, T2 *next, Args * ... args) {
72  getArguments (list, types, idx, cur);
73  getArguments (list, types, idx + 1, next, args ...);
74  }
75 
76 }
77 
140 class NURIA_CORE_EXPORT Callback {
141 
142  // Forward declare helper structures
143  struct TrampolineBase;
144  template< typename Ret, typename ... Args > struct MethodHelper;
145  template< typename Class, typename Ret, typename ... Args > struct MemberMethodHelper;
146  template< typename FullType, typename Ret, typename ... Args > struct LambdaHelper;
147 
148 public:
149 
153  enum Type {
154  Invalid = 0,
155  StaticMethod = 1,
156  MemberMethod = 2,
157  Slot = 3,
158  Lambda = 4
159  };
160 
164  enum Placeholder {
165  _1 = 0,
166  _2,
167  _3,
168  _4,
169  _5,
170  _6,
171  _7,
172  _8,
173  _9,
174  _10
175  };
176 
178  Callback ();
179 
187  Callback (QObject *receiver, const char *slot, bool variadic = false,
188  Qt::ConnectionType connectionType = Qt::AutoConnection);
189 
191  Callback (const Callback &other);
192 
194  template< typename Ret, typename ... Args >
195  Callback (Ret (*func)(Args ...), bool variadic = false)
196  : d (0) { setCallback (func); setVariadic (variadic); }
197 
199  template< typename Class, typename Ret, typename ... Args >
200  Callback (Class *instance, Ret (Class::*func)(Args ...), bool variadic = false)
201  : d (0) { setCallback (instance, func); setVariadic (variadic); }
202 
204  template< typename Class, typename Ret, typename ... Args >
205  Callback (Class *instance, Ret (Class::*func)(Args ...)const, bool variadic = false)
206  : d (0) { setCallback (instance, func); setVariadic (variadic); }
207 
208  template< typename Ret, typename ... Args >
209  Callback (const std::function< Ret(Args ...) > &func, bool variadic = false)
210  : d (0) { setCallback (func); setVariadic (variadic); }
211 
213  template< typename Lambda >
214  static Callback fromLambda (Lambda l, bool variadic = false) {
215  Callback cb = fromLambdaImpl (l, &Lambda::operator());
216  cb.setVariadic (variadic);
217  return cb;
218  }
219 
221  ~Callback ();
222 
224  Callback &operator= (const Callback &other);
225 
235  bool operator== (const Callback &other) const;
236 
238  bool isValid () const;
239 
241  Type type () const;
242 
244  bool isVariadic () const;
245 
247  void setVariadic (bool variadic);
248 
250  int returnType () const;
251 
253  QList< int > argumentTypes () const;
254 
259  //
260  template< typename Ret, typename ... Args >
261  bool setCallback (Ret (*func)(Args ...)) {
262  QList< int > args;
263  buildArgList< Args ... > (args);
264  return initBase (new MethodHelper< Ret, Args ... > (func),
265  CallbackHelper::typeId< Ret > (), args);
266  }
267 
268  // Member methods
269  template< typename Class, typename Ret, typename ... Args >
270  bool setCallback (Class *instance, Ret (Class::*func)(Args ...)const) {
271  typedef Ret(Class::*WithoutConst)(Args ...);
272  return setCallback (instance, (WithoutConst)func);
273  }
274 
275  template< typename Class, typename Ret, typename ... Args >
276  bool setCallback (Class *instance, Ret (Class::*func)(Args ...)) {
277  QList< int > args;
278  buildArgList< Args ... > (args);
279  return initBase (new MemberMethodHelper< Class, Ret, Args ... > (instance, func),
280  CallbackHelper::typeId< Ret > (), args);
281  }
282 
283  // std::function
284  template< typename Ret, typename ... Args >
285  bool setCallback (std::function< Ret(Args ...) > func) {
286  QList< int > args;
287  buildArgList< Args ... > (args);
288  return initBase (new LambdaHelper< std::function< Ret(Args ...) >, Ret, Args ... > (func),
289  CallbackHelper::typeId< Ret > (), args);
290  }
291 
303  bool setCallback (QObject *receiver, const char *slot,
304  Qt::ConnectionType connectionType = Qt::AutoConnection);
305 
306  // Convenience assignment operators
307  template< typename Ret, typename ... Args >
308  Callback &operator= (Ret (*func)(Args ...)) { setCallback (func); return *this; }
309 
319  void bindList (const QVariantList &arguments = QVariantList());
320 
324  template< typename Lambda, typename ... Args >
325  static Callback boundLambda (Lambda func, const Args &... args) {
326  Callback cb = fromLambdaImpl (func, &Lambda::operator());
327  cb.bind (args ...);
328  return cb;
329  }
330 
336  template< typename ... Args >
337  inline Callback &bind (const Args &... args) {
338  bindList (Variant::buildList (args ... ));
339  return *this;
340  }
341 
347  QVariant invoke (const QVariantList &arguments) const;
348 
352  template< typename ... Args >
353  QVariant operator() (const Args &... args) const {
354  void *list[sizeof... (Args)];
355  int types[sizeof... (Args)];
356  CallbackHelper::getArguments (list, types, 0, const_cast< Args * > (&args) ...);
357  return invoke (sizeof... (Args), list, types);
358  }
359 
361  inline QVariant operator() () {
362  return invoke (0, 0, 0);
363  }
364 
365 private:
366 
367  friend class CallbackPrivate;
368 
369  QVariant invoke (int count, void **args, int *types) const;
370  QVariant invokePrepared (const QVariantList &arguments) const;
371 
373  QVariant invokeInternal (int count, void **args, int *types) const;
374 
376  // If you have a error on line struct removeRef< T & >:
377  // T& is not allowed for values. Use const T & or just T instead.
378  template< typename T > struct removeRef { typedef T type; };
379  template< typename T > struct removeRef< T & >; // Not allowed!
380  template< typename T > struct removeRef< const T & > { typedef T type; };
381  template< typename T > struct removeRef< const T * > { typedef T* type; };
382 
386  template< typename Lambda, typename Ret, typename ... Args >
387  inline static Callback fromLambdaImpl (Lambda l, Ret (Lambda::*)(Args ...) const) {
388  return Callback (std::function< Ret(Args ...) > (l));
389  }
390 
395  bool initBase (TrampolineBase *base, int retType, const QList< int > &args);
396 
397  template< typename T1, typename ... T2 >
398  inline void buildArgListDo (QList< int > &list, T1 cur, T2 ... next) {
399  list.append (cur);
400  buildArgListDo (list, next ...);
401  }
402 
403  template< typename T >
404  inline void buildArgListDo (QList< int > &list, T cur)
405  { list.append (cur); }
406 
408  inline void buildArgListDo (QList< int > &) { }
409 
415  template< typename ... Args >
416  inline void buildArgList (QList< int > &list) {
417  buildArgListDo (list, qMetaTypeId< typename removeRef< Args >::type > () ...);
418  }
419 
425  struct TrampolineBase {
426  Type type;
427  TrampolineBase (Type t) : type (t) {}
428 
429  virtual ~TrampolineBase () {}
430  virtual void trampoline (void **) = 0;
431  };
432 
433  struct MemberTrampolineBase : TrampolineBase {
434  MemberTrampolineBase (void *inst) : TrampolineBase (MemberMethod), instance (inst) {}
435  void *instance;
436  };
437 
438  // Static methods
439  template< typename Ret, typename ... Args >
440  struct MethodHelper : public TrampolineBase {
441  typedef Ret (*Prototype)(Args ...);
442  Prototype func;
443 
444  MethodHelper (Prototype f) : TrampolineBase (StaticMethod), func (f) {}
445 
446  template< int ... Index >
447  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
448  (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
449  func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
450  }
451 
452  void trampoline (void **args)
453  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
454 
455  };
456 
457  template< typename ... Args >
458  struct MethodHelper< void, Args ... > : public TrampolineBase {
459  typedef void (*Prototype)(Args ...);
460  Prototype func;
461 
462  MethodHelper (Prototype f) : TrampolineBase (StaticMethod), func (f) {}
463 
464  template< int ... Index >
465  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
466  Q_UNUSED(args);
467  func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
468  }
469 
470  void trampoline (void **args)
471  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
472 
473  };
474 
475  // Member methods
476  template< typename Class, typename Ret, typename ... Args >
477  struct MemberMethodHelper : public MemberTrampolineBase {
478  typedef Ret (Class::*Prototype)(Args ...);
479  Prototype func;
480 
481  MemberMethodHelper (Class *inst, Prototype f) : MemberTrampolineBase (inst), func (f) {}
482 
483  template< int ... Index >
484  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
485  (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
486  (reinterpret_cast< Class * > (instance)->*func)
487  (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
488  }
489 
490  void trampoline (void **args)
491  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
492 
493  };
494 
495  template< typename Class, typename ... Args >
496  struct MemberMethodHelper< Class, void, Args ... > : public MemberTrampolineBase {
497  typedef void (Class::*Prototype)(Args ...);
498  Prototype func;
499 
500  MemberMethodHelper (Class *inst, Prototype f) : MemberTrampolineBase (inst), func (f) {}
501 
502  template< int ... Index >
503  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
504  Q_UNUSED(args);
505  (reinterpret_cast< Class * > (instance)->*func)
506  (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
507  }
508 
509  void trampoline (void **args)
510  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
511 
512  };
513 
514  // std::function< ... >
515  template< typename FullType, typename Ret, typename ... Args >
516  struct LambdaHelper : public TrampolineBase {
517  FullType func;
518 
519  LambdaHelper (const FullType &f) : TrampolineBase (Lambda), func (f) {}
520 
521  template< int ... Index >
522  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
523  (*reinterpret_cast< typename removeRef< Ret >::type * > (args[0])) =
524  func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
525  }
526 
527  void trampoline (void **args)
528  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
529 
530  };
531 
532  template< typename FullType, typename ... Args >
533  struct LambdaHelper< FullType, void, Args ... > : public TrampolineBase {
534  FullType func;
535 
536  LambdaHelper (const FullType &f) : TrampolineBase (Lambda), func (f) {}
537 
538  template< int ... Index >
539  inline void trampolineImpl (void **args, CallbackHelper::IndexTuple< Index... >) {
540  Q_UNUSED(args);
541  func (*reinterpret_cast< typename removeRef< Args >::type * >(args[Index]) ...);
542  }
543 
544  void trampoline (void **args)
545  { trampolineImpl (args, CallbackHelper::buildIndexTuple< Args ... > ()); }
546 
547  };
548 
549  // d-ptr
550  CallbackPrivate *d;
551 
552 };
553 }
554 
555 //
556 Q_DECLARE_METATYPE(Nuria::Callback)
557 Q_DECLARE_METATYPE(Nuria::Callback::Placeholder)
558 
559 #endif // NURIA_CALLBACK_HPP
Nuria::Callback::Placeholder
Placeholder
Definition: callback.hpp:164
Nuria::Callback::setVariadic
void setVariadic(bool variadic)
Nuria::Callback
A modern style callback mechanism which can be bound to various method types including slots...
Definition: callback.hpp:140
Nuria::Callback::boundLambda
static Callback boundLambda(Lambda func, const Args &...args)
Definition: callback.hpp:325
Nuria::Callback::Callback
Callback(Class *instance, Ret(Class::*func)(Args...) const, bool variadic=false)
Definition: callback.hpp:205
Nuria::Variant::buildList
static QVariantList buildList(const Items &...items)
Definition: variant.hpp:42
Nuria::Callback::fromLambda
static Callback fromLambda(Lambda l, bool variadic=false)
Definition: callback.hpp:214
Nuria
Definition: abstractsessionmanager.hpp:24
Nuria::Callback::Callback
Callback(Ret(*func)(Args...), bool variadic=false)
Definition: callback.hpp:195
Nuria::Callback::bind
Callback & bind(const Args &...args)
Definition: callback.hpp:337
Nuria::Callback::Type
Type
Definition: callback.hpp:153
Nuria::CallbackHelper::IndexTuple
Definition: callback.hpp:37
Nuria::CallbackHelper::CreateIndexTuple
Definition: callback.hpp:43
Nuria::Callback::Callback
Callback(Class *instance, Ret(Class::*func)(Args...), bool variadic=false)
Definition: callback.hpp:200
Generated on Fri Jan 9 2015 18:03:55 for NuriaProject Framework by   doxygen 1.8.9.1