- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files
- Directories
- Examples

- File List
- File Members

# qtconcurrentstoredfunctioncall.h

Go to the documentation of this file.

    00001 /****************************************************************************
    00002 **
    00003 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
    00004 ** All rights reserved.
    00005 ** Contact: Nokia Corporation (qt-info@nokia.com)
    00006 **
    00007 ** This file is part of the QtCore module of the Qt Toolkit.
    00008 **
    00009 ** $QT_BEGIN_LICENSE:LGPL$
    00010 ** Commercial Usage
    00011 ** Licensees holding valid Qt Commercial licenses may use this file in
    00012 ** accordance with the Qt Commercial License Agreement provided with the
    00013 ** Software or, alternatively, in accordance with the terms contained in
    00014 ** a written agreement between you and Nokia.
    00015 **
    00016 ** GNU Lesser General Public License Usage
    00017 ** Alternatively, this file may be used under the terms of the GNU Lesser
    00018 ** General Public License version 2.1 as published by the Free Software
    00019 ** Foundation and appearing in the file LICENSE.LGPL included in the
    00020 ** packaging of this file.  Please review the following information to
    00021 ** ensure the GNU Lesser General Public License version 2.1 requirements
    00022 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    00023 **
    00024 ** In addition, as a special exception, Nokia gives you certain additional
    00025 ** rights.  These rights are described in the Nokia Qt LGPL Exception
    00026 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this module.
    00027 **
    00028 ** GNU General Public License Usage
    00029 ** Alternatively, this file may be used under the terms of the GNU
    00030 ** General Public License version 3.0 as published by the Free Software
    00031 ** Foundation and appearing in the file LICENSE.GPL included in the
    00032 ** packaging of this file.  Please review the following information to
    00033 ** ensure the GNU General Public License version 3.0 requirements will be
    00034 ** met: http://www.gnu.org/copyleft/gpl.html.
    00035 **
    00036 ** If you have questions regarding the use of this file, please contact
    00037 ** Nokia at qt-info@nokia.com.
    00038 ** $QT_END_LICENSE$
    00039 **
    00040 ****************************************************************************/
    00041
    00042 // Generated code, do not edit! Use generator at tools/qtconcurrent/generaterun/
    00043 #ifndef QTCONCURRENT_STOREDFUNCTIONCALL_H
    00044 #define QTCONCURRENT_STOREDFUNCTIONCALL_H
    00045
    00046 #include <QtCore/qglobal.h>
    00047
    00048 #ifndef QT_NO_CONCURRENT
    00049 #include <QtCore/qtconcurrentrunbase.h>
    00050
    00051 QT_BEGIN_HEADER
    00052 QT_BEGIN_NAMESPACE
    00053
    00054 QT_MODULE(Core)
    00055
    00056 #ifndef qdoc
    00057
    00058 namespace QtConcurrent {
    00059 template <typename T, typename FunctionPointer>
    00060 struct StoredFunctorCall0: public RunFunctionTask<T>
    00061 {
    00062     inline StoredFunctorCall0(FunctionPointer _function)
    00063       : function(_function) {}
    00064     void runFunctor() { this->result = function(); }
    00065     FunctionPointer function;
    00066
    00067 };
    00068
    00069 template <typename T, typename FunctionPointer>
    00070 struct VoidStoredFunctorCall0: public RunFunctionTask<T>
    00071 {
    00072     inline VoidStoredFunctorCall0(FunctionPointer _function)
    00073       : function(_function) {}
    00074     void runFunctor() { function(); }
    00075     FunctionPointer function;
    00076
    00077 };
    00078
    00079 template <typename T, typename FunctionPointer>
    00080 struct SelectStoredFunctorCall0
    00081 {
    00082     typedef typename SelectSpecialization<T>::template
    00083         Type<StoredFunctorCall0    <T, FunctionPointer>,
    00084              VoidStoredFunctorCall0<T, FunctionPointer> >::type type;
    00085 };
    00086 template <typename T, typename FunctionPointer>
    00087 struct StoredFunctorPointerCall0: public RunFunctionTask<T>
    00088 {
    00089     inline StoredFunctorPointerCall0(FunctionPointer * _function)
    00090       : function(_function) {}
    00091     void runFunctor() { this->result =(*function)(); }
    00092     FunctionPointer * function;
    00093
    00094 };
    00095
    00096 template <typename T, typename FunctionPointer>
    00097 struct VoidStoredFunctorPointerCall0: public RunFunctionTask<T>
    00098 {
    00099     inline VoidStoredFunctorPointerCall0(FunctionPointer * _function)
    00100       : function(_function) {}
    00101     void runFunctor() {(*function)(); }
    00102     FunctionPointer * function;
    00103
    00104 };
    00105
    00106 template <typename T, typename FunctionPointer>
    00107 struct SelectStoredFunctorPointerCall0
    00108 {
    00109     typedef typename SelectSpecialization<T>::template
    00110         Type<StoredFunctorPointerCall0    <T, FunctionPointer>,
    00111              VoidStoredFunctorPointerCall0<T, FunctionPointer> >::type type;
    00112 };
    00113 template <typename T, typename Class>
    00114 class StoredMemberFunctionCall0 : public RunFunctionTask<T>
    00115 {
    00116 public:
    00117     StoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
    00118     : fn(_fn), object(_object){ }
    00119
    00120     void runFunctor()
    00121     {
    00122         this->result = (object.*fn)();
    00123     }
    00124 private:
    00125     T (Class::*fn)();
    00126     Class object;
    00127
    00128 };
    00129 template <typename T, typename Class>
    00130 class VoidStoredMemberFunctionCall0 : public RunFunctionTask<T>
    00131 {
    00132 public:
    00133     VoidStoredMemberFunctionCall0(T (Class::*_fn)() , const Class &_object)
    00134     : fn(_fn), object(_object){ }
    00135
    00136     void runFunctor()
    00137     {
    00138         (object.*fn)();
    00139     }
    00140 private:
    00141     T (Class::*fn)();
    00142     Class object;
    00143
    00144 };
    00145 template <typename T, typename Class>
    00146 struct SelectStoredMemberFunctionCall0
    00147 {
    00148     typedef typename SelectSpecialization<T>::template
    00149         Type<StoredMemberFunctionCall0    <T, Class>,
    00150              VoidStoredMemberFunctionCall0<T, Class> >::type type;
    00151 };
    00152 template <typename T, typename Class>
    00153 class StoredConstMemberFunctionCall0 : public RunFunctionTask<T>
    00154 {
    00155 public:
    00156     StoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
    00157     : fn(_fn), object(_object){ }
    00158
    00159     void runFunctor()
    00160     {
    00161         this->result = (object.*fn)();
    00162     }
    00163 private:
    00164     T (Class::*fn)()const;
    00165     const Class object;
    00166
    00167 };
    00168 template <typename T, typename Class>
    00169 class VoidStoredConstMemberFunctionCall0 : public RunFunctionTask<T>
    00170 {
    00171 public:
    00172     VoidStoredConstMemberFunctionCall0(T (Class::*_fn)() const, const Class &_object)
    00173     : fn(_fn), object(_object){ }
    00174
    00175     void runFunctor()
    00176     {
    00177         (object.*fn)();
    00178     }
    00179 private:
    00180     T (Class::*fn)()const;
    00181     const Class object;
    00182
    00183 };
    00184 template <typename T, typename Class>
    00185 struct SelectStoredConstMemberFunctionCall0
    00186 {
    00187     typedef typename SelectSpecialization<T>::template
    00188         Type<StoredConstMemberFunctionCall0    <T, Class>,
    00189              VoidStoredConstMemberFunctionCall0<T, Class> >::type type;
    00190 };
    00191 template <typename T, typename Class>
    00192 class StoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
    00193 {
    00194 public:
    00195     StoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
    00196     : fn(_fn), object(_object){ }
    00197
    00198     void runFunctor()
    00199     {
    00200         this->result = (object->*fn)();
    00201     }
    00202 private:
    00203     T (Class::*fn)();
    00204     Class *object;
    00205
    00206 };
    00207 template <typename T, typename Class>
    00208 class VoidStoredMemberFunctionPointerCall0 : public RunFunctionTask<T>
    00209 {
    00210 public:
    00211     VoidStoredMemberFunctionPointerCall0(T (Class::*_fn)() , Class *_object)
    00212     : fn(_fn), object(_object){ }
    00213
    00214     void runFunctor()
    00215     {
    00216         (object->*fn)();
    00217     }
    00218 private:
    00219     T (Class::*fn)();
    00220     Class *object;
    00221
    00222 };
    00223 template <typename T, typename Class>
    00224 struct SelectStoredMemberFunctionPointerCall0
    00225 {
    00226     typedef typename SelectSpecialization<T>::template
    00227         Type<StoredMemberFunctionPointerCall0    <T, Class>,
    00228              VoidStoredMemberFunctionPointerCall0<T, Class> >::type type;
    00229 };
    00230 template <typename T, typename Class>
    00231 class StoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
    00232 {
    00233 public:
    00234     StoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
    00235     : fn(_fn), object(_object){ }
    00236
    00237     void runFunctor()
    00238     {
    00239         this->result = (object->*fn)();
    00240     }
    00241 private:
    00242     T (Class::*fn)()const;
    00243     Class const *object;
    00244
    00245 };
    00246 template <typename T, typename Class>
    00247 class VoidStoredConstMemberFunctionPointerCall0 : public RunFunctionTask<T>
    00248 {
    00249 public:
    00250     VoidStoredConstMemberFunctionPointerCall0(T (Class::*_fn)() const, Class const *_object)
    00251     : fn(_fn), object(_object){ }
    00252
    00253     void runFunctor()
    00254     {
    00255         (object->*fn)();
    00256     }
    00257 private:
    00258     T (Class::*fn)()const;
    00259     Class const *object;
    00260
    00261 };
    00262 template <typename T, typename Class>
    00263 struct SelectStoredConstMemberFunctionPointerCall0
    00264 {
    00265     typedef typename SelectSpecialization<T>::template
    00266         Type<StoredConstMemberFunctionPointerCall0    <T, Class>,
    00267              VoidStoredConstMemberFunctionPointerCall0<T, Class> >::type type;
    00268 };
    00269 template <typename T, typename FunctionPointer, typename Arg1>
    00270 struct StoredFunctorCall1: public RunFunctionTask<T>
    00271 {
    00272     inline StoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
    00273       : function(_function), arg1(_arg1) {}
    00274     void runFunctor() { this->result = function(arg1); }
    00275     FunctionPointer function;
    00276     Arg1 arg1;
    00277 };
    00278
    00279 template <typename T, typename FunctionPointer, typename Arg1>
    00280 struct VoidStoredFunctorCall1: public RunFunctionTask<T>
    00281 {
    00282     inline VoidStoredFunctorCall1(FunctionPointer _function, const Arg1 &_arg1)
    00283       : function(_function), arg1(_arg1) {}
    00284     void runFunctor() { function(arg1); }
    00285     FunctionPointer function;
    00286     Arg1 arg1;
    00287 };
    00288
    00289 template <typename T, typename FunctionPointer, typename Arg1>
    00290 struct SelectStoredFunctorCall1
    00291 {
    00292     typedef typename SelectSpecialization<T>::template
    00293         Type<StoredFunctorCall1    <T, FunctionPointer, Arg1>,
    00294              VoidStoredFunctorCall1<T, FunctionPointer, Arg1> >::type type;
    00295 };
    00296 template <typename T, typename FunctionPointer, typename Arg1>
    00297 struct StoredFunctorPointerCall1: public RunFunctionTask<T>
    00298 {
    00299     inline StoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
    00300       : function(_function), arg1(_arg1) {}
    00301     void runFunctor() { this->result =(*function)(arg1); }
    00302     FunctionPointer * function;
    00303     Arg1 arg1;
    00304 };
    00305
    00306 template <typename T, typename FunctionPointer, typename Arg1>
    00307 struct VoidStoredFunctorPointerCall1: public RunFunctionTask<T>
    00308 {
    00309     inline VoidStoredFunctorPointerCall1(FunctionPointer * _function, const Arg1 &_arg1)
    00310       : function(_function), arg1(_arg1) {}
    00311     void runFunctor() {(*function)(arg1); }
    00312     FunctionPointer * function;
    00313     Arg1 arg1;
    00314 };
    00315
    00316 template <typename T, typename FunctionPointer, typename Arg1>
    00317 struct SelectStoredFunctorPointerCall1
    00318 {
    00319     typedef typename SelectSpecialization<T>::template
    00320         Type<StoredFunctorPointerCall1    <T, FunctionPointer, Arg1>,
    00321              VoidStoredFunctorPointerCall1<T, FunctionPointer, Arg1> >::type type;
    00322 };
    00323 template <typename T, typename Class, typename Param1, typename Arg1>
    00324 class StoredMemberFunctionCall1 : public RunFunctionTask<T>
    00325 {
    00326 public:
    00327     StoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
    00328     : fn(_fn), object(_object), arg1(_arg1){ }
    00329
    00330     void runFunctor()
    00331     {
    00332         this->result = (object.*fn)(arg1);
    00333     }
    00334 private:
    00335     T (Class::*fn)(Param1);
    00336     Class object;
    00337     Arg1 arg1;
    00338 };
    00339 template <typename T, typename Class, typename Param1, typename Arg1>
    00340 class VoidStoredMemberFunctionCall1 : public RunFunctionTask<T>
    00341 {
    00342 public:
    00343     VoidStoredMemberFunctionCall1(T (Class::*_fn)(Param1) , const Class &_object, const Arg1 &_arg1)
    00344     : fn(_fn), object(_object), arg1(_arg1){ }
    00345
    00346     void runFunctor()
    00347     {
    00348         (object.*fn)(arg1);
    00349     }
    00350 private:
    00351     T (Class::*fn)(Param1);
    00352     Class object;
    00353     Arg1 arg1;
    00354 };
    00355 template <typename T, typename Class, typename Param1, typename Arg1>
    00356 struct SelectStoredMemberFunctionCall1
    00357 {
    00358     typedef typename SelectSpecialization<T>::template
    00359         Type<StoredMemberFunctionCall1    <T, Class, Param1, Arg1>,
    00360              VoidStoredMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
    00361 };
    00362 template <typename T, typename Class, typename Param1, typename Arg1>
    00363 class StoredConstMemberFunctionCall1 : public RunFunctionTask<T>
    00364 {
    00365 public:
    00366     StoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
    00367     : fn(_fn), object(_object), arg1(_arg1){ }
    00368
    00369     void runFunctor()
    00370     {
    00371         this->result = (object.*fn)(arg1);
    00372     }
    00373 private:
    00374     T (Class::*fn)(Param1)const;
    00375     const Class object;
    00376     Arg1 arg1;
    00377 };
    00378 template <typename T, typename Class, typename Param1, typename Arg1>
    00379 class VoidStoredConstMemberFunctionCall1 : public RunFunctionTask<T>
    00380 {
    00381 public:
    00382     VoidStoredConstMemberFunctionCall1(T (Class::*_fn)(Param1) const, const Class &_object, const Arg1 &_arg1)
    00383     : fn(_fn), object(_object), arg1(_arg1){ }
    00384
    00385     void runFunctor()
    00386     {
    00387         (object.*fn)(arg1);
    00388     }
    00389 private:
    00390     T (Class::*fn)(Param1)const;
    00391     const Class object;
    00392     Arg1 arg1;
    00393 };
    00394 template <typename T, typename Class, typename Param1, typename Arg1>
    00395 struct SelectStoredConstMemberFunctionCall1
    00396 {
    00397     typedef typename SelectSpecialization<T>::template
    00398         Type<StoredConstMemberFunctionCall1    <T, Class, Param1, Arg1>,
    00399              VoidStoredConstMemberFunctionCall1<T, Class, Param1, Arg1> >::type type;
    00400 };
    00401 template <typename T, typename Class, typename Param1, typename Arg1>
    00402 class StoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
    00403 {
    00404 public:
    00405     StoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
    00406     : fn(_fn), object(_object), arg1(_arg1){ }
    00407
    00408     void runFunctor()
    00409     {
    00410         this->result = (object->*fn)(arg1);
    00411     }
    00412 private:
    00413     T (Class::*fn)(Param1);
    00414     Class *object;
    00415     Arg1 arg1;
    00416 };
    00417 template <typename T, typename Class, typename Param1, typename Arg1>
    00418 class VoidStoredMemberFunctionPointerCall1 : public RunFunctionTask<T>
    00419 {
    00420 public:
    00421     VoidStoredMemberFunctionPointerCall1(T (Class::*_fn)(Param1) , Class *_object, const Arg1 &_arg1)
    00422     : fn(_fn), object(_object), arg1(_arg1){ }
    00423
    00424     void runFunctor()
    00425     {
    00426         (object->*fn)(arg1);
    00427     }
    00428 private:
    00429     T (Class::*fn)(Param1);
    00430     Class *object;
    00431     Arg1 arg1;
    00432 };
    00433 template <typename T, typename Class, typename Param1, typename Arg1>
    00434 struct SelectStoredMemberFunctionPointerCall1
    00435 {
    00436     typedef typename SelectSpecialization<T>::template
    00437         Type<StoredMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
    00438              VoidStoredMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
    00439 };
    00440 template <typename T, typename Class, typename Param1, typename Arg1>
    00441 class StoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
    00442 {
    00443 public:
    00444     StoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
    00445     : fn(_fn), object(_object), arg1(_arg1){ }
    00446
    00447     void runFunctor()
    00448     {
    00449         this->result = (object->*fn)(arg1);
    00450     }
    00451 private:
    00452     T (Class::*fn)(Param1)const;
    00453     Class const *object;
    00454     Arg1 arg1;
    00455 };
    00456 template <typename T, typename Class, typename Param1, typename Arg1>
    00457 class VoidStoredConstMemberFunctionPointerCall1 : public RunFunctionTask<T>
    00458 {
    00459 public:
    00460     VoidStoredConstMemberFunctionPointerCall1(T (Class::*_fn)(Param1) const, Class const *_object, const Arg1 &_arg1)
    00461     : fn(_fn), object(_object), arg1(_arg1){ }
    00462
    00463     void runFunctor()
    00464     {
    00465         (object->*fn)(arg1);
    00466     }
    00467 private:
    00468     T (Class::*fn)(Param1)const;
    00469     Class const *object;
    00470     Arg1 arg1;
    00471 };
    00472 template <typename T, typename Class, typename Param1, typename Arg1>
    00473 struct SelectStoredConstMemberFunctionPointerCall1
    00474 {
    00475     typedef typename SelectSpecialization<T>::template
    00476         Type<StoredConstMemberFunctionPointerCall1    <T, Class, Param1, Arg1>,
    00477              VoidStoredConstMemberFunctionPointerCall1<T, Class, Param1, Arg1> >::type type;
    00478 };
    00479 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00480 struct StoredFunctorCall2: public RunFunctionTask<T>
    00481 {
    00482     inline StoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
    00483       : function(_function), arg1(_arg1), arg2(_arg2) {}
    00484     void runFunctor() { this->result = function(arg1, arg2); }
    00485     FunctionPointer function;
    00486     Arg1 arg1; Arg2 arg2;
    00487 };
    00488
    00489 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00490 struct VoidStoredFunctorCall2: public RunFunctionTask<T>
    00491 {
    00492     inline VoidStoredFunctorCall2(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2)
    00493       : function(_function), arg1(_arg1), arg2(_arg2) {}
    00494     void runFunctor() { function(arg1, arg2); }
    00495     FunctionPointer function;
    00496     Arg1 arg1; Arg2 arg2;
    00497 };
    00498
    00499 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00500 struct SelectStoredFunctorCall2
    00501 {
    00502     typedef typename SelectSpecialization<T>::template
    00503         Type<StoredFunctorCall2    <T, FunctionPointer, Arg1, Arg2>,
    00504              VoidStoredFunctorCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
    00505 };
    00506 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00507 struct StoredFunctorPointerCall2: public RunFunctionTask<T>
    00508 {
    00509     inline StoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
    00510       : function(_function), arg1(_arg1), arg2(_arg2) {}
    00511     void runFunctor() { this->result =(*function)(arg1, arg2); }
    00512     FunctionPointer * function;
    00513     Arg1 arg1; Arg2 arg2;
    00514 };
    00515
    00516 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00517 struct VoidStoredFunctorPointerCall2: public RunFunctionTask<T>
    00518 {
    00519     inline VoidStoredFunctorPointerCall2(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2)
    00520     : function(_function), arg1(_arg1), arg2(_arg2) {}
    00521     void runFunctor() {(*function)(arg1, arg2); }
    00522     FunctionPointer * function;
    00523     Arg1 arg1; Arg2 arg2;
    00524 };
    00525
    00526 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
    00527 struct SelectStoredFunctorPointerCall2
    00528 {
    00529     typedef typename SelectSpecialization<T>::template
    00530         Type<StoredFunctorPointerCall2    <T, FunctionPointer, Arg1, Arg2>,
    00531              VoidStoredFunctorPointerCall2<T, FunctionPointer, Arg1, Arg2> >::type type;
    00532 };
    00533 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00534 class StoredMemberFunctionCall2 : public RunFunctionTask<T>
    00535 {
    00536 public:
    00537     StoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00538     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00539
    00540     void runFunctor()
    00541     {
    00542         this->result = (object.*fn)(arg1, arg2);
    00543     }
    00544 private:
    00545     T (Class::*fn)(Param1, Param2);
    00546     Class object;
    00547     Arg1 arg1; Arg2 arg2;
    00548 };
    00549 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00550 class VoidStoredMemberFunctionCall2 : public RunFunctionTask<T>
    00551 {
    00552 public:
    00553     VoidStoredMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00554     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00555
    00556     void runFunctor()
    00557     {
    00558         (object.*fn)(arg1, arg2);
    00559     }
    00560 private:
    00561     T (Class::*fn)(Param1, Param2);
    00562     Class object;
    00563     Arg1 arg1; Arg2 arg2;
    00564 };
    00565 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00566 struct SelectStoredMemberFunctionCall2
    00567 {
    00568     typedef typename SelectSpecialization<T>::template
    00569         Type<StoredMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
    00570              VoidStoredMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
    00571 };
    00572 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00573 class StoredConstMemberFunctionCall2 : public RunFunctionTask<T>
    00574 {
    00575 public:
    00576     StoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00577     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00578
    00579     void runFunctor()
    00580     {
    00581         this->result = (object.*fn)(arg1, arg2);
    00582     }
    00583 private:
    00584     T (Class::*fn)(Param1, Param2)const;
    00585     const Class object;
    00586     Arg1 arg1; Arg2 arg2;
    00587 };
    00588 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00589 class VoidStoredConstMemberFunctionCall2 : public RunFunctionTask<T>
    00590 {
    00591 public:
    00592     VoidStoredConstMemberFunctionCall2(T (Class::*_fn)(Param1, Param2) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00593     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00594
    00595     void runFunctor()
    00596     {
    00597         (object.*fn)(arg1, arg2);
    00598     }
    00599 private:
    00600     T (Class::*fn)(Param1, Param2)const;
    00601     const Class object;
    00602     Arg1 arg1; Arg2 arg2;
    00603 };
    00604 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00605 struct SelectStoredConstMemberFunctionCall2
    00606 {
    00607     typedef typename SelectSpecialization<T>::template
    00608         Type<StoredConstMemberFunctionCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
    00609              VoidStoredConstMemberFunctionCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
    00610 };
    00611 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00612 class StoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
    00613 {
    00614 public:
    00615     StoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00616     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00617
    00618     void runFunctor()
    00619     {
    00620         this->result = (object->*fn)(arg1, arg2);
    00621     }
    00622 private:
    00623     T (Class::*fn)(Param1, Param2);
    00624     Class *object;
    00625     Arg1 arg1; Arg2 arg2;
    00626 };
    00627 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00628 class VoidStoredMemberFunctionPointerCall2 : public RunFunctionTask<T>
    00629 {
    00630 public:
    00631     VoidStoredMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00632     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00633
    00634     void runFunctor()
    00635     {
    00636         (object->*fn)(arg1, arg2);
    00637     }
    00638 private:
    00639     T (Class::*fn)(Param1, Param2);
    00640     Class *object;
    00641     Arg1 arg1; Arg2 arg2;
    00642 };
    00643 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00644 struct SelectStoredMemberFunctionPointerCall2
    00645 {
    00646     typedef typename SelectSpecialization<T>::template
    00647         Type<StoredMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
    00648              VoidStoredMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
    00649 };
    00650 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00651 class StoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
    00652 {
    00653 public:
    00654     StoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00655     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00656
    00657     void runFunctor()
    00658     {
    00659         this->result = (object->*fn)(arg1, arg2);
    00660     }
    00661 private:
    00662     T (Class::*fn)(Param1, Param2)const;
    00663     Class const *object;
    00664     Arg1 arg1; Arg2 arg2;
    00665 };
    00666 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00667 class VoidStoredConstMemberFunctionPointerCall2 : public RunFunctionTask<T>
    00668 {
    00669 public:
    00670     VoidStoredConstMemberFunctionPointerCall2(T (Class::*_fn)(Param1, Param2) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2)
    00671     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2){ }
    00672
    00673     void runFunctor()
    00674     {
    00675         (object->*fn)(arg1, arg2);
    00676     }
    00677 private:
    00678     T (Class::*fn)(Param1, Param2)const;
    00679     Class const *object;
    00680     Arg1 arg1; Arg2 arg2;
    00681 };
    00682 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2>
    00683 struct SelectStoredConstMemberFunctionPointerCall2
    00684 {
    00685     typedef typename SelectSpecialization<T>::template
    00686         Type<StoredConstMemberFunctionPointerCall2    <T, Class, Param1, Arg1, Param2, Arg2>,
    00687              VoidStoredConstMemberFunctionPointerCall2<T, Class, Param1, Arg1, Param2, Arg2> >::type type;
    00688 };
    00689 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00690 struct StoredFunctorCall3: public RunFunctionTask<T>
    00691 {
    00692     inline StoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00693       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
    00694     void runFunctor() { this->result = function(arg1, arg2, arg3); }
    00695     FunctionPointer function;
    00696     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00697 };
    00698
    00699 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00700 struct VoidStoredFunctorCall3: public RunFunctionTask<T>
    00701 {
    00702     inline VoidStoredFunctorCall3(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00703       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
    00704     void runFunctor() { function(arg1, arg2, arg3); }
    00705     FunctionPointer function;
    00706     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00707 };
    00708
    00709 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00710 struct SelectStoredFunctorCall3
    00711 {
    00712     typedef typename SelectSpecialization<T>::template
    00713         Type<StoredFunctorCall3    <T, FunctionPointer, Arg1, Arg2, Arg3>,
    00714              VoidStoredFunctorCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
    00715 };
    00716 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00717 struct StoredFunctorPointerCall3: public RunFunctionTask<T>
    00718 {
    00719     inline StoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00720       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
    00721     void runFunctor() { this->result =(*function)(arg1, arg2, arg3); }
    00722     FunctionPointer * function;
    00723     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00724 };
    00725
    00726 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00727 struct VoidStoredFunctorPointerCall3: public RunFunctionTask<T>
    00728 {
    00729     inline VoidStoredFunctorPointerCall3(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00730       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3) {}
    00731     void runFunctor() {(*function)(arg1, arg2, arg3); }
    00732     FunctionPointer * function;
    00733     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00734 };
    00735
    00736 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
    00737 struct SelectStoredFunctorPointerCall3
    00738 {
    00739     typedef typename SelectSpecialization<T>::template
    00740         Type<StoredFunctorPointerCall3    <T, FunctionPointer, Arg1, Arg2, Arg3>,
    00741              VoidStoredFunctorPointerCall3<T, FunctionPointer, Arg1, Arg2, Arg3> >::type type;
    00742 };
    00743 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00744 class StoredMemberFunctionCall3 : public RunFunctionTask<T>
    00745 {
    00746 public:
    00747     StoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00748     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00749
    00750     void runFunctor()
    00751     {
    00752         this->result = (object.*fn)(arg1, arg2, arg3);
    00753     }
    00754 private:
    00755     T (Class::*fn)(Param1, Param2, Param3);
    00756     Class object;
    00757     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00758 };
    00759 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00760 class VoidStoredMemberFunctionCall3 : public RunFunctionTask<T>
    00761 {
    00762 public:
    00763     VoidStoredMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00764     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00765
    00766     void runFunctor()
    00767     {
    00768         (object.*fn)(arg1, arg2, arg3);
    00769     }
    00770 private:
    00771     T (Class::*fn)(Param1, Param2, Param3);
    00772     Class object;
    00773     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00774 };
    00775 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00776 struct SelectStoredMemberFunctionCall3
    00777 {
    00778     typedef typename SelectSpecialization<T>::template
    00779         Type<StoredMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
    00780              VoidStoredMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
    00781 };
    00782 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00783 class StoredConstMemberFunctionCall3 : public RunFunctionTask<T>
    00784 {
    00785 public:
    00786     StoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00787     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00788
    00789     void runFunctor()
    00790     {
    00791         this->result = (object.*fn)(arg1, arg2, arg3);
    00792     }
    00793 private:
    00794     T (Class::*fn)(Param1, Param2, Param3)const;
    00795     const Class object;
    00796     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00797 };
    00798 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00799 class VoidStoredConstMemberFunctionCall3 : public RunFunctionTask<T>
    00800 {
    00801 public:
    00802     VoidStoredConstMemberFunctionCall3(T (Class::*_fn)(Param1, Param2, Param3) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00803     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00804
    00805     void runFunctor()
    00806     {
    00807         (object.*fn)(arg1, arg2, arg3);
    00808     }
    00809 private:
    00810     T (Class::*fn)(Param1, Param2, Param3)const;
    00811     const Class object;
    00812     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00813 };
    00814 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00815 struct SelectStoredConstMemberFunctionCall3
    00816 {
    00817     typedef typename SelectSpecialization<T>::template
    00818         Type<StoredConstMemberFunctionCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
    00819              VoidStoredConstMemberFunctionCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
    00820 };
    00821 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00822 class StoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
    00823 {
    00824 public:
    00825     StoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00826     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00827
    00828     void runFunctor()
    00829     {
    00830         this->result = (object->*fn)(arg1, arg2, arg3);
    00831     }
    00832 private:
    00833     T (Class::*fn)(Param1, Param2, Param3);
    00834     Class *object;
    00835     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00836 };
    00837 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00838 class VoidStoredMemberFunctionPointerCall3 : public RunFunctionTask<T>
    00839 {
    00840 public:
    00841     VoidStoredMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00842     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00843
    00844     void runFunctor()
    00845     {
    00846         (object->*fn)(arg1, arg2, arg3);
    00847     }
    00848 private:
    00849     T (Class::*fn)(Param1, Param2, Param3);
    00850     Class *object;
    00851     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00852 };
    00853 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00854 struct SelectStoredMemberFunctionPointerCall3
    00855 {
    00856     typedef typename SelectSpecialization<T>::template
    00857         Type<StoredMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
    00858              VoidStoredMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
    00859 };
    00860 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00861 class StoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
    00862 {
    00863 public:
    00864     StoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00865     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00866
    00867     void runFunctor()
    00868     {
    00869         this->result = (object->*fn)(arg1, arg2, arg3);
    00870     }
    00871 private:
    00872     T (Class::*fn)(Param1, Param2, Param3)const;
    00873     Class const *object;
    00874     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00875 };
    00876 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00877 class VoidStoredConstMemberFunctionPointerCall3 : public RunFunctionTask<T>
    00878 {
    00879 public:
    00880     VoidStoredConstMemberFunctionPointerCall3(T (Class::*_fn)(Param1, Param2, Param3) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3)
    00881     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3){ }
    00882
    00883     void runFunctor()
    00884     {
    00885         (object->*fn)(arg1, arg2, arg3);
    00886     }
    00887 private:
    00888     T (Class::*fn)(Param1, Param2, Param3)const;
    00889     Class const *object;
    00890     Arg1 arg1; Arg2 arg2; Arg3 arg3;
    00891 };
    00892 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3>
    00893 struct SelectStoredConstMemberFunctionPointerCall3
    00894 {
    00895     typedef typename SelectSpecialization<T>::template
    00896         Type<StoredConstMemberFunctionPointerCall3    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3>,
    00897              VoidStoredConstMemberFunctionPointerCall3<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3> >::type type;
    00898 };
    00899 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00900 struct StoredFunctorCall4: public RunFunctionTask<T>
    00901 {
    00902     inline StoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00903       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
    00904     void runFunctor() { this->result = function(arg1, arg2, arg3, arg4); }
    00905     FunctionPointer function;
    00906     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00907 };
    00908
    00909 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00910 struct VoidStoredFunctorCall4: public RunFunctionTask<T>
    00911 {
    00912     inline VoidStoredFunctorCall4(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00913       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
    00914     void runFunctor() { function(arg1, arg2, arg3, arg4); }
    00915     FunctionPointer function;
    00916     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00917 };
    00918
    00919 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00920 struct SelectStoredFunctorCall4
    00921 {
    00922     typedef typename SelectSpecialization<T>::template
    00923         Type<StoredFunctorCall4    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
    00924              VoidStoredFunctorCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
    00925 };
    00926 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00927 struct StoredFunctorPointerCall4: public RunFunctionTask<T>
    00928 {
    00929     inline StoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00930       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
    00931     void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4); }
    00932     FunctionPointer * function;
    00933     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00934 };
    00935
    00936 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00937 struct VoidStoredFunctorPointerCall4: public RunFunctionTask<T>
    00938 {
    00939     inline VoidStoredFunctorPointerCall4(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00940       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4) {}
    00941     void runFunctor() {(*function)(arg1, arg2, arg3, arg4); }
    00942     FunctionPointer * function;
    00943     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00944 };
    00945
    00946 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
    00947 struct SelectStoredFunctorPointerCall4
    00948 {
    00949     typedef typename SelectSpecialization<T>::template
    00950         Type<StoredFunctorPointerCall4    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4>,
    00951              VoidStoredFunctorPointerCall4<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4> >::type type;
    00952 };
    00953 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    00954 class StoredMemberFunctionCall4 : public RunFunctionTask<T>
    00955 {
    00956 public:
    00957     StoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00958     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    00959
    00960     void runFunctor()
    00961     {
    00962         this->result = (object.*fn)(arg1, arg2, arg3, arg4);
    00963     }
    00964 private:
    00965     T (Class::*fn)(Param1, Param2, Param3, Param4);
    00966     Class object;
    00967     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00968 };
    00969 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    00970 class VoidStoredMemberFunctionCall4 : public RunFunctionTask<T>
    00971 {
    00972 public:
    00973     VoidStoredMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00974     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    00975
    00976     void runFunctor()
    00977     {
    00978         (object.*fn)(arg1, arg2, arg3, arg4);
    00979     }
    00980 private:
    00981     T (Class::*fn)(Param1, Param2, Param3, Param4);
    00982     Class object;
    00983     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    00984 };
    00985 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    00986 struct SelectStoredMemberFunctionCall4
    00987 {
    00988     typedef typename SelectSpecialization<T>::template
    00989         Type<StoredMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
    00990              VoidStoredMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
    00991 };
    00992 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    00993 class StoredConstMemberFunctionCall4 : public RunFunctionTask<T>
    00994 {
    00995 public:
    00996     StoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    00997     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    00998
    00999     void runFunctor()
    01000     {
    01001         this->result = (object.*fn)(arg1, arg2, arg3, arg4);
    01002     }
    01003 private:
    01004     T (Class::*fn)(Param1, Param2, Param3, Param4)const;
    01005     const Class object;
    01006     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01007 };
    01008 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01009 class VoidStoredConstMemberFunctionCall4 : public RunFunctionTask<T>
    01010 {
    01011 public:
    01012     VoidStoredConstMemberFunctionCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    01013     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    01014
    01015     void runFunctor()
    01016     {
    01017         (object.*fn)(arg1, arg2, arg3, arg4);
    01018     }
    01019 private:
    01020     T (Class::*fn)(Param1, Param2, Param3, Param4)const;
    01021     const Class object;
    01022     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01023 };
    01024 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01025 struct SelectStoredConstMemberFunctionCall4
    01026 {
    01027     typedef typename SelectSpecialization<T>::template
    01028         Type<StoredConstMemberFunctionCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
    01029              VoidStoredConstMemberFunctionCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
    01030 };
    01031 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01032 class StoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
    01033 {
    01034 public:
    01035     StoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    01036     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    01037
    01038     void runFunctor()
    01039     {
    01040         this->result = (object->*fn)(arg1, arg2, arg3, arg4);
    01041     }
    01042 private:
    01043     T (Class::*fn)(Param1, Param2, Param3, Param4);
    01044     Class *object;
    01045     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01046 };
    01047 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01048 class VoidStoredMemberFunctionPointerCall4 : public RunFunctionTask<T>
    01049 {
    01050 public:
    01051     VoidStoredMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    01052     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    01053
    01054     void runFunctor()
    01055     {
    01056         (object->*fn)(arg1, arg2, arg3, arg4);
    01057     }
    01058 private:
    01059     T (Class::*fn)(Param1, Param2, Param3, Param4);
    01060     Class *object;
    01061     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01062 };
    01063 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01064 struct SelectStoredMemberFunctionPointerCall4
    01065 {
    01066     typedef typename SelectSpecialization<T>::template
    01067         Type<StoredMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
    01068              VoidStoredMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
    01069 };
    01070 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01071 class StoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
    01072 {
    01073 public:
    01074     StoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    01075     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    01076
    01077     void runFunctor()
    01078     {
    01079         this->result = (object->*fn)(arg1, arg2, arg3, arg4);
    01080     }
    01081 private:
    01082     T (Class::*fn)(Param1, Param2, Param3, Param4)const;
    01083     Class const *object;
    01084     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01085 };
    01086 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01087 class VoidStoredConstMemberFunctionPointerCall4 : public RunFunctionTask<T>
    01088 {
    01089 public:
    01090     VoidStoredConstMemberFunctionPointerCall4(T (Class::*_fn)(Param1, Param2, Param3, Param4) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4)
    01091     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4){ }
    01092
    01093     void runFunctor()
    01094     {
    01095         (object->*fn)(arg1, arg2, arg3, arg4);
    01096     }
    01097 private:
    01098     T (Class::*fn)(Param1, Param2, Param3, Param4)const;
    01099     Class const *object;
    01100     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
    01101 };
    01102 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4>
    01103 struct SelectStoredConstMemberFunctionPointerCall4
    01104 {
    01105     typedef typename SelectSpecialization<T>::template
    01106         Type<StoredConstMemberFunctionPointerCall4    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4>,
    01107              VoidStoredConstMemberFunctionPointerCall4<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4> >::type type;
    01108 };
    01109 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01110 struct StoredFunctorCall5: public RunFunctionTask<T>
    01111 {
    01112     inline StoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01113       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
    01114     void runFunctor() { this->result = function(arg1, arg2, arg3, arg4, arg5); }
    01115     FunctionPointer function;
    01116     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01117 };
    01118
    01119 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01120 struct VoidStoredFunctorCall5: public RunFunctionTask<T>
    01121 {
    01122     inline VoidStoredFunctorCall5(FunctionPointer _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01123       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
    01124     void runFunctor() { function(arg1, arg2, arg3, arg4, arg5); }
    01125     FunctionPointer function;
    01126     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01127 };
    01128
    01129 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01130 struct SelectStoredFunctorCall5
    01131 {
    01132     typedef typename SelectSpecialization<T>::template
    01133         Type<StoredFunctorCall5    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
    01134              VoidStoredFunctorCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
    01135 };
    01136 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01137 struct StoredFunctorPointerCall5: public RunFunctionTask<T>
    01138 {
    01139     inline StoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01140       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
    01141     void runFunctor() { this->result =(*function)(arg1, arg2, arg3, arg4, arg5); }
    01142     FunctionPointer * function;
    01143     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01144 };
    01145
    01146 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01147 struct VoidStoredFunctorPointerCall5: public RunFunctionTask<T>
    01148 {
    01149     inline VoidStoredFunctorPointerCall5(FunctionPointer * _function, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01150       : function(_function), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5) {}
    01151     void runFunctor() {(*function)(arg1, arg2, arg3, arg4, arg5); }
    01152     FunctionPointer * function;
    01153     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01154 };
    01155
    01156 template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
    01157 struct SelectStoredFunctorPointerCall5
    01158 {
    01159     typedef typename SelectSpecialization<T>::template
    01160         Type<StoredFunctorPointerCall5    <T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5>,
    01161              VoidStoredFunctorPointerCall5<T, FunctionPointer, Arg1, Arg2, Arg3, Arg4, Arg5> >::type type;
    01162 };
    01163 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01164 class StoredMemberFunctionCall5 : public RunFunctionTask<T>
    01165 {
    01166 public:
    01167     StoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01168     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01169
    01170     void runFunctor()
    01171     {
    01172         this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    01173     }
    01174 private:
    01175     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
    01176     Class object;
    01177     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01178 };
    01179 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01180 class VoidStoredMemberFunctionCall5 : public RunFunctionTask<T>
    01181 {
    01182 public:
    01183     VoidStoredMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01184     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01185
    01186     void runFunctor()
    01187     {
    01188         (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    01189     }
    01190 private:
    01191     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
    01192     Class object;
    01193     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01194 };
    01195 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01196 struct SelectStoredMemberFunctionCall5
    01197 {
    01198     typedef typename SelectSpecialization<T>::template
    01199         Type<StoredMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
    01200              VoidStoredMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
    01201 };
    01202 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01203 class StoredConstMemberFunctionCall5 : public RunFunctionTask<T>
    01204 {
    01205 public:
    01206     StoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01207     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01208
    01209     void runFunctor()
    01210     {
    01211         this->result = (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    01212     }
    01213 private:
    01214     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
    01215     const Class object;
    01216     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01217 };
    01218 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01219 class VoidStoredConstMemberFunctionCall5 : public RunFunctionTask<T>
    01220 {
    01221 public:
    01222     VoidStoredConstMemberFunctionCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, const Class &_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01223     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01224
    01225     void runFunctor()
    01226     {
    01227         (object.*fn)(arg1, arg2, arg3, arg4, arg5);
    01228     }
    01229 private:
    01230     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
    01231     const Class object;
    01232     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01233 };
    01234 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01235 struct SelectStoredConstMemberFunctionCall5
    01236 {
    01237     typedef typename SelectSpecialization<T>::template
    01238         Type<StoredConstMemberFunctionCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
    01239              VoidStoredConstMemberFunctionCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
    01240 };
    01241 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01242 class StoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
    01243 {
    01244 public:
    01245     StoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01246     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01247
    01248     void runFunctor()
    01249     {
    01250         this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    01251     }
    01252 private:
    01253     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
    01254     Class *object;
    01255     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01256 };
    01257 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01258 class VoidStoredMemberFunctionPointerCall5 : public RunFunctionTask<T>
    01259 {
    01260 public:
    01261     VoidStoredMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) , Class *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01262     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01263
    01264     void runFunctor()
    01265     {
    01266         (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    01267     }
    01268 private:
    01269     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5);
    01270     Class *object;
    01271     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01272 };
    01273 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01274 struct SelectStoredMemberFunctionPointerCall5
    01275 {
    01276     typedef typename SelectSpecialization<T>::template
    01277         Type<StoredMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
    01278              VoidStoredMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
    01279 };
    01280 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01281 class StoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
    01282 {
    01283 public:
    01284     StoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01285     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01286
    01287     void runFunctor()
    01288     {
    01289         this->result = (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    01290     }
    01291 private:
    01292     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
    01293     Class const *object;
    01294     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01295 };
    01296 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01297 class VoidStoredConstMemberFunctionPointerCall5 : public RunFunctionTask<T>
    01298 {
    01299 public:
    01300     VoidStoredConstMemberFunctionPointerCall5(T (Class::*_fn)(Param1, Param2, Param3, Param4, Param5) const, Class const *_object, const Arg1 &_arg1, const Arg2 &_arg2, const Arg3 &_arg3, const Arg4 &_arg4, const Arg5 &_arg5)
    01301     : fn(_fn), object(_object), arg1(_arg1), arg2(_arg2), arg3(_arg3), arg4(_arg4), arg5(_arg5){ }
    01302
    01303     void runFunctor()
    01304     {
    01305         (object->*fn)(arg1, arg2, arg3, arg4, arg5);
    01306     }
    01307 private:
    01308     T (Class::*fn)(Param1, Param2, Param3, Param4, Param5)const;
    01309     Class const *object;
    01310     Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
    01311 };
    01312 template <typename T, typename Class, typename Param1, typename Arg1, typename Param2, typename Arg2, typename Param3, typename Arg3, typename Param4, typename Arg4, typename Param5, typename Arg5>
    01313 struct SelectStoredConstMemberFunctionPointerCall5
    01314 {
    01315     typedef typename SelectSpecialization<T>::template
    01316         Type<StoredConstMemberFunctionPointerCall5    <T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5>,
    01317              VoidStoredConstMemberFunctionPointerCall5<T, Class, Param1, Arg1, Param2, Arg2, Param3, Arg3, Param4, Arg4, Param5, Arg5> >::type type;
    01318 };
    01319 } //namespace QtConcurrent
    01320
    01321 #endif // qdoc
    01322
    01323 QT_END_NAMESPACE
    01324 QT_END_HEADER
    01325
    01326 #endif // QT_NO_CONCURRENT
    01327
    01328 #endif