Library of Assembled Shared Sources
bind.h
Go to the documentation of this file.
1/*
2 * *** ATTENTION! DO NOT MODIFY THIS FILE DIRECTLY! ***
3 *
4 * It has automatically been generated from bind.tmpl.h
5 * by param_expander.py on Mon Oct 6 22:51:36 2025.
6 */
7
8/** @file
9 * @author Bram de Greve (bram@cocamware.com)
10 * @author Tom De Muer (tom@cocamware.com)
11 *
12 * *** BEGIN LICENSE INFORMATION ***
13 *
14 * The contents of this file are subject to the Common Public Attribution License
15 * Version 1.0 (the "License"); you may not use this file except in compliance with
16 * the License. You may obtain a copy of the License at
17 * http://lass.sourceforge.net/cpal-license. The License is based on the
18 * Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover
19 * use of software over a computer network and provide for limited attribution for
20 * the Original Developer. In addition, Exhibit A has been modified to be consistent
21 * with Exhibit B.
22 *
23 * Software distributed under the License is distributed on an "AS IS" basis, WITHOUT
24 * WARRANTY OF ANY KIND, either express or implied. See the License for the specific
25 * language governing rights and limitations under the License.
26 *
27 * The Original Code is LASS - Library of Assembled Shared Sources.
28 *
29 * The Initial Developer of the Original Code is Bram de Greve and Tom De Muer.
30 * The Original Developer is the Initial Developer.
31 *
32 * All portions of the code written by the Initial Developer are:
33 * Copyright (C) 2004-2011 the Initial Developer.
34 * All Rights Reserved.
35 *
36 * Contributor(s):
37 *
38 * Alternatively, the contents of this file may be used under the terms of the
39 * GNU General Public License Version 2 or later (the GPL), in which case the
40 * provisions of GPL are applicable instead of those above. If you wish to allow use
41 * of your version of this file only under the terms of the GPL and not to allow
42 * others to use your version of this file under the CPAL, indicate your decision by
43 * deleting the provisions above and replace them with the notice and other
44 * provisions required by the GPL License. If you do not delete the provisions above,
45 * a recipient may use your version of this file under either the CPAL or the GPL.
46 *
47 * *** END LICENSE INFORMATION ***
48 */
49
50/** @defgroup Bind
51 * @brief bind call and arguments to a nullary callback.
52 *
53 * @code
54 * #include <lass/util/bind.h>
55 * #include <lass/util/shared_ptr.h>
56 * namespace using lass::util;
57 *
58 * void fun(const std::string& a);
59 * float moreFun(float a, float b);
60 * class Spam
61 * {
62 * void ham(const std::string& something);
63 * std::string eggs(int num) const;
64 * };
65 *
66 * // ...
67 *
68 * // regulare function call
69 * Callback0 boundFun = bind(fun, "hello world!");
70 *
71 * // with return value. type conversion is allowed both on arguments and result
72 * CallbackR1<double> boundMoreFun(moreFun, 5, 6);
73 *
74 * // bound method call, you have to make sure spam1 is still alive when call is executed!
75 * Spam spam1;
76 * Callback0 boundHam = bind(&Spam::ham, &spam1, "eggs");
77 *
78 * // bound method call with smart pointer, return value is ignored
79 * SharedPtr<Spam> spam2(new Spam);
80 * Callback0 boundEggs = bind(&Spam::eggs, spam2, 3);
81 *
82 * // ...
83 *
84 * boundFun();
85 * double result = boundMoreFun();
86 * boundHam();
87 * boundEggs();
88 * @endcode
89 */
90
91#ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_BIND_H
92#define LASS_GUARDIAN_OF_INCLUSION_UTIL_BIND_H
93
94#include "util_common.h"
95#include "callback_0.h"
96#include "callback_1.h"
97#include "callback_2.h"
98#include "callback_3.h"
99#include "callback_4.h"
100#include "callback_5.h"
101#include "callback_6.h"
102#include "callback_7.h"
103#include "callback_8.h"
104#include "callback_9.h"
105#include "callback_10.h"
106#include "callback_11.h"
107#include "callback_12.h"
108#include "callback_13.h"
109#include "callback_14.h"
110#include "callback_15.h"
111#include "callback_r_0.h"
112#include "callback_r_1.h"
113#include "callback_r_2.h"
114#include "callback_r_3.h"
115#include "callback_r_4.h"
116#include "callback_r_5.h"
117#include "callback_r_6.h"
118#include "callback_r_7.h"
119#include "callback_r_8.h"
120#include "callback_r_9.h"
121#include "callback_r_10.h"
122#include "callback_r_11.h"
123#include "callback_r_12.h"
124#include "callback_r_13.h"
125#include "callback_r_14.h"
126#include "callback_r_15.h"
127
128
129#if LASS_COMPILER_TYPE == LASS_COMPILER_TYPE_MSVC
130# pragma warning(push)
131# pragma warning(disable: 4267) // for size_t parameters ...
132#endif
133
134namespace lass
135{
136namespace util
137{
138
139namespace impl
140{
141
142/** @ingroup Bind
143 * @internal
144 */
145template <typename R> struct BindCallback { typedef CallbackR0<R> Type; };
146template <> struct BindCallback<void> { typedef Callback0 Type; };
147
148/** @ingroup Bind
149 * @internal
150 */
151template <typename R> class BindDispatcher: public DispatcherR0<R>
152{
153 bool doIsEquivalent(const DispatcherR0<R>*) const override { return false; }
154};
155template <> class BindDispatcher<void>: public impl::Dispatcher0
156{
157 bool doIsEquivalent(const Dispatcher0*) const override { return false; }
158};
159
160}
161
162// --- zero arguments ------------------------------------------------------------------------------
163
164/** @ingroup Bind
165 */
166template <typename R>
167typename impl::BindCallback<R>::Type
168bind(R (*fun)())
169{
170 return typename impl::BindCallback<R>::Type(fun);
171}
172
173/** @ingroup Bind
174 */
175template <typename R, typename Obj, typename ObjPtr>
176typename impl::BindCallback<R>::Type
177bind(R (Obj::*fun)(), ObjPtr obj)
178{
179 return typename impl::BindCallback<R>::Type(obj, fun);
180}
181
182/** @ingroup Bind
183 */
184template <typename R, typename Obj, typename ObjPtr>
185typename impl::BindCallback<R>::Type
186bind(R (Obj::*fun)() const, ObjPtr obj)
187{
188 return typename impl::BindCallback<R>::Type(obj, fun);
189}
190
191/** @ingroup Bind
192 */
193inline Callback0 bind(const Callback0& fun)
194{
195 return fun;
196}
197
198/** @ingroup Bind
199 */
200template <typename R>
201CallbackR0<R> bind(const CallbackR0<R>& fun)
202{
203 return fun;
204}
205
206
207
208// --- 1 argument(s) -----------------------------------------------------------------------------
209
210namespace impl
211{
212
213/** @ingroup Bind
214 * @internal
215 */
216template <typename R, typename Fun, typename X1>
217class DispatcherBindFun1: public BindDispatcher<R>
218{
219public:
220 DispatcherBindFun1(Fun fun, X1 x1): fun_(fun), x1_(x1) {}
221private:
222 R doCall() const override
223 {
224 if (!fun_)
225 {
226 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
227 }
228 return fun_(x1_);
229 }
230 Fun fun_;
231 typename CallTraits<X1>::TValue x1_;
232};
233
234/** @ingroup Bind
235 * @internal
236 */
237template <typename R, typename ObjPtr, typename Fun, typename X1>
238class DispatcherBindMemFun1: public BindDispatcher<R>
239{
240public:
241 DispatcherBindMemFun1(ObjPtr obj, Fun fun, X1 x1): obj_(obj), fun_(fun), x1_(x1) {}
242private:
243 R doCall() const override
244 {
245 if (!obj_ || !fun_)
246 {
247 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
248 }
249 return ((*obj_).*fun_)(x1_);
250 }
251 ObjPtr obj_;
252 Fun fun_;
253 typename CallTraits<X1>::TValue x1_;
254};
255
256}
257
258/** @ingroup Bind
259 */
260template <typename R, typename P1, typename X1>
261typename impl::BindCallback<R>::Type
262bind(R (*fun)(P1), X1 x1)
263{
264 typedef R (*TFun)(P1);
265 typedef typename impl::BindCallback<R>::Type TCallback;
266 typedef impl::DispatcherBindFun1<R, TFun, X1> TDispatcher;
267 return TCallback(TDispatcher(fun, x1));
268}
269
270/** @ingroup Bind
271 */
272template <typename R, typename P1, typename Obj, typename ObjPtr, typename X1>
273typename impl::BindCallback<R>::Type
274bind(R (Obj::*fun)(P1), ObjPtr obj, X1 x1)
275{
276 typedef R (Obj::*TFun)(P1);
277 typedef typename impl::BindCallback<R>::Type TCallback;
278 typedef impl::DispatcherBindMemFun1<R, ObjPtr, TFun, X1> TDispatcher;
279 return TCallback(TDispatcher(obj, fun, x1));
280}
281
282/** @ingroup Bind
283 */
284template <typename R, typename P1, typename Obj, typename ObjPtr, typename X1>
285typename impl::BindCallback<R>::Type
286bind(R (Obj::*fun)(P1) const, ObjPtr obj, X1 x1)
287{
288 typedef R (Obj::*TFun)(P1) const;
289 typedef typename impl::BindCallback<R>::Type TCallback;
290 typedef impl::DispatcherBindMemFun1<R, ObjPtr, TFun, X1> TDispatcher;
291 return TCallback(TDispatcher(obj, fun, x1));
292}
293
294/** @ingroup Bind
295 */
296template <typename R, typename P1, typename X1>
297CallbackR0<R>
298bind(const CallbackR1<R, P1>& fun, X1 x1)
299{
300 typedef CallbackR1<R, P1> TFun;
301 typedef CallbackR0<R> TCallback;
302 typedef impl::DispatcherBindFun1<R, TFun, X1> TDispatcher;
303 return TCallback(TDispatcher(fun, x1));
304}
305
306/** @ingroup Bind
307 */
308template <typename P1, typename X1>
309Callback0
310bind(const Callback1<P1>& fun, X1 x1)
311{
312 typedef Callback1<P1> TFun;
313 typedef Callback0 TCallback;
314 typedef impl::DispatcherBindFun1<void, TFun, X1> TDispatcher;
315 return TCallback(TDispatcher(fun, x1));
316}
317
318
319
320// --- 2 argument(s) -----------------------------------------------------------------------------
321
322namespace impl
323{
324
325/** @ingroup Bind
326 * @internal
327 */
328template <typename R, typename Fun, typename X1, typename X2>
329class DispatcherBindFun2: public BindDispatcher<R>
330{
331public:
332 DispatcherBindFun2(Fun fun, X1 x1, X2 x2): fun_(fun), x1_(x1), x2_(x2) {}
333private:
334 R doCall() const override
335 {
336 if (!fun_)
337 {
338 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
339 }
340 return fun_(x1_, x2_);
341 }
342 Fun fun_;
343 typename CallTraits<X1>::TValue x1_;
344 typename CallTraits<X2>::TValue x2_;
345};
346
347/** @ingroup Bind
348 * @internal
349 */
350template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2>
351class DispatcherBindMemFun2: public BindDispatcher<R>
352{
353public:
354 DispatcherBindMemFun2(ObjPtr obj, Fun fun, X1 x1, X2 x2): obj_(obj), fun_(fun), x1_(x1), x2_(x2) {}
355private:
356 R doCall() const override
357 {
358 if (!obj_ || !fun_)
359 {
360 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
361 }
362 return ((*obj_).*fun_)(x1_, x2_);
363 }
364 ObjPtr obj_;
365 Fun fun_;
366 typename CallTraits<X1>::TValue x1_;
367 typename CallTraits<X2>::TValue x2_;
368};
369
370}
371
372/** @ingroup Bind
373 */
374template <typename R, typename P1, typename P2, typename X1, typename X2>
375typename impl::BindCallback<R>::Type
376bind(R (*fun)(P1, P2), X1 x1, X2 x2)
377{
378 typedef R (*TFun)(P1, P2);
379 typedef typename impl::BindCallback<R>::Type TCallback;
380 typedef impl::DispatcherBindFun2<R, TFun, X1, X2> TDispatcher;
381 return TCallback(TDispatcher(fun, x1, x2));
382}
383
384/** @ingroup Bind
385 */
386template <typename R, typename P1, typename P2, typename Obj, typename ObjPtr, typename X1, typename X2>
387typename impl::BindCallback<R>::Type
388bind(R (Obj::*fun)(P1, P2), ObjPtr obj, X1 x1, X2 x2)
389{
390 typedef R (Obj::*TFun)(P1, P2);
391 typedef typename impl::BindCallback<R>::Type TCallback;
392 typedef impl::DispatcherBindMemFun2<R, ObjPtr, TFun, X1, X2> TDispatcher;
393 return TCallback(TDispatcher(obj, fun, x1, x2));
394}
395
396/** @ingroup Bind
397 */
398template <typename R, typename P1, typename P2, typename Obj, typename ObjPtr, typename X1, typename X2>
399typename impl::BindCallback<R>::Type
400bind(R (Obj::*fun)(P1, P2) const, ObjPtr obj, X1 x1, X2 x2)
401{
402 typedef R (Obj::*TFun)(P1, P2) const;
403 typedef typename impl::BindCallback<R>::Type TCallback;
404 typedef impl::DispatcherBindMemFun2<R, ObjPtr, TFun, X1, X2> TDispatcher;
405 return TCallback(TDispatcher(obj, fun, x1, x2));
406}
407
408/** @ingroup Bind
409 */
410template <typename R, typename P1, typename P2, typename X1, typename X2>
411CallbackR0<R>
412bind(const CallbackR2<R, P1, P2>& fun, X1 x1, X2 x2)
413{
414 typedef CallbackR2<R, P1, P2> TFun;
415 typedef CallbackR0<R> TCallback;
416 typedef impl::DispatcherBindFun2<R, TFun, X1, X2> TDispatcher;
417 return TCallback(TDispatcher(fun, x1, x2));
418}
419
420/** @ingroup Bind
421 */
422template <typename P1, typename P2, typename X1, typename X2>
423Callback0
424bind(const Callback2<P1, P2>& fun, X1 x1, X2 x2)
425{
426 typedef Callback2<P1, P2> TFun;
427 typedef Callback0 TCallback;
428 typedef impl::DispatcherBindFun2<void, TFun, X1, X2> TDispatcher;
429 return TCallback(TDispatcher(fun, x1, x2));
430}
431
432
433
434// --- 3 argument(s) -----------------------------------------------------------------------------
435
436namespace impl
437{
438
439/** @ingroup Bind
440 * @internal
441 */
442template <typename R, typename Fun, typename X1, typename X2, typename X3>
443class DispatcherBindFun3: public BindDispatcher<R>
444{
445public:
446 DispatcherBindFun3(Fun fun, X1 x1, X2 x2, X3 x3): fun_(fun), x1_(x1), x2_(x2), x3_(x3) {}
447private:
448 R doCall() const override
449 {
450 if (!fun_)
451 {
452 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
453 }
454 return fun_(x1_, x2_, x3_);
455 }
456 Fun fun_;
457 typename CallTraits<X1>::TValue x1_;
458 typename CallTraits<X2>::TValue x2_;
459 typename CallTraits<X3>::TValue x3_;
460};
461
462/** @ingroup Bind
463 * @internal
464 */
465template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3>
466class DispatcherBindMemFun3: public BindDispatcher<R>
467{
468public:
469 DispatcherBindMemFun3(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3) {}
470private:
471 R doCall() const override
472 {
473 if (!obj_ || !fun_)
474 {
475 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
476 }
477 return ((*obj_).*fun_)(x1_, x2_, x3_);
478 }
479 ObjPtr obj_;
480 Fun fun_;
481 typename CallTraits<X1>::TValue x1_;
482 typename CallTraits<X2>::TValue x2_;
483 typename CallTraits<X3>::TValue x3_;
484};
485
486}
487
488/** @ingroup Bind
489 */
490template <typename R, typename P1, typename P2, typename P3, typename X1, typename X2, typename X3>
491typename impl::BindCallback<R>::Type
492bind(R (*fun)(P1, P2, P3), X1 x1, X2 x2, X3 x3)
493{
494 typedef R (*TFun)(P1, P2, P3);
495 typedef typename impl::BindCallback<R>::Type TCallback;
496 typedef impl::DispatcherBindFun3<R, TFun, X1, X2, X3> TDispatcher;
497 return TCallback(TDispatcher(fun, x1, x2, x3));
498}
499
500/** @ingroup Bind
501 */
502template <typename R, typename P1, typename P2, typename P3, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3>
503typename impl::BindCallback<R>::Type
504bind(R (Obj::*fun)(P1, P2, P3), ObjPtr obj, X1 x1, X2 x2, X3 x3)
505{
506 typedef R (Obj::*TFun)(P1, P2, P3);
507 typedef typename impl::BindCallback<R>::Type TCallback;
508 typedef impl::DispatcherBindMemFun3<R, ObjPtr, TFun, X1, X2, X3> TDispatcher;
509 return TCallback(TDispatcher(obj, fun, x1, x2, x3));
510}
511
512/** @ingroup Bind
513 */
514template <typename R, typename P1, typename P2, typename P3, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3>
515typename impl::BindCallback<R>::Type
516bind(R (Obj::*fun)(P1, P2, P3) const, ObjPtr obj, X1 x1, X2 x2, X3 x3)
517{
518 typedef R (Obj::*TFun)(P1, P2, P3) const;
519 typedef typename impl::BindCallback<R>::Type TCallback;
520 typedef impl::DispatcherBindMemFun3<R, ObjPtr, TFun, X1, X2, X3> TDispatcher;
521 return TCallback(TDispatcher(obj, fun, x1, x2, x3));
522}
523
524/** @ingroup Bind
525 */
526template <typename R, typename P1, typename P2, typename P3, typename X1, typename X2, typename X3>
527CallbackR0<R>
528bind(const CallbackR3<R, P1, P2, P3>& fun, X1 x1, X2 x2, X3 x3)
529{
530 typedef CallbackR3<R, P1, P2, P3> TFun;
531 typedef CallbackR0<R> TCallback;
532 typedef impl::DispatcherBindFun3<R, TFun, X1, X2, X3> TDispatcher;
533 return TCallback(TDispatcher(fun, x1, x2, x3));
534}
535
536/** @ingroup Bind
537 */
538template <typename P1, typename P2, typename P3, typename X1, typename X2, typename X3>
539Callback0
540bind(const Callback3<P1, P2, P3>& fun, X1 x1, X2 x2, X3 x3)
541{
542 typedef Callback3<P1, P2, P3> TFun;
543 typedef Callback0 TCallback;
544 typedef impl::DispatcherBindFun3<void, TFun, X1, X2, X3> TDispatcher;
545 return TCallback(TDispatcher(fun, x1, x2, x3));
546}
547
548
549
550// --- 4 argument(s) -----------------------------------------------------------------------------
551
552namespace impl
553{
554
555/** @ingroup Bind
556 * @internal
557 */
558template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4>
559class DispatcherBindFun4: public BindDispatcher<R>
560{
561public:
562 DispatcherBindFun4(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4) {}
563private:
564 R doCall() const override
565 {
566 if (!fun_)
567 {
568 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
569 }
570 return fun_(x1_, x2_, x3_, x4_);
571 }
572 Fun fun_;
573 typename CallTraits<X1>::TValue x1_;
574 typename CallTraits<X2>::TValue x2_;
575 typename CallTraits<X3>::TValue x3_;
576 typename CallTraits<X4>::TValue x4_;
577};
578
579/** @ingroup Bind
580 * @internal
581 */
582template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4>
583class DispatcherBindMemFun4: public BindDispatcher<R>
584{
585public:
586 DispatcherBindMemFun4(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4) {}
587private:
588 R doCall() const override
589 {
590 if (!obj_ || !fun_)
591 {
592 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
593 }
594 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_);
595 }
596 ObjPtr obj_;
597 Fun fun_;
598 typename CallTraits<X1>::TValue x1_;
599 typename CallTraits<X2>::TValue x2_;
600 typename CallTraits<X3>::TValue x3_;
601 typename CallTraits<X4>::TValue x4_;
602};
603
604}
605
606/** @ingroup Bind
607 */
608template <typename R, typename P1, typename P2, typename P3, typename P4, typename X1, typename X2, typename X3, typename X4>
609typename impl::BindCallback<R>::Type
610bind(R (*fun)(P1, P2, P3, P4), X1 x1, X2 x2, X3 x3, X4 x4)
611{
612 typedef R (*TFun)(P1, P2, P3, P4);
613 typedef typename impl::BindCallback<R>::Type TCallback;
614 typedef impl::DispatcherBindFun4<R, TFun, X1, X2, X3, X4> TDispatcher;
615 return TCallback(TDispatcher(fun, x1, x2, x3, x4));
616}
617
618/** @ingroup Bind
619 */
620template <typename R, typename P1, typename P2, typename P3, typename P4, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4>
621typename impl::BindCallback<R>::Type
622bind(R (Obj::*fun)(P1, P2, P3, P4), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4)
623{
624 typedef R (Obj::*TFun)(P1, P2, P3, P4);
625 typedef typename impl::BindCallback<R>::Type TCallback;
626 typedef impl::DispatcherBindMemFun4<R, ObjPtr, TFun, X1, X2, X3, X4> TDispatcher;
627 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4));
628}
629
630/** @ingroup Bind
631 */
632template <typename R, typename P1, typename P2, typename P3, typename P4, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4>
633typename impl::BindCallback<R>::Type
634bind(R (Obj::*fun)(P1, P2, P3, P4) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4)
635{
636 typedef R (Obj::*TFun)(P1, P2, P3, P4) const;
637 typedef typename impl::BindCallback<R>::Type TCallback;
638 typedef impl::DispatcherBindMemFun4<R, ObjPtr, TFun, X1, X2, X3, X4> TDispatcher;
639 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4));
640}
641
642/** @ingroup Bind
643 */
644template <typename R, typename P1, typename P2, typename P3, typename P4, typename X1, typename X2, typename X3, typename X4>
645CallbackR0<R>
646bind(const CallbackR4<R, P1, P2, P3, P4>& fun, X1 x1, X2 x2, X3 x3, X4 x4)
647{
648 typedef CallbackR4<R, P1, P2, P3, P4> TFun;
649 typedef CallbackR0<R> TCallback;
650 typedef impl::DispatcherBindFun4<R, TFun, X1, X2, X3, X4> TDispatcher;
651 return TCallback(TDispatcher(fun, x1, x2, x3, x4));
652}
653
654/** @ingroup Bind
655 */
656template <typename P1, typename P2, typename P3, typename P4, typename X1, typename X2, typename X3, typename X4>
657Callback0
658bind(const Callback4<P1, P2, P3, P4>& fun, X1 x1, X2 x2, X3 x3, X4 x4)
659{
660 typedef Callback4<P1, P2, P3, P4> TFun;
661 typedef Callback0 TCallback;
662 typedef impl::DispatcherBindFun4<void, TFun, X1, X2, X3, X4> TDispatcher;
663 return TCallback(TDispatcher(fun, x1, x2, x3, x4));
664}
665
666
667
668// --- 5 argument(s) -----------------------------------------------------------------------------
669
670namespace impl
671{
672
673/** @ingroup Bind
674 * @internal
675 */
676template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5>
677class DispatcherBindFun5: public BindDispatcher<R>
678{
679public:
680 DispatcherBindFun5(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5) {}
681private:
682 R doCall() const override
683 {
684 if (!fun_)
685 {
686 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
687 }
688 return fun_(x1_, x2_, x3_, x4_, x5_);
689 }
690 Fun fun_;
691 typename CallTraits<X1>::TValue x1_;
692 typename CallTraits<X2>::TValue x2_;
693 typename CallTraits<X3>::TValue x3_;
694 typename CallTraits<X4>::TValue x4_;
695 typename CallTraits<X5>::TValue x5_;
696};
697
698/** @ingroup Bind
699 * @internal
700 */
701template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5>
702class DispatcherBindMemFun5: public BindDispatcher<R>
703{
704public:
705 DispatcherBindMemFun5(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5) {}
706private:
707 R doCall() const override
708 {
709 if (!obj_ || !fun_)
710 {
711 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
712 }
713 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_);
714 }
715 ObjPtr obj_;
716 Fun fun_;
717 typename CallTraits<X1>::TValue x1_;
718 typename CallTraits<X2>::TValue x2_;
719 typename CallTraits<X3>::TValue x3_;
720 typename CallTraits<X4>::TValue x4_;
721 typename CallTraits<X5>::TValue x5_;
722};
723
724}
725
726/** @ingroup Bind
727 */
728template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename X1, typename X2, typename X3, typename X4, typename X5>
729typename impl::BindCallback<R>::Type
730bind(R (*fun)(P1, P2, P3, P4, P5), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5)
731{
732 typedef R (*TFun)(P1, P2, P3, P4, P5);
733 typedef typename impl::BindCallback<R>::Type TCallback;
734 typedef impl::DispatcherBindFun5<R, TFun, X1, X2, X3, X4, X5> TDispatcher;
735 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5));
736}
737
738/** @ingroup Bind
739 */
740template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5>
741typename impl::BindCallback<R>::Type
742bind(R (Obj::*fun)(P1, P2, P3, P4, P5), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5)
743{
744 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5);
745 typedef typename impl::BindCallback<R>::Type TCallback;
746 typedef impl::DispatcherBindMemFun5<R, ObjPtr, TFun, X1, X2, X3, X4, X5> TDispatcher;
747 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5));
748}
749
750/** @ingroup Bind
751 */
752template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5>
753typename impl::BindCallback<R>::Type
754bind(R (Obj::*fun)(P1, P2, P3, P4, P5) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5)
755{
756 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5) const;
757 typedef typename impl::BindCallback<R>::Type TCallback;
758 typedef impl::DispatcherBindMemFun5<R, ObjPtr, TFun, X1, X2, X3, X4, X5> TDispatcher;
759 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5));
760}
761
762/** @ingroup Bind
763 */
764template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename X1, typename X2, typename X3, typename X4, typename X5>
765CallbackR0<R>
766bind(const CallbackR5<R, P1, P2, P3, P4, P5>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5)
767{
768 typedef CallbackR5<R, P1, P2, P3, P4, P5> TFun;
769 typedef CallbackR0<R> TCallback;
770 typedef impl::DispatcherBindFun5<R, TFun, X1, X2, X3, X4, X5> TDispatcher;
771 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5));
772}
773
774/** @ingroup Bind
775 */
776template <typename P1, typename P2, typename P3, typename P4, typename P5, typename X1, typename X2, typename X3, typename X4, typename X5>
777Callback0
778bind(const Callback5<P1, P2, P3, P4, P5>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5)
779{
780 typedef Callback5<P1, P2, P3, P4, P5> TFun;
781 typedef Callback0 TCallback;
782 typedef impl::DispatcherBindFun5<void, TFun, X1, X2, X3, X4, X5> TDispatcher;
783 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5));
784}
785
786
787
788// --- 6 argument(s) -----------------------------------------------------------------------------
789
790namespace impl
791{
792
793/** @ingroup Bind
794 * @internal
795 */
796template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
797class DispatcherBindFun6: public BindDispatcher<R>
798{
799public:
800 DispatcherBindFun6(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6) {}
801private:
802 R doCall() const override
803 {
804 if (!fun_)
805 {
806 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
807 }
808 return fun_(x1_, x2_, x3_, x4_, x5_, x6_);
809 }
810 Fun fun_;
811 typename CallTraits<X1>::TValue x1_;
812 typename CallTraits<X2>::TValue x2_;
813 typename CallTraits<X3>::TValue x3_;
814 typename CallTraits<X4>::TValue x4_;
815 typename CallTraits<X5>::TValue x5_;
816 typename CallTraits<X6>::TValue x6_;
817};
818
819/** @ingroup Bind
820 * @internal
821 */
822template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
823class DispatcherBindMemFun6: public BindDispatcher<R>
824{
825public:
826 DispatcherBindMemFun6(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6) {}
827private:
828 R doCall() const override
829 {
830 if (!obj_ || !fun_)
831 {
832 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
833 }
834 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_);
835 }
836 ObjPtr obj_;
837 Fun fun_;
838 typename CallTraits<X1>::TValue x1_;
839 typename CallTraits<X2>::TValue x2_;
840 typename CallTraits<X3>::TValue x3_;
841 typename CallTraits<X4>::TValue x4_;
842 typename CallTraits<X5>::TValue x5_;
843 typename CallTraits<X6>::TValue x6_;
844};
845
846}
847
848/** @ingroup Bind
849 */
850template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
851typename impl::BindCallback<R>::Type
852bind(R (*fun)(P1, P2, P3, P4, P5, P6), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6)
853{
854 typedef R (*TFun)(P1, P2, P3, P4, P5, P6);
855 typedef typename impl::BindCallback<R>::Type TCallback;
856 typedef impl::DispatcherBindFun6<R, TFun, X1, X2, X3, X4, X5, X6> TDispatcher;
857 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6));
858}
859
860/** @ingroup Bind
861 */
862template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
863typename impl::BindCallback<R>::Type
864bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6)
865{
866 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6);
867 typedef typename impl::BindCallback<R>::Type TCallback;
868 typedef impl::DispatcherBindMemFun6<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6> TDispatcher;
869 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6));
870}
871
872/** @ingroup Bind
873 */
874template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
875typename impl::BindCallback<R>::Type
876bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6)
877{
878 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6) const;
879 typedef typename impl::BindCallback<R>::Type TCallback;
880 typedef impl::DispatcherBindMemFun6<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6> TDispatcher;
881 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6));
882}
883
884/** @ingroup Bind
885 */
886template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
887CallbackR0<R>
888bind(const CallbackR6<R, P1, P2, P3, P4, P5, P6>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6)
889{
890 typedef CallbackR6<R, P1, P2, P3, P4, P5, P6> TFun;
891 typedef CallbackR0<R> TCallback;
892 typedef impl::DispatcherBindFun6<R, TFun, X1, X2, X3, X4, X5, X6> TDispatcher;
893 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6));
894}
895
896/** @ingroup Bind
897 */
898template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6>
899Callback0
900bind(const Callback6<P1, P2, P3, P4, P5, P6>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6)
901{
902 typedef Callback6<P1, P2, P3, P4, P5, P6> TFun;
903 typedef Callback0 TCallback;
904 typedef impl::DispatcherBindFun6<void, TFun, X1, X2, X3, X4, X5, X6> TDispatcher;
905 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6));
906}
907
908
909
910// --- 7 argument(s) -----------------------------------------------------------------------------
911
912namespace impl
913{
914
915/** @ingroup Bind
916 * @internal
917 */
918template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
919class DispatcherBindFun7: public BindDispatcher<R>
920{
921public:
922 DispatcherBindFun7(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7) {}
923private:
924 R doCall() const override
925 {
926 if (!fun_)
927 {
928 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
929 }
930 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_);
931 }
932 Fun fun_;
933 typename CallTraits<X1>::TValue x1_;
934 typename CallTraits<X2>::TValue x2_;
935 typename CallTraits<X3>::TValue x3_;
936 typename CallTraits<X4>::TValue x4_;
937 typename CallTraits<X5>::TValue x5_;
938 typename CallTraits<X6>::TValue x6_;
939 typename CallTraits<X7>::TValue x7_;
940};
941
942/** @ingroup Bind
943 * @internal
944 */
945template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
946class DispatcherBindMemFun7: public BindDispatcher<R>
947{
948public:
949 DispatcherBindMemFun7(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7) {}
950private:
951 R doCall() const override
952 {
953 if (!obj_ || !fun_)
954 {
955 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
956 }
957 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_);
958 }
959 ObjPtr obj_;
960 Fun fun_;
961 typename CallTraits<X1>::TValue x1_;
962 typename CallTraits<X2>::TValue x2_;
963 typename CallTraits<X3>::TValue x3_;
964 typename CallTraits<X4>::TValue x4_;
965 typename CallTraits<X5>::TValue x5_;
966 typename CallTraits<X6>::TValue x6_;
967 typename CallTraits<X7>::TValue x7_;
968};
969
970}
971
972/** @ingroup Bind
973 */
974template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
975typename impl::BindCallback<R>::Type
976bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7)
977{
978 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7);
979 typedef typename impl::BindCallback<R>::Type TCallback;
980 typedef impl::DispatcherBindFun7<R, TFun, X1, X2, X3, X4, X5, X6, X7> TDispatcher;
981 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7));
982}
983
984/** @ingroup Bind
985 */
986template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
987typename impl::BindCallback<R>::Type
988bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7)
989{
990 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7);
991 typedef typename impl::BindCallback<R>::Type TCallback;
992 typedef impl::DispatcherBindMemFun7<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7> TDispatcher;
993 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7));
994}
995
996/** @ingroup Bind
997 */
998template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
999typename impl::BindCallback<R>::Type
1000bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7)
1001{
1002 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7) const;
1003 typedef typename impl::BindCallback<R>::Type TCallback;
1004 typedef impl::DispatcherBindMemFun7<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7> TDispatcher;
1005 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7));
1006}
1007
1008/** @ingroup Bind
1009 */
1010template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
1011CallbackR0<R>
1012bind(const CallbackR7<R, P1, P2, P3, P4, P5, P6, P7>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7)
1013{
1014 typedef CallbackR7<R, P1, P2, P3, P4, P5, P6, P7> TFun;
1015 typedef CallbackR0<R> TCallback;
1016 typedef impl::DispatcherBindFun7<R, TFun, X1, X2, X3, X4, X5, X6, X7> TDispatcher;
1017 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7));
1018}
1019
1020/** @ingroup Bind
1021 */
1022template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7>
1023Callback0
1024bind(const Callback7<P1, P2, P3, P4, P5, P6, P7>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7)
1025{
1026 typedef Callback7<P1, P2, P3, P4, P5, P6, P7> TFun;
1027 typedef Callback0 TCallback;
1028 typedef impl::DispatcherBindFun7<void, TFun, X1, X2, X3, X4, X5, X6, X7> TDispatcher;
1029 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7));
1030}
1031
1032
1033
1034// --- 8 argument(s) -----------------------------------------------------------------------------
1035
1036namespace impl
1037{
1038
1039/** @ingroup Bind
1040 * @internal
1041 */
1042template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1043class DispatcherBindFun8: public BindDispatcher<R>
1044{
1045public:
1046 DispatcherBindFun8(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8) {}
1047private:
1048 R doCall() const override
1049 {
1050 if (!fun_)
1051 {
1052 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1053 }
1054 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
1055 }
1056 Fun fun_;
1057 typename CallTraits<X1>::TValue x1_;
1058 typename CallTraits<X2>::TValue x2_;
1059 typename CallTraits<X3>::TValue x3_;
1060 typename CallTraits<X4>::TValue x4_;
1061 typename CallTraits<X5>::TValue x5_;
1062 typename CallTraits<X6>::TValue x6_;
1063 typename CallTraits<X7>::TValue x7_;
1064 typename CallTraits<X8>::TValue x8_;
1065};
1066
1067/** @ingroup Bind
1068 * @internal
1069 */
1070template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1071class DispatcherBindMemFun8: public BindDispatcher<R>
1072{
1073public:
1074 DispatcherBindMemFun8(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8) {}
1075private:
1076 R doCall() const override
1077 {
1078 if (!obj_ || !fun_)
1079 {
1080 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1081 }
1082 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_);
1083 }
1084 ObjPtr obj_;
1085 Fun fun_;
1086 typename CallTraits<X1>::TValue x1_;
1087 typename CallTraits<X2>::TValue x2_;
1088 typename CallTraits<X3>::TValue x3_;
1089 typename CallTraits<X4>::TValue x4_;
1090 typename CallTraits<X5>::TValue x5_;
1091 typename CallTraits<X6>::TValue x6_;
1092 typename CallTraits<X7>::TValue x7_;
1093 typename CallTraits<X8>::TValue x8_;
1094};
1095
1096}
1097
1098/** @ingroup Bind
1099 */
1100template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1101typename impl::BindCallback<R>::Type
1102bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8)
1103{
1104 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8);
1105 typedef typename impl::BindCallback<R>::Type TCallback;
1106 typedef impl::DispatcherBindFun8<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8> TDispatcher;
1107 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8));
1108}
1109
1110/** @ingroup Bind
1111 */
1112template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1113typename impl::BindCallback<R>::Type
1114bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8)
1115{
1116 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8);
1117 typedef typename impl::BindCallback<R>::Type TCallback;
1118 typedef impl::DispatcherBindMemFun8<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8> TDispatcher;
1119 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8));
1120}
1121
1122/** @ingroup Bind
1123 */
1124template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1125typename impl::BindCallback<R>::Type
1126bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8)
1127{
1128 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8) const;
1129 typedef typename impl::BindCallback<R>::Type TCallback;
1130 typedef impl::DispatcherBindMemFun8<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8> TDispatcher;
1131 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8));
1132}
1133
1134/** @ingroup Bind
1135 */
1136template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1137CallbackR0<R>
1138bind(const CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8)
1139{
1140 typedef CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8> TFun;
1141 typedef CallbackR0<R> TCallback;
1142 typedef impl::DispatcherBindFun8<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8> TDispatcher;
1143 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8));
1144}
1145
1146/** @ingroup Bind
1147 */
1148template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8>
1149Callback0
1150bind(const Callback8<P1, P2, P3, P4, P5, P6, P7, P8>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8)
1151{
1152 typedef Callback8<P1, P2, P3, P4, P5, P6, P7, P8> TFun;
1153 typedef Callback0 TCallback;
1154 typedef impl::DispatcherBindFun8<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8> TDispatcher;
1155 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8));
1156}
1157
1158
1159
1160// --- 9 argument(s) -----------------------------------------------------------------------------
1161
1162namespace impl
1163{
1164
1165/** @ingroup Bind
1166 * @internal
1167 */
1168template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1169class DispatcherBindFun9: public BindDispatcher<R>
1170{
1171public:
1172 DispatcherBindFun9(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9) {}
1173private:
1174 R doCall() const override
1175 {
1176 if (!fun_)
1177 {
1178 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1179 }
1180 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
1181 }
1182 Fun fun_;
1183 typename CallTraits<X1>::TValue x1_;
1184 typename CallTraits<X2>::TValue x2_;
1185 typename CallTraits<X3>::TValue x3_;
1186 typename CallTraits<X4>::TValue x4_;
1187 typename CallTraits<X5>::TValue x5_;
1188 typename CallTraits<X6>::TValue x6_;
1189 typename CallTraits<X7>::TValue x7_;
1190 typename CallTraits<X8>::TValue x8_;
1191 typename CallTraits<X9>::TValue x9_;
1192};
1193
1194/** @ingroup Bind
1195 * @internal
1196 */
1197template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1198class DispatcherBindMemFun9: public BindDispatcher<R>
1199{
1200public:
1201 DispatcherBindMemFun9(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9) {}
1202private:
1203 R doCall() const override
1204 {
1205 if (!obj_ || !fun_)
1206 {
1207 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1208 }
1209 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_);
1210 }
1211 ObjPtr obj_;
1212 Fun fun_;
1213 typename CallTraits<X1>::TValue x1_;
1214 typename CallTraits<X2>::TValue x2_;
1215 typename CallTraits<X3>::TValue x3_;
1216 typename CallTraits<X4>::TValue x4_;
1217 typename CallTraits<X5>::TValue x5_;
1218 typename CallTraits<X6>::TValue x6_;
1219 typename CallTraits<X7>::TValue x7_;
1220 typename CallTraits<X8>::TValue x8_;
1221 typename CallTraits<X9>::TValue x9_;
1222};
1223
1224}
1225
1226/** @ingroup Bind
1227 */
1228template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1229typename impl::BindCallback<R>::Type
1230bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9)
1231{
1232 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
1233 typedef typename impl::BindCallback<R>::Type TCallback;
1234 typedef impl::DispatcherBindFun9<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9> TDispatcher;
1235 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9));
1236}
1237
1238/** @ingroup Bind
1239 */
1240template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1241typename impl::BindCallback<R>::Type
1242bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9)
1243{
1244 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
1245 typedef typename impl::BindCallback<R>::Type TCallback;
1246 typedef impl::DispatcherBindMemFun9<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9> TDispatcher;
1247 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9));
1248}
1249
1250/** @ingroup Bind
1251 */
1252template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1253typename impl::BindCallback<R>::Type
1254bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9)
1255{
1256 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const;
1257 typedef typename impl::BindCallback<R>::Type TCallback;
1258 typedef impl::DispatcherBindMemFun9<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9> TDispatcher;
1259 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9));
1260}
1261
1262/** @ingroup Bind
1263 */
1264template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1265CallbackR0<R>
1266bind(const CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9)
1267{
1268 typedef CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> TFun;
1269 typedef CallbackR0<R> TCallback;
1270 typedef impl::DispatcherBindFun9<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9> TDispatcher;
1271 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9));
1272}
1273
1274/** @ingroup Bind
1275 */
1276template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9>
1277Callback0
1278bind(const Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9)
1279{
1280 typedef Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9> TFun;
1281 typedef Callback0 TCallback;
1282 typedef impl::DispatcherBindFun9<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9> TDispatcher;
1283 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9));
1284}
1285
1286
1287
1288// --- 10 argument(s) -----------------------------------------------------------------------------
1289
1290namespace impl
1291{
1292
1293/** @ingroup Bind
1294 * @internal
1295 */
1296template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1297class DispatcherBindFun10: public BindDispatcher<R>
1298{
1299public:
1300 DispatcherBindFun10(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10) {}
1301private:
1302 R doCall() const override
1303 {
1304 if (!fun_)
1305 {
1306 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1307 }
1308 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
1309 }
1310 Fun fun_;
1311 typename CallTraits<X1>::TValue x1_;
1312 typename CallTraits<X2>::TValue x2_;
1313 typename CallTraits<X3>::TValue x3_;
1314 typename CallTraits<X4>::TValue x4_;
1315 typename CallTraits<X5>::TValue x5_;
1316 typename CallTraits<X6>::TValue x6_;
1317 typename CallTraits<X7>::TValue x7_;
1318 typename CallTraits<X8>::TValue x8_;
1319 typename CallTraits<X9>::TValue x9_;
1320 typename CallTraits<X10>::TValue x10_;
1321};
1322
1323/** @ingroup Bind
1324 * @internal
1325 */
1326template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1327class DispatcherBindMemFun10: public BindDispatcher<R>
1328{
1329public:
1330 DispatcherBindMemFun10(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10) {}
1331private:
1332 R doCall() const override
1333 {
1334 if (!obj_ || !fun_)
1335 {
1336 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1337 }
1338 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_);
1339 }
1340 ObjPtr obj_;
1341 Fun fun_;
1342 typename CallTraits<X1>::TValue x1_;
1343 typename CallTraits<X2>::TValue x2_;
1344 typename CallTraits<X3>::TValue x3_;
1345 typename CallTraits<X4>::TValue x4_;
1346 typename CallTraits<X5>::TValue x5_;
1347 typename CallTraits<X6>::TValue x6_;
1348 typename CallTraits<X7>::TValue x7_;
1349 typename CallTraits<X8>::TValue x8_;
1350 typename CallTraits<X9>::TValue x9_;
1351 typename CallTraits<X10>::TValue x10_;
1352};
1353
1354}
1355
1356/** @ingroup Bind
1357 */
1358template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1359typename impl::BindCallback<R>::Type
1360bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10)
1361{
1362 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
1363 typedef typename impl::BindCallback<R>::Type TCallback;
1364 typedef impl::DispatcherBindFun10<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10> TDispatcher;
1365 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10));
1366}
1367
1368/** @ingroup Bind
1369 */
1370template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1371typename impl::BindCallback<R>::Type
1372bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10)
1373{
1374 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
1375 typedef typename impl::BindCallback<R>::Type TCallback;
1376 typedef impl::DispatcherBindMemFun10<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10> TDispatcher;
1377 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10));
1378}
1379
1380/** @ingroup Bind
1381 */
1382template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1383typename impl::BindCallback<R>::Type
1384bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10)
1385{
1386 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const;
1387 typedef typename impl::BindCallback<R>::Type TCallback;
1388 typedef impl::DispatcherBindMemFun10<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10> TDispatcher;
1389 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10));
1390}
1391
1392/** @ingroup Bind
1393 */
1394template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1395CallbackR0<R>
1396bind(const CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10)
1397{
1398 typedef CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> TFun;
1399 typedef CallbackR0<R> TCallback;
1400 typedef impl::DispatcherBindFun10<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10> TDispatcher;
1401 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10));
1402}
1403
1404/** @ingroup Bind
1405 */
1406template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10>
1407Callback0
1408bind(const Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10)
1409{
1410 typedef Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> TFun;
1411 typedef Callback0 TCallback;
1412 typedef impl::DispatcherBindFun10<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10> TDispatcher;
1413 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10));
1414}
1415
1416
1417
1418// --- 11 argument(s) -----------------------------------------------------------------------------
1419
1420namespace impl
1421{
1422
1423/** @ingroup Bind
1424 * @internal
1425 */
1426template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1427class DispatcherBindFun11: public BindDispatcher<R>
1428{
1429public:
1430 DispatcherBindFun11(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11) {}
1431private:
1432 R doCall() const override
1433 {
1434 if (!fun_)
1435 {
1436 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1437 }
1438 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
1439 }
1440 Fun fun_;
1441 typename CallTraits<X1>::TValue x1_;
1442 typename CallTraits<X2>::TValue x2_;
1443 typename CallTraits<X3>::TValue x3_;
1444 typename CallTraits<X4>::TValue x4_;
1445 typename CallTraits<X5>::TValue x5_;
1446 typename CallTraits<X6>::TValue x6_;
1447 typename CallTraits<X7>::TValue x7_;
1448 typename CallTraits<X8>::TValue x8_;
1449 typename CallTraits<X9>::TValue x9_;
1450 typename CallTraits<X10>::TValue x10_;
1451 typename CallTraits<X11>::TValue x11_;
1452};
1453
1454/** @ingroup Bind
1455 * @internal
1456 */
1457template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1458class DispatcherBindMemFun11: public BindDispatcher<R>
1459{
1460public:
1461 DispatcherBindMemFun11(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11) {}
1462private:
1463 R doCall() const override
1464 {
1465 if (!obj_ || !fun_)
1466 {
1467 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1468 }
1469 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_);
1470 }
1471 ObjPtr obj_;
1472 Fun fun_;
1473 typename CallTraits<X1>::TValue x1_;
1474 typename CallTraits<X2>::TValue x2_;
1475 typename CallTraits<X3>::TValue x3_;
1476 typename CallTraits<X4>::TValue x4_;
1477 typename CallTraits<X5>::TValue x5_;
1478 typename CallTraits<X6>::TValue x6_;
1479 typename CallTraits<X7>::TValue x7_;
1480 typename CallTraits<X8>::TValue x8_;
1481 typename CallTraits<X9>::TValue x9_;
1482 typename CallTraits<X10>::TValue x10_;
1483 typename CallTraits<X11>::TValue x11_;
1484};
1485
1486}
1487
1488/** @ingroup Bind
1489 */
1490template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1491typename impl::BindCallback<R>::Type
1492bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11)
1493{
1494 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
1495 typedef typename impl::BindCallback<R>::Type TCallback;
1496 typedef impl::DispatcherBindFun11<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11> TDispatcher;
1497 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11));
1498}
1499
1500/** @ingroup Bind
1501 */
1502template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1503typename impl::BindCallback<R>::Type
1504bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11)
1505{
1506 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
1507 typedef typename impl::BindCallback<R>::Type TCallback;
1508 typedef impl::DispatcherBindMemFun11<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11> TDispatcher;
1509 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11));
1510}
1511
1512/** @ingroup Bind
1513 */
1514template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1515typename impl::BindCallback<R>::Type
1516bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11)
1517{
1518 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const;
1519 typedef typename impl::BindCallback<R>::Type TCallback;
1520 typedef impl::DispatcherBindMemFun11<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11> TDispatcher;
1521 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11));
1522}
1523
1524/** @ingroup Bind
1525 */
1526template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1527CallbackR0<R>
1528bind(const CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11)
1529{
1530 typedef CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> TFun;
1531 typedef CallbackR0<R> TCallback;
1532 typedef impl::DispatcherBindFun11<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11> TDispatcher;
1533 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11));
1534}
1535
1536/** @ingroup Bind
1537 */
1538template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11>
1539Callback0
1540bind(const Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11)
1541{
1542 typedef Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> TFun;
1543 typedef Callback0 TCallback;
1544 typedef impl::DispatcherBindFun11<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11> TDispatcher;
1545 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11));
1546}
1547
1548
1549
1550// --- 12 argument(s) -----------------------------------------------------------------------------
1551
1552namespace impl
1553{
1554
1555/** @ingroup Bind
1556 * @internal
1557 */
1558template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1559class DispatcherBindFun12: public BindDispatcher<R>
1560{
1561public:
1562 DispatcherBindFun12(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12) {}
1563private:
1564 R doCall() const override
1565 {
1566 if (!fun_)
1567 {
1568 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1569 }
1570 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
1571 }
1572 Fun fun_;
1573 typename CallTraits<X1>::TValue x1_;
1574 typename CallTraits<X2>::TValue x2_;
1575 typename CallTraits<X3>::TValue x3_;
1576 typename CallTraits<X4>::TValue x4_;
1577 typename CallTraits<X5>::TValue x5_;
1578 typename CallTraits<X6>::TValue x6_;
1579 typename CallTraits<X7>::TValue x7_;
1580 typename CallTraits<X8>::TValue x8_;
1581 typename CallTraits<X9>::TValue x9_;
1582 typename CallTraits<X10>::TValue x10_;
1583 typename CallTraits<X11>::TValue x11_;
1584 typename CallTraits<X12>::TValue x12_;
1585};
1586
1587/** @ingroup Bind
1588 * @internal
1589 */
1590template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1591class DispatcherBindMemFun12: public BindDispatcher<R>
1592{
1593public:
1594 DispatcherBindMemFun12(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12) {}
1595private:
1596 R doCall() const override
1597 {
1598 if (!obj_ || !fun_)
1599 {
1600 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1601 }
1602 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_);
1603 }
1604 ObjPtr obj_;
1605 Fun fun_;
1606 typename CallTraits<X1>::TValue x1_;
1607 typename CallTraits<X2>::TValue x2_;
1608 typename CallTraits<X3>::TValue x3_;
1609 typename CallTraits<X4>::TValue x4_;
1610 typename CallTraits<X5>::TValue x5_;
1611 typename CallTraits<X6>::TValue x6_;
1612 typename CallTraits<X7>::TValue x7_;
1613 typename CallTraits<X8>::TValue x8_;
1614 typename CallTraits<X9>::TValue x9_;
1615 typename CallTraits<X10>::TValue x10_;
1616 typename CallTraits<X11>::TValue x11_;
1617 typename CallTraits<X12>::TValue x12_;
1618};
1619
1620}
1621
1622/** @ingroup Bind
1623 */
1624template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1625typename impl::BindCallback<R>::Type
1626bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12)
1627{
1628 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
1629 typedef typename impl::BindCallback<R>::Type TCallback;
1630 typedef impl::DispatcherBindFun12<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12> TDispatcher;
1631 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12));
1632}
1633
1634/** @ingroup Bind
1635 */
1636template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1637typename impl::BindCallback<R>::Type
1638bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12)
1639{
1640 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
1641 typedef typename impl::BindCallback<R>::Type TCallback;
1642 typedef impl::DispatcherBindMemFun12<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12> TDispatcher;
1643 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12));
1644}
1645
1646/** @ingroup Bind
1647 */
1648template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1649typename impl::BindCallback<R>::Type
1650bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12)
1651{
1652 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const;
1653 typedef typename impl::BindCallback<R>::Type TCallback;
1654 typedef impl::DispatcherBindMemFun12<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12> TDispatcher;
1655 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12));
1656}
1657
1658/** @ingroup Bind
1659 */
1660template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1661CallbackR0<R>
1662bind(const CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12)
1663{
1664 typedef CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> TFun;
1665 typedef CallbackR0<R> TCallback;
1666 typedef impl::DispatcherBindFun12<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12> TDispatcher;
1667 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12));
1668}
1669
1670/** @ingroup Bind
1671 */
1672template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12>
1673Callback0
1674bind(const Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12)
1675{
1676 typedef Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> TFun;
1677 typedef Callback0 TCallback;
1678 typedef impl::DispatcherBindFun12<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12> TDispatcher;
1679 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12));
1680}
1681
1682
1683
1684// --- 13 argument(s) -----------------------------------------------------------------------------
1685
1686namespace impl
1687{
1688
1689/** @ingroup Bind
1690 * @internal
1691 */
1692template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1693class DispatcherBindFun13: public BindDispatcher<R>
1694{
1695public:
1696 DispatcherBindFun13(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13) {}
1697private:
1698 R doCall() const override
1699 {
1700 if (!fun_)
1701 {
1702 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1703 }
1704 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_);
1705 }
1706 Fun fun_;
1707 typename CallTraits<X1>::TValue x1_;
1708 typename CallTraits<X2>::TValue x2_;
1709 typename CallTraits<X3>::TValue x3_;
1710 typename CallTraits<X4>::TValue x4_;
1711 typename CallTraits<X5>::TValue x5_;
1712 typename CallTraits<X6>::TValue x6_;
1713 typename CallTraits<X7>::TValue x7_;
1714 typename CallTraits<X8>::TValue x8_;
1715 typename CallTraits<X9>::TValue x9_;
1716 typename CallTraits<X10>::TValue x10_;
1717 typename CallTraits<X11>::TValue x11_;
1718 typename CallTraits<X12>::TValue x12_;
1719 typename CallTraits<X13>::TValue x13_;
1720};
1721
1722/** @ingroup Bind
1723 * @internal
1724 */
1725template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1726class DispatcherBindMemFun13: public BindDispatcher<R>
1727{
1728public:
1729 DispatcherBindMemFun13(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13) {}
1730private:
1731 R doCall() const override
1732 {
1733 if (!obj_ || !fun_)
1734 {
1735 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1736 }
1737 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_);
1738 }
1739 ObjPtr obj_;
1740 Fun fun_;
1741 typename CallTraits<X1>::TValue x1_;
1742 typename CallTraits<X2>::TValue x2_;
1743 typename CallTraits<X3>::TValue x3_;
1744 typename CallTraits<X4>::TValue x4_;
1745 typename CallTraits<X5>::TValue x5_;
1746 typename CallTraits<X6>::TValue x6_;
1747 typename CallTraits<X7>::TValue x7_;
1748 typename CallTraits<X8>::TValue x8_;
1749 typename CallTraits<X9>::TValue x9_;
1750 typename CallTraits<X10>::TValue x10_;
1751 typename CallTraits<X11>::TValue x11_;
1752 typename CallTraits<X12>::TValue x12_;
1753 typename CallTraits<X13>::TValue x13_;
1754};
1755
1756}
1757
1758/** @ingroup Bind
1759 */
1760template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1761typename impl::BindCallback<R>::Type
1762bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13)
1763{
1764 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
1765 typedef typename impl::BindCallback<R>::Type TCallback;
1766 typedef impl::DispatcherBindFun13<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13> TDispatcher;
1767 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13));
1768}
1769
1770/** @ingroup Bind
1771 */
1772template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1773typename impl::BindCallback<R>::Type
1774bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13)
1775{
1776 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
1777 typedef typename impl::BindCallback<R>::Type TCallback;
1778 typedef impl::DispatcherBindMemFun13<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13> TDispatcher;
1779 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13));
1780}
1781
1782/** @ingroup Bind
1783 */
1784template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1785typename impl::BindCallback<R>::Type
1786bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13)
1787{
1788 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const;
1789 typedef typename impl::BindCallback<R>::Type TCallback;
1790 typedef impl::DispatcherBindMemFun13<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13> TDispatcher;
1791 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13));
1792}
1793
1794/** @ingroup Bind
1795 */
1796template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1797CallbackR0<R>
1798bind(const CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13)
1799{
1800 typedef CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> TFun;
1801 typedef CallbackR0<R> TCallback;
1802 typedef impl::DispatcherBindFun13<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13> TDispatcher;
1803 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13));
1804}
1805
1806/** @ingroup Bind
1807 */
1808template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13>
1809Callback0
1810bind(const Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13)
1811{
1812 typedef Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> TFun;
1813 typedef Callback0 TCallback;
1814 typedef impl::DispatcherBindFun13<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13> TDispatcher;
1815 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13));
1816}
1817
1818
1819
1820// --- 14 argument(s) -----------------------------------------------------------------------------
1821
1822namespace impl
1823{
1824
1825/** @ingroup Bind
1826 * @internal
1827 */
1828template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1829class DispatcherBindFun14: public BindDispatcher<R>
1830{
1831public:
1832 DispatcherBindFun14(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13), x14_(x14) {}
1833private:
1834 R doCall() const override
1835 {
1836 if (!fun_)
1837 {
1838 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1839 }
1840 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_);
1841 }
1842 Fun fun_;
1843 typename CallTraits<X1>::TValue x1_;
1844 typename CallTraits<X2>::TValue x2_;
1845 typename CallTraits<X3>::TValue x3_;
1846 typename CallTraits<X4>::TValue x4_;
1847 typename CallTraits<X5>::TValue x5_;
1848 typename CallTraits<X6>::TValue x6_;
1849 typename CallTraits<X7>::TValue x7_;
1850 typename CallTraits<X8>::TValue x8_;
1851 typename CallTraits<X9>::TValue x9_;
1852 typename CallTraits<X10>::TValue x10_;
1853 typename CallTraits<X11>::TValue x11_;
1854 typename CallTraits<X12>::TValue x12_;
1855 typename CallTraits<X13>::TValue x13_;
1856 typename CallTraits<X14>::TValue x14_;
1857};
1858
1859/** @ingroup Bind
1860 * @internal
1861 */
1862template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1863class DispatcherBindMemFun14: public BindDispatcher<R>
1864{
1865public:
1866 DispatcherBindMemFun14(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13), x14_(x14) {}
1867private:
1868 R doCall() const override
1869 {
1870 if (!obj_ || !fun_)
1871 {
1872 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1873 }
1874 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_);
1875 }
1876 ObjPtr obj_;
1877 Fun fun_;
1878 typename CallTraits<X1>::TValue x1_;
1879 typename CallTraits<X2>::TValue x2_;
1880 typename CallTraits<X3>::TValue x3_;
1881 typename CallTraits<X4>::TValue x4_;
1882 typename CallTraits<X5>::TValue x5_;
1883 typename CallTraits<X6>::TValue x6_;
1884 typename CallTraits<X7>::TValue x7_;
1885 typename CallTraits<X8>::TValue x8_;
1886 typename CallTraits<X9>::TValue x9_;
1887 typename CallTraits<X10>::TValue x10_;
1888 typename CallTraits<X11>::TValue x11_;
1889 typename CallTraits<X12>::TValue x12_;
1890 typename CallTraits<X13>::TValue x13_;
1891 typename CallTraits<X14>::TValue x14_;
1892};
1893
1894}
1895
1896/** @ingroup Bind
1897 */
1898template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1899typename impl::BindCallback<R>::Type
1900bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14)
1901{
1902 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);
1903 typedef typename impl::BindCallback<R>::Type TCallback;
1904 typedef impl::DispatcherBindFun14<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14> TDispatcher;
1905 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14));
1906}
1907
1908/** @ingroup Bind
1909 */
1910template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1911typename impl::BindCallback<R>::Type
1912bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14)
1913{
1914 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);
1915 typedef typename impl::BindCallback<R>::Type TCallback;
1916 typedef impl::DispatcherBindMemFun14<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14> TDispatcher;
1917 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14));
1918}
1919
1920/** @ingroup Bind
1921 */
1922template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1923typename impl::BindCallback<R>::Type
1924bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14)
1925{
1926 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const;
1927 typedef typename impl::BindCallback<R>::Type TCallback;
1928 typedef impl::DispatcherBindMemFun14<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14> TDispatcher;
1929 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14));
1930}
1931
1932/** @ingroup Bind
1933 */
1934template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1935CallbackR0<R>
1936bind(const CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14)
1937{
1938 typedef CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> TFun;
1939 typedef CallbackR0<R> TCallback;
1940 typedef impl::DispatcherBindFun14<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14> TDispatcher;
1941 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14));
1942}
1943
1944/** @ingroup Bind
1945 */
1946template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14>
1947Callback0
1948bind(const Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14)
1949{
1950 typedef Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> TFun;
1951 typedef Callback0 TCallback;
1952 typedef impl::DispatcherBindFun14<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14> TDispatcher;
1953 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14));
1954}
1955
1956
1957
1958// --- 15 argument(s) -----------------------------------------------------------------------------
1959
1960namespace impl
1961{
1962
1963/** @ingroup Bind
1964 * @internal
1965 */
1966template <typename R, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
1967class DispatcherBindFun15: public BindDispatcher<R>
1968{
1969public:
1970 DispatcherBindFun15(Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15): fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13), x14_(x14), x15_(x15) {}
1971private:
1972 R doCall() const override
1973 {
1974 if (!fun_)
1975 {
1976 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
1977 }
1978 return fun_(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_);
1979 }
1980 Fun fun_;
1981 typename CallTraits<X1>::TValue x1_;
1982 typename CallTraits<X2>::TValue x2_;
1983 typename CallTraits<X3>::TValue x3_;
1984 typename CallTraits<X4>::TValue x4_;
1985 typename CallTraits<X5>::TValue x5_;
1986 typename CallTraits<X6>::TValue x6_;
1987 typename CallTraits<X7>::TValue x7_;
1988 typename CallTraits<X8>::TValue x8_;
1989 typename CallTraits<X9>::TValue x9_;
1990 typename CallTraits<X10>::TValue x10_;
1991 typename CallTraits<X11>::TValue x11_;
1992 typename CallTraits<X12>::TValue x12_;
1993 typename CallTraits<X13>::TValue x13_;
1994 typename CallTraits<X14>::TValue x14_;
1995 typename CallTraits<X15>::TValue x15_;
1996};
1997
1998/** @ingroup Bind
1999 * @internal
2000 */
2001template <typename R, typename ObjPtr, typename Fun, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2002class DispatcherBindMemFun15: public BindDispatcher<R>
2003{
2004public:
2005 DispatcherBindMemFun15(ObjPtr obj, Fun fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15): obj_(obj), fun_(fun), x1_(x1), x2_(x2), x3_(x3), x4_(x4), x5_(x5), x6_(x6), x7_(x7), x8_(x8), x9_(x9), x10_(x10), x11_(x11), x12_(x12), x13_(x13), x14_(x14), x15_(x15) {}
2006private:
2007 R doCall() const override
2008 {
2009 if (!obj_ || !fun_)
2010 {
2011 LASS_THROW_EX(EmptyCallback, "You've tried to call an empty CallbackR0. Can't return a value.");
2012 }
2013 return ((*obj_).*fun_)(x1_, x2_, x3_, x4_, x5_, x6_, x7_, x8_, x9_, x10_, x11_, x12_, x13_, x14_, x15_);
2014 }
2015 ObjPtr obj_;
2016 Fun fun_;
2017 typename CallTraits<X1>::TValue x1_;
2018 typename CallTraits<X2>::TValue x2_;
2019 typename CallTraits<X3>::TValue x3_;
2020 typename CallTraits<X4>::TValue x4_;
2021 typename CallTraits<X5>::TValue x5_;
2022 typename CallTraits<X6>::TValue x6_;
2023 typename CallTraits<X7>::TValue x7_;
2024 typename CallTraits<X8>::TValue x8_;
2025 typename CallTraits<X9>::TValue x9_;
2026 typename CallTraits<X10>::TValue x10_;
2027 typename CallTraits<X11>::TValue x11_;
2028 typename CallTraits<X12>::TValue x12_;
2029 typename CallTraits<X13>::TValue x13_;
2030 typename CallTraits<X14>::TValue x14_;
2031 typename CallTraits<X15>::TValue x15_;
2032};
2033
2034}
2035
2036/** @ingroup Bind
2037 */
2038template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2039typename impl::BindCallback<R>::Type
2040bind(R (*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15)
2041{
2042 typedef R (*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);
2043 typedef typename impl::BindCallback<R>::Type TCallback;
2044 typedef impl::DispatcherBindFun15<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15> TDispatcher;
2045 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15));
2046}
2047
2048/** @ingroup Bind
2049 */
2050template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2051typename impl::BindCallback<R>::Type
2052bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15), ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15)
2053{
2054 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);
2055 typedef typename impl::BindCallback<R>::Type TCallback;
2056 typedef impl::DispatcherBindMemFun15<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15> TDispatcher;
2057 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15));
2058}
2059
2060/** @ingroup Bind
2061 */
2062template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename Obj, typename ObjPtr, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2063typename impl::BindCallback<R>::Type
2064bind(R (Obj::*fun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const, ObjPtr obj, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15)
2065{
2066 typedef R (Obj::*TFun)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const;
2067 typedef typename impl::BindCallback<R>::Type TCallback;
2068 typedef impl::DispatcherBindMemFun15<R, ObjPtr, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15> TDispatcher;
2069 return TCallback(TDispatcher(obj, fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15));
2070}
2071
2072/** @ingroup Bind
2073 */
2074template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2075CallbackR0<R>
2076bind(const CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15)
2077{
2078 typedef CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> TFun;
2079 typedef CallbackR0<R> TCallback;
2080 typedef impl::DispatcherBindFun15<R, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15> TDispatcher;
2081 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15));
2082}
2083
2084/** @ingroup Bind
2085 */
2086template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename X1, typename X2, typename X3, typename X4, typename X5, typename X6, typename X7, typename X8, typename X9, typename X10, typename X11, typename X12, typename X13, typename X14, typename X15>
2087Callback0
2088bind(const Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>& fun, X1 x1, X2 x2, X3 x3, X4 x4, X5 x5, X6 x6, X7 x7, X8 x8, X9 x9, X10 x10, X11 x11, X12 x12, X13 x13, X14 x14, X15 x15)
2089{
2090 typedef Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> TFun;
2091 typedef Callback0 TCallback;
2092 typedef impl::DispatcherBindFun15<void, TFun, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15> TDispatcher;
2093 return TCallback(TDispatcher(fun, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15));
2094}
2095
2096
2097
2098}
2099
2100}
2101
2102#if LASS_COMPILER_TYPE == LASS_COMPILER_TYPE_MSVC
2103# pragma warning(pop)
2104#endif
2105
2106#endif
2107
2108// EOF
callback_0.h
callback_10.h
callback_11.h
callback_12.h
callback_13.h
callback_14.h
callback_15.h
callback_1.h
callback_2.h
callback_3.h
callback_4.h
callback_5.h
callback_6.h
callback_7.h
callback_8.h
callback_9.h
callback_r_0.h
callback_r_10.h
callback_r_11.h
callback_r_12.h
callback_r_13.h
callback_r_14.h
callback_r_15.h
callback_r_1.h
callback_r_2.h
callback_r_3.h
callback_r_4.h
callback_r_5.h
callback_r_6.h
callback_r_7.h
callback_r_8.h
callback_r_9.h
lass::util::Callback0
callback with 0 parameter(s) and without returnvalue.
Definition callback_0.h:84
lass::util::Callback10
callback with 10 parameter(s) but without returnvalue.
Definition callback_10.h:97
lass::util::Callback11
callback with 11 parameter(s) but without returnvalue.
Definition callback_11.h:97
lass::util::Callback12
callback with 12 parameter(s) but without returnvalue.
Definition callback_12.h:97
lass::util::Callback13
callback with 13 parameter(s) but without returnvalue.
Definition callback_13.h:97
lass::util::Callback14
callback with 14 parameter(s) but without returnvalue.
Definition callback_14.h:97
lass::util::Callback15
callback with 15 parameter(s) but without returnvalue.
Definition callback_15.h:97
lass::util::Callback1
callback with 1 parameter(s) but without returnvalue.
Definition callback_1.h:97
lass::util::Callback2
callback with 2 parameter(s) but without returnvalue.
Definition callback_2.h:97
lass::util::Callback3
callback with 3 parameter(s) but without returnvalue.
Definition callback_3.h:97
lass::util::Callback4
callback with 4 parameter(s) but without returnvalue.
Definition callback_4.h:97
lass::util::Callback5
callback with 5 parameter(s) but without returnvalue.
Definition callback_5.h:97
lass::util::Callback6
callback with 6 parameter(s) but without returnvalue.
Definition callback_6.h:97
lass::util::Callback7
callback with 7 parameter(s) but without returnvalue.
Definition callback_7.h:97
lass::util::Callback8
callback with 8 parameter(s) but without returnvalue.
Definition callback_8.h:97
lass::util::Callback9
callback with 9 parameter(s) but without returnvalue.
Definition callback_9.h:97
lass::util::CallbackR0
callback with 0 parameters but with returnvalue.
Definition callback_r_0.h:91
lass::util::CallbackR10
callback with 10 parameter10 and with returnvalue.
Definition callback_r_10.h:98
lass::util::CallbackR11
callback with 11 parameter11 and with returnvalue.
Definition callback_r_11.h:98
lass::util::CallbackR12
callback with 12 parameter12 and with returnvalue.
Definition callback_r_12.h:98
lass::util::CallbackR13
callback with 13 parameter13 and with returnvalue.
Definition callback_r_13.h:98
lass::util::CallbackR14
callback with 14 parameter14 and with returnvalue.
Definition callback_r_14.h:98
lass::util::CallbackR15
callback with 15 parameter15 and with returnvalue.
Definition callback_r_15.h:98
lass::util::CallbackR1
callback with 1 parameter1 and with returnvalue.
Definition callback_r_1.h:98
lass::util::CallbackR2
callback with 2 parameter2 and with returnvalue.
Definition callback_r_2.h:98
lass::util::CallbackR3
callback with 3 parameter3 and with returnvalue.
Definition callback_r_3.h:98
lass::util::CallbackR4
callback with 4 parameter4 and with returnvalue.
Definition callback_r_4.h:98
lass::util::CallbackR5
callback with 5 parameter5 and with returnvalue.
Definition callback_r_5.h:98
lass::util::CallbackR6
callback with 6 parameter6 and with returnvalue.
Definition callback_r_6.h:98
lass::util::CallbackR7
callback with 7 parameter7 and with returnvalue.
Definition callback_r_7.h:98
lass::util::CallbackR8
callback with 8 parameter8 and with returnvalue.
Definition callback_r_8.h:98
lass::util::CallbackR9
callback with 9 parameter9 and with returnvalue.
Definition callback_r_9.h:98
lass::util::impl::DispatcherR0
abstract base class of all dispatchers for lass::util::CallbackR0.
Definition dispatcher_r_0.h:68
lass::util
general utility, debug facilities, ...
lass
Library for Assembled Shared Sources.
Definition config.h:53
util_common.h