callback_python.h

Go to the documentation of this file.
00001 /*
00002  * *** ATTENTION!  DO NOT MODIFY THIS FILE DIRECTLY! ***
00003  * 
00004  * It has automatically been generated from callback_python.tmpl.h
00005  * by param_expander.py on Sun Nov 09 16:55:52 2008.
00006  */
00007 
00008 /** @file
00009  *  @author Bram de Greve (bramz@users.sourceforge.net)
00010  *  @author Tom De Muer (tomdemuer@users.sourceforge.net)
00011  *
00012  *  *** BEGIN LICENSE INFORMATION ***
00013  *  
00014  *  The contents of this file are subject to the Common Public Attribution License 
00015  *  Version 1.0 (the "License"); you may not use this file except in compliance with 
00016  *  the License. You may obtain a copy of the License at 
00017  *  http://lass.sourceforge.net/cpal-license. The License is based on the 
00018  *  Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover 
00019  *  use of software over a computer network and provide for limited attribution for 
00020  *  the Original Developer. In addition, Exhibit A has been modified to be consistent 
00021  *  with Exhibit B.
00022  *  
00023  *  Software distributed under the License is distributed on an "AS IS" basis, WITHOUT 
00024  *  WARRANTY OF ANY KIND, either express or implied. See the License for the specific 
00025  *  language governing rights and limitations under the License.
00026  *  
00027  *  The Original Code is LASS - Library of Assembled Shared Sources.
00028  *  
00029  *  The Initial Developer of the Original Code is Bram de Greve and Tom De Muer.
00030  *  The Original Developer is the Initial Developer.
00031  *  
00032  *  All portions of the code written by the Initial Developer are:
00033  *  Copyright (C) 2004-2007 the Initial Developer.
00034  *  All Rights Reserved.
00035  *  
00036  *  Contributor(s):
00037  *
00038  *  Alternatively, the contents of this file may be used under the terms of the 
00039  *  GNU General Public License Version 2 or later (the GPL), in which case the 
00040  *  provisions of GPL are applicable instead of those above.  If you wish to allow use
00041  *  of your version of this file only under the terms of the GPL and not to allow 
00042  *  others to use your version of this file under the CPAL, indicate your decision by 
00043  *  deleting the provisions above and replace them with the notice and other 
00044  *  provisions required by the GPL License. If you do not delete the provisions above,
00045  *  a recipient may use your version of this file under either the CPAL or the GPL.
00046  *  
00047  *  *** END LICENSE INFORMATION ***
00048  */
00049 
00050 
00051 #ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H
00052 #define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H
00053 
00054 #include "util_common.h"
00055 #include "pyobject_plus.h"
00056 #include "py_tuple.h"
00057 #include "pyobject_call.inl"
00058 
00059 namespace lass
00060 {
00061 namespace python
00062 {
00063 namespace impl
00064 {
00065     LASS_DLL void LASS_CALL fetchAndThrowPythonException(const std::string& loc); // see impl/dispatcher_python.cpp
00066 
00067     /** Common implementation of a dispatcher to an python callback with void return type
00068      *  @internal
00069      *  @author Bramz
00070      */
00071     class FunctorPythonBase
00072     {
00073     public:
00074         FunctorPythonBase(const python::TPyObjPtr& callable): callable_(callable) {}
00075         bool operator==(const FunctorPythonBase& other) const
00076         {
00077             return callable_.get() == other.callable_.get();
00078         }
00079     protected:
00080         void call(const python::TPyObjPtr& args) const
00081         {
00082             LASS_ASSERT(callable_);
00083             const python::TPyObjPtr result(PyObject_CallObject(callable_.get(), args.get()));
00084             if (!result)
00085             {
00086                 fetchAndThrowPythonException(LASS_PRETTY_FUNCTION);
00087             }
00088         }
00089     private:
00090         python::TPyObjPtr callable_;
00091     };
00092 
00093     /** Common implementation of a dispatcher to an python callback with non-void return type.
00094      *  @internal
00095      *  @author Bramz
00096      */
00097     template <typename R>
00098     class FunctorPythonRBase
00099     {
00100     public:
00101         FunctorPythonRBase(const python::TPyObjPtr& callable): callable_(callable) {}
00102         bool operator==(const FunctorPythonRBase<R>& other) const
00103         {
00104             return callable_.get() == other.callable_.get();
00105         }
00106     protected:
00107         R call(const python::TPyObjPtr& args) const
00108         {
00109             LASS_ASSERT(callable_);
00110             const python::TPyObjPtr result(PyObject_CallObject(callable_.get(), args.get()));
00111             if (!result)
00112             {
00113                 fetchAndThrowPythonException(LASS_PRETTY_FUNCTION);
00114             }
00115             typedef ArgumentTraits<R> TraitsR;
00116             typename TraitsR::TStorage temp;
00117             if (python::PyExportTraits< typename TraitsR::TStorage >::get(result.get(), temp) != 0)
00118             {
00119                 LASS_THROW("bad result");
00120             }
00121             return TraitsR::arg(temp);
00122         }
00123     private:
00124         python::TPyObjPtr callable_;
00125     };
00126 }
00127 
00128 /** @internal
00129  */
00130 template <typename CallbackType, typename FunctorType, typename ExportTraits>
00131 struct PyExportTraitsCallback
00132 {
00133     static int get(PyObject* value, CallbackType& callback)
00134     {
00135         TPyObjPtr callable;
00136         if (pyGetSimpleObject(value, callable) != 0)
00137         {
00138             impl::addMessageHeader(ExportTraits::className());
00139             return 1;
00140         }
00141         if (!callable) // null pointer
00142         {
00143             callback.reset();
00144             return 0;
00145         }
00146         if (!PyCallable_Check(callable.get()))
00147         {
00148             std::ostringstream buffer;
00149             buffer << ExportTraits::className() << ": not callable";
00150             PyErr_SetString(PyExc_TypeError, buffer.str().c_str());
00151             return 1;
00152         }
00153         callback = FunctorType(callable);
00154         return 0;
00155     }
00156     static PyObject* build(const CallbackType& callback) 
00157     {
00158         if (!callback)
00159         {
00160             Py_RETURN_NONE;
00161         }
00162 #pragma LASS_TODO("Return a real callback object ... [Bramz]")
00163         Py_RETURN_TRUE;
00164     }
00165 };
00166 
00167 }
00168 }
00169 
00170 #endif
00171 
00172 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_0)
00173 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_0
00174 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_0
00175 
00176 namespace lass
00177 {
00178 namespace python
00179 {
00180 namespace impl
00181 {
00182     /** @internal
00183      */
00184     class Functor0Python: public FunctorPythonBase
00185     {
00186     public:
00187         Functor0Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00188         void operator()() const
00189         {
00190             this->call(python::TPyObjPtr());
00191         }
00192     };
00193 }
00194 
00195 /** @internal
00196  */
00197 template <>
00198 struct PyExportTraits< util::Callback0 >:
00199     public PyExportTraitsCallback<
00200         util::Callback0, 
00201         impl::Functor0Python, 
00202         PyExportTraits< util::Callback0 > 
00203     >
00204 {
00205     static const char* className() { return "Callback0"; }
00206 };
00207 
00208 }
00209 }
00210 
00211 #   endif
00212 #endif
00213 
00214 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_1)
00215 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_1
00216 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_1
00217 
00218 namespace lass
00219 {
00220 namespace python
00221 {
00222 namespace impl
00223 {
00224     /** @internal
00225      */
00226     template <typename P1>
00227     class Functor1Python: public FunctorPythonBase
00228     {
00229     public:
00230         Functor1Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00231         void operator()(typename util::CallTraits<P1>::TParam p1) const
00232         {
00233             this->call(python::makeTuple(p1));
00234         }
00235     };
00236 }
00237 
00238 /** @internal
00239  */
00240 template <typename P1>
00241 struct PyExportTraits< util::Callback1<P1> >:
00242     public PyExportTraitsCallback<
00243         util::Callback1<P1>, 
00244         impl::Functor1Python<P1>, 
00245         PyExportTraits< util::Callback1<P1> > 
00246     >
00247 {
00248     static const char* className() { return "Callback1"; }
00249 };
00250 
00251 }
00252 }
00253 
00254 #   endif
00255 #endif
00256 
00257 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_2)
00258 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_2
00259 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_2
00260 
00261 namespace lass
00262 {
00263 namespace python
00264 {
00265 namespace impl
00266 {
00267     /** @internal
00268      */
00269     template <typename P1, typename P2>
00270     class Functor2Python: public FunctorPythonBase
00271     {
00272     public:
00273         Functor2Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00274         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2) const
00275         {
00276             this->call(python::makeTuple(p1, p2));
00277         }
00278     };
00279 }
00280 
00281 /** @internal
00282  */
00283 template <typename P1, typename P2>
00284 struct PyExportTraits< util::Callback2<P1, P2> >:
00285     public PyExportTraitsCallback<
00286         util::Callback2<P1, P2>, 
00287         impl::Functor2Python<P1, P2>, 
00288         PyExportTraits< util::Callback2<P1, P2> > 
00289     >
00290 {
00291     static const char* className() { return "Callback2"; }
00292 };
00293 
00294 }
00295 }
00296 
00297 #   endif
00298 #endif
00299 
00300 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_3)
00301 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_3
00302 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_3
00303 
00304 namespace lass
00305 {
00306 namespace python
00307 {
00308 namespace impl
00309 {
00310     /** @internal
00311      */
00312     template <typename P1, typename P2, typename P3>
00313     class Functor3Python: public FunctorPythonBase
00314     {
00315     public:
00316         Functor3Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00317         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3) const
00318         {
00319             this->call(python::makeTuple(p1, p2, p3));
00320         }
00321     };
00322 }
00323 
00324 /** @internal
00325  */
00326 template <typename P1, typename P2, typename P3>
00327 struct PyExportTraits< util::Callback3<P1, P2, P3> >:
00328     public PyExportTraitsCallback<
00329         util::Callback3<P1, P2, P3>, 
00330         impl::Functor3Python<P1, P2, P3>, 
00331         PyExportTraits< util::Callback3<P1, P2, P3> > 
00332     >
00333 {
00334     static const char* className() { return "Callback3"; }
00335 };
00336 
00337 }
00338 }
00339 
00340 #   endif
00341 #endif
00342 
00343 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_4)
00344 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_4
00345 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_4
00346 
00347 namespace lass
00348 {
00349 namespace python
00350 {
00351 namespace impl
00352 {
00353     /** @internal
00354      */
00355     template <typename P1, typename P2, typename P3, typename P4>
00356     class Functor4Python: public FunctorPythonBase
00357     {
00358     public:
00359         Functor4Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00360         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4) const
00361         {
00362             this->call(python::makeTuple(p1, p2, p3, p4));
00363         }
00364     };
00365 }
00366 
00367 /** @internal
00368  */
00369 template <typename P1, typename P2, typename P3, typename P4>
00370 struct PyExportTraits< util::Callback4<P1, P2, P3, P4> >:
00371     public PyExportTraitsCallback<
00372         util::Callback4<P1, P2, P3, P4>, 
00373         impl::Functor4Python<P1, P2, P3, P4>, 
00374         PyExportTraits< util::Callback4<P1, P2, P3, P4> > 
00375     >
00376 {
00377     static const char* className() { return "Callback4"; }
00378 };
00379 
00380 }
00381 }
00382 
00383 #   endif
00384 #endif
00385 
00386 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_5)
00387 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_5
00388 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_5
00389 
00390 namespace lass
00391 {
00392 namespace python
00393 {
00394 namespace impl
00395 {
00396     /** @internal
00397      */
00398     template <typename P1, typename P2, typename P3, typename P4, typename P5>
00399     class Functor5Python: public FunctorPythonBase
00400     {
00401     public:
00402         Functor5Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00403         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5) const
00404         {
00405             this->call(python::makeTuple(p1, p2, p3, p4, p5));
00406         }
00407     };
00408 }
00409 
00410 /** @internal
00411  */
00412 template <typename P1, typename P2, typename P3, typename P4, typename P5>
00413 struct PyExportTraits< util::Callback5<P1, P2, P3, P4, P5> >:
00414     public PyExportTraitsCallback<
00415         util::Callback5<P1, P2, P3, P4, P5>, 
00416         impl::Functor5Python<P1, P2, P3, P4, P5>, 
00417         PyExportTraits< util::Callback5<P1, P2, P3, P4, P5> > 
00418     >
00419 {
00420     static const char* className() { return "Callback5"; }
00421 };
00422 
00423 }
00424 }
00425 
00426 #   endif
00427 #endif
00428 
00429 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_6)
00430 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_6
00431 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_6
00432 
00433 namespace lass
00434 {
00435 namespace python
00436 {
00437 namespace impl
00438 {
00439     /** @internal
00440      */
00441     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
00442     class Functor6Python: public FunctorPythonBase
00443     {
00444     public:
00445         Functor6Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00446         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6) const
00447         {
00448             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6));
00449         }
00450     };
00451 }
00452 
00453 /** @internal
00454  */
00455 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
00456 struct PyExportTraits< util::Callback6<P1, P2, P3, P4, P5, P6> >:
00457     public PyExportTraitsCallback<
00458         util::Callback6<P1, P2, P3, P4, P5, P6>, 
00459         impl::Functor6Python<P1, P2, P3, P4, P5, P6>, 
00460         PyExportTraits< util::Callback6<P1, P2, P3, P4, P5, P6> > 
00461     >
00462 {
00463     static const char* className() { return "Callback6"; }
00464 };
00465 
00466 }
00467 }
00468 
00469 #   endif
00470 #endif
00471 
00472 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_7)
00473 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_7
00474 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_7
00475 
00476 namespace lass
00477 {
00478 namespace python
00479 {
00480 namespace impl
00481 {
00482     /** @internal
00483      */
00484     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
00485     class Functor7Python: public FunctorPythonBase
00486     {
00487     public:
00488         Functor7Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00489         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7) const
00490         {
00491             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7));
00492         }
00493     };
00494 }
00495 
00496 /** @internal
00497  */
00498 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
00499 struct PyExportTraits< util::Callback7<P1, P2, P3, P4, P5, P6, P7> >:
00500     public PyExportTraitsCallback<
00501         util::Callback7<P1, P2, P3, P4, P5, P6, P7>, 
00502         impl::Functor7Python<P1, P2, P3, P4, P5, P6, P7>, 
00503         PyExportTraits< util::Callback7<P1, P2, P3, P4, P5, P6, P7> > 
00504     >
00505 {
00506     static const char* className() { return "Callback7"; }
00507 };
00508 
00509 }
00510 }
00511 
00512 #   endif
00513 #endif
00514 
00515 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_8)
00516 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_8
00517 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_8
00518 
00519 namespace lass
00520 {
00521 namespace python
00522 {
00523 namespace impl
00524 {
00525     /** @internal
00526      */
00527     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
00528     class Functor8Python: public FunctorPythonBase
00529     {
00530     public:
00531         Functor8Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00532         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8) const
00533         {
00534             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8));
00535         }
00536     };
00537 }
00538 
00539 /** @internal
00540  */
00541 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
00542 struct PyExportTraits< util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8> >:
00543     public PyExportTraitsCallback<
00544         util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8>, 
00545         impl::Functor8Python<P1, P2, P3, P4, P5, P6, P7, P8>, 
00546         PyExportTraits< util::Callback8<P1, P2, P3, P4, P5, P6, P7, P8> > 
00547     >
00548 {
00549     static const char* className() { return "Callback8"; }
00550 };
00551 
00552 }
00553 }
00554 
00555 #   endif
00556 #endif
00557 
00558 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_9)
00559 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_9
00560 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_9
00561 
00562 namespace lass
00563 {
00564 namespace python
00565 {
00566 namespace impl
00567 {
00568     /** @internal
00569      */
00570     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
00571     class Functor9Python: public FunctorPythonBase
00572     {
00573     public:
00574         Functor9Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00575         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9) const
00576         {
00577             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9));
00578         }
00579     };
00580 }
00581 
00582 /** @internal
00583  */
00584 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
00585 struct PyExportTraits< util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9> >:
00586     public PyExportTraitsCallback<
00587         util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9>, 
00588         impl::Functor9Python<P1, P2, P3, P4, P5, P6, P7, P8, P9>, 
00589         PyExportTraits< util::Callback9<P1, P2, P3, P4, P5, P6, P7, P8, P9> > 
00590     >
00591 {
00592     static const char* className() { return "Callback9"; }
00593 };
00594 
00595 }
00596 }
00597 
00598 #   endif
00599 #endif
00600 
00601 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_10)
00602 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_10
00603 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_10
00604 
00605 namespace lass
00606 {
00607 namespace python
00608 {
00609 namespace impl
00610 {
00611     /** @internal
00612      */
00613     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
00614     class Functor10Python: public FunctorPythonBase
00615     {
00616     public:
00617         Functor10Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00618         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10) const
00619         {
00620             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10));
00621         }
00622     };
00623 }
00624 
00625 /** @internal
00626  */
00627 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
00628 struct PyExportTraits< util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >:
00629     public PyExportTraitsCallback<
00630         util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, 
00631         impl::Functor10Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, 
00632         PyExportTraits< util::Callback10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> > 
00633     >
00634 {
00635     static const char* className() { return "Callback10"; }
00636 };
00637 
00638 }
00639 }
00640 
00641 #   endif
00642 #endif
00643 
00644 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_11)
00645 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_11
00646 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_11
00647 
00648 namespace lass
00649 {
00650 namespace python
00651 {
00652 namespace impl
00653 {
00654     /** @internal
00655      */
00656     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
00657     class Functor11Python: public FunctorPythonBase
00658     {
00659     public:
00660         Functor11Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00661         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11) const
00662         {
00663             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11));
00664         }
00665     };
00666 }
00667 
00668 /** @internal
00669  */
00670 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
00671 struct PyExportTraits< util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >:
00672     public PyExportTraitsCallback<
00673         util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, 
00674         impl::Functor11Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, 
00675         PyExportTraits< util::Callback11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> > 
00676     >
00677 {
00678     static const char* className() { return "Callback11"; }
00679 };
00680 
00681 }
00682 }
00683 
00684 #   endif
00685 #endif
00686 
00687 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_12)
00688 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_12
00689 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_12
00690 
00691 namespace lass
00692 {
00693 namespace python
00694 {
00695 namespace impl
00696 {
00697     /** @internal
00698      */
00699     template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
00700     class Functor12Python: public FunctorPythonBase
00701     {
00702     public:
00703         Functor12Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00704         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12) const
00705         {
00706             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12));
00707         }
00708     };
00709 }
00710 
00711 /** @internal
00712  */
00713 template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
00714 struct PyExportTraits< util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >:
00715     public PyExportTraitsCallback<
00716         util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, 
00717         impl::Functor12Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, 
00718         PyExportTraits< util::Callback12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> > 
00719     >
00720 {
00721     static const char* className() { return "Callback12"; }
00722 };
00723 
00724 }
00725 }
00726 
00727 #   endif
00728 #endif
00729 
00730 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_13)
00731 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_13
00732 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_13
00733 
00734 namespace lass
00735 {
00736 namespace python
00737 {
00738 namespace impl
00739 {
00740     /** @internal
00741      */
00742     template <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>
00743     class Functor13Python: public FunctorPythonBase
00744     {
00745     public:
00746         Functor13Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00747         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13) const
00748         {
00749             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13));
00750         }
00751     };
00752 }
00753 
00754 /** @internal
00755  */
00756 template <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>
00757 struct PyExportTraits< util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >:
00758     public PyExportTraitsCallback<
00759         util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>, 
00760         impl::Functor13Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>, 
00761         PyExportTraits< util::Callback13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> > 
00762     >
00763 {
00764     static const char* className() { return "Callback13"; }
00765 };
00766 
00767 }
00768 }
00769 
00770 #   endif
00771 #endif
00772 
00773 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_14)
00774 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_14
00775 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_14
00776 
00777 namespace lass
00778 {
00779 namespace python
00780 {
00781 namespace impl
00782 {
00783     /** @internal
00784      */
00785     template <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>
00786     class Functor14Python: public FunctorPythonBase
00787     {
00788     public:
00789         Functor14Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00790         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14) const
00791         {
00792             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14));
00793         }
00794     };
00795 }
00796 
00797 /** @internal
00798  */
00799 template <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>
00800 struct PyExportTraits< util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >:
00801     public PyExportTraitsCallback<
00802         util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>, 
00803         impl::Functor14Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>, 
00804         PyExportTraits< util::Callback14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> > 
00805     >
00806 {
00807     static const char* className() { return "Callback14"; }
00808 };
00809 
00810 }
00811 }
00812 
00813 #   endif
00814 #endif
00815 
00816 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_15)
00817 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_15
00818 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_15
00819 
00820 namespace lass
00821 {
00822 namespace python
00823 {
00824 namespace impl
00825 {
00826     /** @internal
00827      */
00828     template <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>
00829     class Functor15Python: public FunctorPythonBase
00830     {
00831     public:
00832         Functor15Python(const python::TPyObjPtr& callable): FunctorPythonBase(callable) {}
00833         void operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14, typename util::CallTraits<P15>::TParam p15) const
00834         {
00835             this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15));
00836         }
00837     };
00838 }
00839 
00840 /** @internal
00841  */
00842 template <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>
00843 struct PyExportTraits< util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >:
00844     public PyExportTraitsCallback<
00845         util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>, 
00846         impl::Functor15Python<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>, 
00847         PyExportTraits< util::Callback15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> > 
00848     >
00849 {
00850     static const char* className() { return "Callback15"; }
00851 };
00852 
00853 }
00854 }
00855 
00856 #   endif
00857 #endif
00858 
00859 
00860 
00861 
00862 
00863 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R0)
00864 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R0
00865 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R0
00866 
00867 namespace lass
00868 {
00869 namespace python
00870 {
00871 namespace impl
00872 {
00873     /** @internal
00874      */
00875     template <typename R>
00876     class FunctorPythonR0: public FunctorPythonRBase<R>
00877     {
00878     public:
00879         FunctorPythonR0(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
00880         R operator()() const
00881         {
00882             return this->call(python::TPyObjPtr());
00883         }
00884     };
00885 }
00886 
00887 /** @internal
00888  */
00889 template <typename R>
00890 struct PyExportTraits< util::CallbackR0<R> >:
00891     public PyExportTraitsCallback<
00892         util::CallbackR0<R>, 
00893         impl::FunctorPythonR0<R>, 
00894         PyExportTraits< util::CallbackR0<R> > 
00895     >
00896 {
00897     static const char* className() { return "CallbackR0"; }
00898 };
00899 
00900 }
00901 }
00902 
00903 #   endif
00904 #endif
00905 
00906 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R1)
00907 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R1
00908 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R1
00909 
00910 namespace lass
00911 {
00912 namespace python
00913 {
00914 namespace impl
00915 {
00916     /** @internal
00917      */
00918     template <typename R, typename P1>
00919     class FunctorPythonR1: public FunctorPythonRBase<R>
00920     {
00921     public:
00922         FunctorPythonR1(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
00923         R operator()(typename util::CallTraits<P1>::TParam p1) const
00924         {
00925             return this->call(python::makeTuple(p1));
00926         }
00927     };
00928 }
00929 
00930 /** @internal
00931  */
00932 template <typename R, typename P1>
00933 struct PyExportTraits< util::CallbackR1<R, P1> >:
00934     public PyExportTraitsCallback<
00935         util::CallbackR1<R, P1>, 
00936         impl::FunctorPythonR1<R, P1>, 
00937         PyExportTraits< util::CallbackR1<R, P1> > 
00938     >
00939 {
00940     static const char* className() { return "CallbackR1"; }
00941 };
00942 
00943 }
00944 }
00945 
00946 #   endif
00947 #endif
00948 
00949 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R2)
00950 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R2
00951 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R2
00952 
00953 namespace lass
00954 {
00955 namespace python
00956 {
00957 namespace impl
00958 {
00959     /** @internal
00960      */
00961     template <typename R, typename P1, typename P2>
00962     class FunctorPythonR2: public FunctorPythonRBase<R>
00963     {
00964     public:
00965         FunctorPythonR2(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
00966         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2) const
00967         {
00968             return this->call(python::makeTuple(p1, p2));
00969         }
00970     };
00971 }
00972 
00973 /** @internal
00974  */
00975 template <typename R, typename P1, typename P2>
00976 struct PyExportTraits< util::CallbackR2<R, P1, P2> >:
00977     public PyExportTraitsCallback<
00978         util::CallbackR2<R, P1, P2>, 
00979         impl::FunctorPythonR2<R, P1, P2>, 
00980         PyExportTraits< util::CallbackR2<R, P1, P2> > 
00981     >
00982 {
00983     static const char* className() { return "CallbackR2"; }
00984 };
00985 
00986 }
00987 }
00988 
00989 #   endif
00990 #endif
00991 
00992 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R3)
00993 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R3
00994 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R3
00995 
00996 namespace lass
00997 {
00998 namespace python
00999 {
01000 namespace impl
01001 {
01002     /** @internal
01003      */
01004     template <typename R, typename P1, typename P2, typename P3>
01005     class FunctorPythonR3: public FunctorPythonRBase<R>
01006     {
01007     public:
01008         FunctorPythonR3(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01009         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3) const
01010         {
01011             return this->call(python::makeTuple(p1, p2, p3));
01012         }
01013     };
01014 }
01015 
01016 /** @internal
01017  */
01018 template <typename R, typename P1, typename P2, typename P3>
01019 struct PyExportTraits< util::CallbackR3<R, P1, P2, P3> >:
01020     public PyExportTraitsCallback<
01021         util::CallbackR3<R, P1, P2, P3>, 
01022         impl::FunctorPythonR3<R, P1, P2, P3>, 
01023         PyExportTraits< util::CallbackR3<R, P1, P2, P3> > 
01024     >
01025 {
01026     static const char* className() { return "CallbackR3"; }
01027 };
01028 
01029 }
01030 }
01031 
01032 #   endif
01033 #endif
01034 
01035 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R4)
01036 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R4
01037 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R4
01038 
01039 namespace lass
01040 {
01041 namespace python
01042 {
01043 namespace impl
01044 {
01045     /** @internal
01046      */
01047     template <typename R, typename P1, typename P2, typename P3, typename P4>
01048     class FunctorPythonR4: public FunctorPythonRBase<R>
01049     {
01050     public:
01051         FunctorPythonR4(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01052         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4) const
01053         {
01054             return this->call(python::makeTuple(p1, p2, p3, p4));
01055         }
01056     };
01057 }
01058 
01059 /** @internal
01060  */
01061 template <typename R, typename P1, typename P2, typename P3, typename P4>
01062 struct PyExportTraits< util::CallbackR4<R, P1, P2, P3, P4> >:
01063     public PyExportTraitsCallback<
01064         util::CallbackR4<R, P1, P2, P3, P4>, 
01065         impl::FunctorPythonR4<R, P1, P2, P3, P4>, 
01066         PyExportTraits< util::CallbackR4<R, P1, P2, P3, P4> > 
01067     >
01068 {
01069     static const char* className() { return "CallbackR4"; }
01070 };
01071 
01072 }
01073 }
01074 
01075 #   endif
01076 #endif
01077 
01078 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R5)
01079 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R5
01080 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R5
01081 
01082 namespace lass
01083 {
01084 namespace python
01085 {
01086 namespace impl
01087 {
01088     /** @internal
01089      */
01090     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
01091     class FunctorPythonR5: public FunctorPythonRBase<R>
01092     {
01093     public:
01094         FunctorPythonR5(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01095         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5) const
01096         {
01097             return this->call(python::makeTuple(p1, p2, p3, p4, p5));
01098         }
01099     };
01100 }
01101 
01102 /** @internal
01103  */
01104 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
01105 struct PyExportTraits< util::CallbackR5<R, P1, P2, P3, P4, P5> >:
01106     public PyExportTraitsCallback<
01107         util::CallbackR5<R, P1, P2, P3, P4, P5>, 
01108         impl::FunctorPythonR5<R, P1, P2, P3, P4, P5>, 
01109         PyExportTraits< util::CallbackR5<R, P1, P2, P3, P4, P5> > 
01110     >
01111 {
01112     static const char* className() { return "CallbackR5"; }
01113 };
01114 
01115 }
01116 }
01117 
01118 #   endif
01119 #endif
01120 
01121 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R6)
01122 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R6
01123 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R6
01124 
01125 namespace lass
01126 {
01127 namespace python
01128 {
01129 namespace impl
01130 {
01131     /** @internal
01132      */
01133     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
01134     class FunctorPythonR6: public FunctorPythonRBase<R>
01135     {
01136     public:
01137         FunctorPythonR6(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01138         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6) const
01139         {
01140             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6));
01141         }
01142     };
01143 }
01144 
01145 /** @internal
01146  */
01147 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
01148 struct PyExportTraits< util::CallbackR6<R, P1, P2, P3, P4, P5, P6> >:
01149     public PyExportTraitsCallback<
01150         util::CallbackR6<R, P1, P2, P3, P4, P5, P6>, 
01151         impl::FunctorPythonR6<R, P1, P2, P3, P4, P5, P6>, 
01152         PyExportTraits< util::CallbackR6<R, P1, P2, P3, P4, P5, P6> > 
01153     >
01154 {
01155     static const char* className() { return "CallbackR6"; }
01156 };
01157 
01158 }
01159 }
01160 
01161 #   endif
01162 #endif
01163 
01164 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R7)
01165 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R7
01166 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R7
01167 
01168 namespace lass
01169 {
01170 namespace python
01171 {
01172 namespace impl
01173 {
01174     /** @internal
01175      */
01176     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
01177     class FunctorPythonR7: public FunctorPythonRBase<R>
01178     {
01179     public:
01180         FunctorPythonR7(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01181         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7) const
01182         {
01183             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7));
01184         }
01185     };
01186 }
01187 
01188 /** @internal
01189  */
01190 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
01191 struct PyExportTraits< util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7> >:
01192     public PyExportTraitsCallback<
01193         util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7>, 
01194         impl::FunctorPythonR7<R, P1, P2, P3, P4, P5, P6, P7>, 
01195         PyExportTraits< util::CallbackR7<R, P1, P2, P3, P4, P5, P6, P7> > 
01196     >
01197 {
01198     static const char* className() { return "CallbackR7"; }
01199 };
01200 
01201 }
01202 }
01203 
01204 #   endif
01205 #endif
01206 
01207 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R8)
01208 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R8
01209 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R8
01210 
01211 namespace lass
01212 {
01213 namespace python
01214 {
01215 namespace impl
01216 {
01217     /** @internal
01218      */
01219     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
01220     class FunctorPythonR8: public FunctorPythonRBase<R>
01221     {
01222     public:
01223         FunctorPythonR8(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01224         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8) const
01225         {
01226             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8));
01227         }
01228     };
01229 }
01230 
01231 /** @internal
01232  */
01233 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
01234 struct PyExportTraits< util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8> >:
01235     public PyExportTraitsCallback<
01236         util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8>, 
01237         impl::FunctorPythonR8<R, P1, P2, P3, P4, P5, P6, P7, P8>, 
01238         PyExportTraits< util::CallbackR8<R, P1, P2, P3, P4, P5, P6, P7, P8> > 
01239     >
01240 {
01241     static const char* className() { return "CallbackR8"; }
01242 };
01243 
01244 }
01245 }
01246 
01247 #   endif
01248 #endif
01249 
01250 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R9)
01251 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R9
01252 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R9
01253 
01254 namespace lass
01255 {
01256 namespace python
01257 {
01258 namespace impl
01259 {
01260     /** @internal
01261      */
01262     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
01263     class FunctorPythonR9: public FunctorPythonRBase<R>
01264     {
01265     public:
01266         FunctorPythonR9(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01267         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9) const
01268         {
01269             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9));
01270         }
01271     };
01272 }
01273 
01274 /** @internal
01275  */
01276 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
01277 struct PyExportTraits< util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> >:
01278     public PyExportTraitsCallback<
01279         util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>, 
01280         impl::FunctorPythonR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>, 
01281         PyExportTraits< util::CallbackR9<R, P1, P2, P3, P4, P5, P6, P7, P8, P9> > 
01282     >
01283 {
01284     static const char* className() { return "CallbackR9"; }
01285 };
01286 
01287 }
01288 }
01289 
01290 #   endif
01291 #endif
01292 
01293 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R10)
01294 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R10
01295 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R10
01296 
01297 namespace lass
01298 {
01299 namespace python
01300 {
01301 namespace impl
01302 {
01303     /** @internal
01304      */
01305     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
01306     class FunctorPythonR10: public FunctorPythonRBase<R>
01307     {
01308     public:
01309         FunctorPythonR10(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01310         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10) const
01311         {
01312             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10));
01313         }
01314     };
01315 }
01316 
01317 /** @internal
01318  */
01319 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
01320 struct PyExportTraits< util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> >:
01321     public PyExportTraitsCallback<
01322         util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, 
01323         impl::FunctorPythonR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>, 
01324         PyExportTraits< util::CallbackR10<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> > 
01325     >
01326 {
01327     static const char* className() { return "CallbackR10"; }
01328 };
01329 
01330 }
01331 }
01332 
01333 #   endif
01334 #endif
01335 
01336 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R11)
01337 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R11
01338 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R11
01339 
01340 namespace lass
01341 {
01342 namespace python
01343 {
01344 namespace impl
01345 {
01346     /** @internal
01347      */
01348     template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
01349     class FunctorPythonR11: public FunctorPythonRBase<R>
01350     {
01351     public:
01352         FunctorPythonR11(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01353         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11) const
01354         {
01355             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11));
01356         }
01357     };
01358 }
01359 
01360 /** @internal
01361  */
01362 template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
01363 struct PyExportTraits< util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> >:
01364     public PyExportTraitsCallback<
01365         util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, 
01366         impl::FunctorPythonR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>, 
01367         PyExportTraits< util::CallbackR11<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> > 
01368     >
01369 {
01370     static const char* className() { return "CallbackR11"; }
01371 };
01372 
01373 }
01374 }
01375 
01376 #   endif
01377 #endif
01378 
01379 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R12)
01380 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R12
01381 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R12
01382 
01383 namespace lass
01384 {
01385 namespace python
01386 {
01387 namespace impl
01388 {
01389     /** @internal
01390      */
01391     template <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>
01392     class FunctorPythonR12: public FunctorPythonRBase<R>
01393     {
01394     public:
01395         FunctorPythonR12(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01396         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12) const
01397         {
01398             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12));
01399         }
01400     };
01401 }
01402 
01403 /** @internal
01404  */
01405 template <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>
01406 struct PyExportTraits< util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> >:
01407     public PyExportTraitsCallback<
01408         util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, 
01409         impl::FunctorPythonR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>, 
01410         PyExportTraits< util::CallbackR12<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> > 
01411     >
01412 {
01413     static const char* className() { return "CallbackR12"; }
01414 };
01415 
01416 }
01417 }
01418 
01419 #   endif
01420 #endif
01421 
01422 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R13)
01423 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R13
01424 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R13
01425 
01426 namespace lass
01427 {
01428 namespace python
01429 {
01430 namespace impl
01431 {
01432     /** @internal
01433      */
01434     template <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>
01435     class FunctorPythonR13: public FunctorPythonRBase<R>
01436     {
01437     public:
01438         FunctorPythonR13(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01439         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13) const
01440         {
01441             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13));
01442         }
01443     };
01444 }
01445 
01446 /** @internal
01447  */
01448 template <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>
01449 struct PyExportTraits< util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> >:
01450     public PyExportTraitsCallback<
01451         util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>, 
01452         impl::FunctorPythonR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>, 
01453         PyExportTraits< util::CallbackR13<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> > 
01454     >
01455 {
01456     static const char* className() { return "CallbackR13"; }
01457 };
01458 
01459 }
01460 }
01461 
01462 #   endif
01463 #endif
01464 
01465 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R14)
01466 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R14
01467 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R14
01468 
01469 namespace lass
01470 {
01471 namespace python
01472 {
01473 namespace impl
01474 {
01475     /** @internal
01476      */
01477     template <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>
01478     class FunctorPythonR14: public FunctorPythonRBase<R>
01479     {
01480     public:
01481         FunctorPythonR14(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01482         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14) const
01483         {
01484             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14));
01485         }
01486     };
01487 }
01488 
01489 /** @internal
01490  */
01491 template <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>
01492 struct PyExportTraits< util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> >:
01493     public PyExportTraitsCallback<
01494         util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>, 
01495         impl::FunctorPythonR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>, 
01496         PyExportTraits< util::CallbackR14<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> > 
01497     >
01498 {
01499     static const char* className() { return "CallbackR14"; }
01500 };
01501 
01502 }
01503 }
01504 
01505 #   endif
01506 #endif
01507 
01508 #if defined(LASS_PRIM_HAVE_PY_EXPORT_TRAITS_CALLBACK_R15)
01509 #   ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R15
01510 #   define LASS_GUARDIAN_OF_INCLUSION_UTIL_CALLBACK_PYTHON_H_CALLBACK_R15
01511 
01512 namespace lass
01513 {
01514 namespace python
01515 {
01516 namespace impl
01517 {
01518     /** @internal
01519      */
01520     template <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>
01521     class FunctorPythonR15: public FunctorPythonRBase<R>
01522     {
01523     public:
01524         FunctorPythonR15(const python::TPyObjPtr& callable): FunctorPythonRBase<R>(callable) {}
01525         R operator()(typename util::CallTraits<P1>::TParam p1, typename util::CallTraits<P2>::TParam p2, typename util::CallTraits<P3>::TParam p3, typename util::CallTraits<P4>::TParam p4, typename util::CallTraits<P5>::TParam p5, typename util::CallTraits<P6>::TParam p6, typename util::CallTraits<P7>::TParam p7, typename util::CallTraits<P8>::TParam p8, typename util::CallTraits<P9>::TParam p9, typename util::CallTraits<P10>::TParam p10, typename util::CallTraits<P11>::TParam p11, typename util::CallTraits<P12>::TParam p12, typename util::CallTraits<P13>::TParam p13, typename util::CallTraits<P14>::TParam p14, typename util::CallTraits<P15>::TParam p15) const
01526         {
01527             return this->call(python::makeTuple(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15));
01528         }
01529     };
01530 }
01531 
01532 /** @internal
01533  */
01534 template <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>
01535 struct PyExportTraits< util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> >:
01536     public PyExportTraitsCallback<
01537         util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>, 
01538         impl::FunctorPythonR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>, 
01539         PyExportTraits< util::CallbackR15<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> > 
01540     >
01541 {
01542     static const char* className() { return "CallbackR15"; }
01543 };
01544 
01545 }
01546 }
01547 
01548 #   endif
01549 #endif
01550 
01551 
01552 // EOF
library of assembled shared sources

callback_python.h
