pyobject_call.inl

Go to the documentation of this file.

/*
 * *** ATTENTION!  DO NOT MODIFY THIS FILE DIRECTLY! ***
 * 
 * It has automatically been generated from pyobject_call.tmpl.inl
 * by param_expander.py on Mon Oct  6 22:51:43 2025.
 */
 
/** @file
 *  @author Bram de Greve (bram@cocamware.com)
 *  @author Tom De Muer (tom@cocamware.com)
 *
 *  *** BEGIN LICENSE INFORMATION ***
 *  
 *  The contents of this file are subject to the Common Public Attribution License 
 *  Version 1.0 (the "License"); you may not use this file except in compliance with 
 *  the License. You may obtain a copy of the License at 
 *  http://lass.sourceforge.net/cpal-license. The License is based on the 
 *  Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover 
 *  use of software over a computer network and provide for limited attribution for 
 *  the Original Developer. In addition, Exhibit A has been modified to be consistent 
 *  with Exhibit B.
 *  
 *  Software distributed under the License is distributed on an "AS IS" basis, WITHOUT 
 *  WARRANTY OF ANY KIND, either express or implied. See the License for the specific 
 *  language governing rights and limitations under the License.
 *  
 *  The Original Code is LASS - Library of Assembled Shared Sources.
 *  
 *  The Initial Developer of the Original Code is Bram de Greve and Tom De Muer.
 *  The Original Developer is the Initial Developer.
 *  
 *  All portions of the code written by the Initial Developer are:
 *  Copyright (C) 2004-2025 the Initial Developer.
 *  All Rights Reserved.
 *  
 *  Contributor(s):
 *
 *  Alternatively, the contents of this file may be used under the terms of the 
 *  GNU General Public License Version 2 or later (the GPL), in which case the 
 *  provisions of GPL are applicable instead of those above.  If you wish to allow use
 *  of your version of this file only under the terms of the GPL and not to allow 
 *  others to use your version of this file under the CPAL, indicate your decision by 
 *  deleting the provisions above and replace them with the notice and other 
 *  provisions required by the GPL License. If you do not delete the provisions above,
 *  a recipient may use your version of this file under either the CPAL or the GPL.
 *  
 *  *** END LICENSE INFORMATION ***
 */
 
#ifndef LASS_GUARDIAN_OF_INCLUSION_UTIL_PYOBJECT_CALL_INL
#define LASS_GUARDIAN_OF_INCLUSION_UTIL_PYOBJECT_CALL_INL
 
#include "python_common.h"
#include "pyobject_plus.h"
#include "py_tuple.h"
#include "pyshadow_object.h"
#include "argument_traits.h"
#include "exception.h"
#include "gil.h"
#include "../util/call_traits.h"
#include "../meta/if.h"
#include "../meta/select.h"
#include "../meta/wrap.h"
#include "../meta/type_list.h"
#include "../meta/type_tuple.h"
#include "../meta/is_const.h"
 
 
#if LASS_COMPILER_TYPE == LASS_COMPILER_TYPE_MSVC
#   pragma warning(push)
#   pragma warning(disable: 4267) // conversion from 'size_t' to 'unsigned int', possible loss of data
#endif
 
namespace lass
{
namespace python
{
namespace impl
{
 
// --- exception handlers -------------------------------------------------------------------------
 
 
 
 
 
// --- actual callers ------------------------------------------------------------------------------
 
/** calls the actual function with provided parameters, and returns result as a PyObject pointer.
 */
template <typename R>
struct Caller
{
    // free function
 
    template <typename Function>
    static PyObject* callFunction( Function function )
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            return pyBuildSimpleObject( function() );
        }
        LASS_PYTHON_CATCH_AND_RETURN
    };
 
    template <typename Function, typename... P>
    static PyObject* callFunction(Function function, P&&... p)
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            return pyBuildSimpleObject(function(std::forward<P>(p)...));
        }
        LASS_PYTHON_CATCH_AND_RETURN
    }
 
    // method
 
    template <typename CppClassRef, typename Method>
    static PyObject* callMethod( CppClassRef object, Method method )
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            return pyBuildSimpleObject( (object.*method)() );
        }
        LASS_PYTHON_CATCH_AND_RETURN
    };
 
    template <typename CppClassRef, typename Method, typename... P>
    static PyObject* callMethod(CppClassRef object, Method method, P&&... p)
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            return pyBuildSimpleObject((object.*method)(std::forward<P>(p)...));
        }
        LASS_PYTHON_CATCH_AND_RETURN
    }
};
 
/** specialisation for functions without return value, calls function and returns Py_None.
 */
template <>
struct Caller<void>
{
    // free functions
 
    template <typename Function>
    static PyObject* callFunction( Function function )
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            function();
        }
        LASS_PYTHON_CATCH_AND_RETURN
        Py_RETURN_NONE;
    };
 
    template <typename Function, typename... P>
    static PyObject* callFunction(Function function, P&&... p)
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            function(std::forward<P>(p)...);
        }
        LASS_PYTHON_CATCH_AND_RETURN
            Py_RETURN_NONE;
    }
 
    // methods
 
    template <typename CppClassRef, typename Method>
    static PyObject* callMethod( CppClassRef object, Method method )
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            (object.*method)();
        }
        LASS_PYTHON_CATCH_AND_RETURN
        Py_RETURN_NONE;
    };
 
    template <typename CppClassRef, typename Method, typename... P>
    static PyObject* callMethod( CppClassRef object, Method method, P&&... p)
    {
        try
        {
            UnblockThreads LASS_UNUSED(unlock);
            (object.*method)(std::forward<P>(p)...);
        }
        LASS_PYTHON_CATCH_AND_RETURN
        Py_RETURN_NONE;
    }
};
 
 
 
// --- free functions ------------------------------------------------------------------------------
 
/** calls C++ function without arguments
 */
template <typename R>
PyObject* callFunction( PyObject* args, R (*function)() )
{
    typedef R(*TFunction)();
    if( decodeTuple(args) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>( function );
}
 
/** calls C++ function with 1 arguments, translated from python arguments
 */
template <typename R, typename P1>
PyObject* callFunction( PyObject* args, R (*function)(P1) )
{
    typedef R (*TFunction)(P1);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    
    if( decodeTuple<S1>( args, p1 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1) );
}
 
/** calls C++ function with 2 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2) )
{
    typedef R (*TFunction)(P1, P2);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    
    if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2) );
}
 
/** calls C++ function with 3 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3) )
{
    typedef R (*TFunction)(P1, P2, P3);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    
    if( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
}
 
/** calls C++ function with 4 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4) )
{
    typedef R (*TFunction)(P1, P2, P3, P4);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    
    if( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
}
 
/** calls C++ function with 5 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    
    if( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
}
 
/** calls C++ function with 6 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
}
 
/** calls C++ function with 7 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
}
 
/** calls C++ function with 8 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
}
 
/** calls C++ function with 9 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
}
 
/** calls C++ function with 10 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
}
 
/** calls C++ function with 11 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
}
 
/** calls C++ function with 12 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
}
 
/** calls C++ function with 13 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
}
 
/** calls C++ function with 14 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
}
 
/** calls C++ function with 15 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, R (*function)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
}
 
 
/** calls std::function without arguments
 */
template <typename R>
PyObject* callFunction( PyObject* args, std::function<R()> function )
{
    typedef std::function<R()> TFunction;
    if( decodeTuple(args) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>( function );
}
 
/** calls std::function with 1 arguments, translated from python arguments
 */
template <typename R, typename P1>
PyObject* callFunction( PyObject* args, std::function<R(P1)> function )
{
    typedef std::function<R(P1)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    
    if( decodeTuple<S1>( args, p1 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1) );
}
 
/** calls std::function with 2 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2)> function )
{
    typedef std::function<R(P1, P2)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    
    if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2) );
}
 
/** calls std::function with 3 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3)> function )
{
    typedef std::function<R(P1, P2, P3)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    
    if( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
}
 
/** calls std::function with 4 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4)> function )
{
    typedef std::function<R(P1, P2, P3, P4)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    
    if( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
}
 
/** calls std::function with 5 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    
    if( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
}
 
/** calls std::function with 6 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
}
 
/** calls std::function with 7 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
}
 
/** calls std::function with 8 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
}
 
/** calls std::function with 9 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
}
 
/** calls std::function with 10 arguments, translated from python arguments
 */
template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
}
 
/** calls std::function with 11 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
}
 
/** calls std::function with 12 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
}
 
/** calls std::function with 13 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
}
 
/** calls std::function with 14 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
}
 
/** calls std::function with 15 arguments, translated from python arguments
 */
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>
PyObject* callFunction( PyObject* args, std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)> function )
{
    typedef std::function<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)> TFunction;
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
    
    if( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template callFunction<TFunction>(
        function, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
}
 
 
 
 
// --- methods -------------------------------------------------------------------------------------
 
template <typename ShadowTraits>
struct CallMethod
{
    // non const methods
 
    /** call non const method without arguments
     */
    template <typename C, typename R>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)() )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)();
        TCppClassPtr self;
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple(args) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method);
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 1 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1>(args, p1) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 2 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2>(args, p1, p2) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 3 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 4 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 5 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 6 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 7 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 8 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 9 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 10 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 11 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 12 arguments, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11;
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 13 arguments, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11;
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12;
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 14 arguments, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11;
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12;
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13;
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call non const method with 15 arguments, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);
        TCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3;
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4;
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5;
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6;
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7;
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8;
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9;
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10;
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11;
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12;
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13;
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14;
        typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15;
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
        return establishMagicalBackLinks(result, object);
    }
 
 
    // const methods
 
    /** call const method without arguments
     */
    template <typename C, typename R>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)() const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)() const;
        TConstCppClassPtr self;
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple(args) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>( 
            *self, method);
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 1 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1>(args, p1) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 2 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2>(args, p1, p2) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 3 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 4 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 5 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 6 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 7 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 8 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 9 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 10 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 11 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 12 argument, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 13 argument, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 14 argument, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call const method with 15 argument, translated from python arguments
     */
    template <typename C, 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>
    static PyObject* call( PyObject* args, PyObject* object, R (C::*method)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const )
    {
        typedef typename ShadowTraits::TCppClass TCppClass;
        typedef typename ShadowTraits::TConstCppClassPtr TConstCppClassPtr;
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const;
        TConstCppClassPtr self;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
        
        if ( ShadowTraits::getObject(object, self) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callMethod<const TCppClass&, TMethod>(
            *self, method, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
        return establishMagicalBackLinks(result, object);
    }
 
    // "free" methods passing object as first argument
 
    /** call "free method" without arguments, passing object as first argument
     */
    template <typename R, typename P0>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0) )
    {
        typedef R (*TFunction)(P0);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple(args) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 1 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1) )
    {
        typedef R (*TFunction)(P0, P1);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1>(args, p1) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 2 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2) )
    {
        typedef R (*TFunction)(P0, P1, P2);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2>(args, p1, p2) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 3 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 4 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 5 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 6 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 7 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 8 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 9 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 10 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 11 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 12 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 13 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 14 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 15 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, R (*freeMethod)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (*TFunction)(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15);
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
        return establishMagicalBackLinks(result, object);
    }
 
 
    /** call std::function as "free method" without arguments, passing object as first argument
     */
    template <typename R, typename P0>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0)> freeMethod )
    {
        typedef std::function<R(P0)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple(args) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 1 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1)> freeMethod )
    {
        typedef std::function<R(P0, P1)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1>(args, p1) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 2 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2>(args, p1, p2) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 3 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3>(args, p1, p2, p3) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 4 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4>(args, p1, p2, p3, p4) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 5 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5>(args, p1, p2, p3, p4, p5) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 6 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6>(args, p1, p2, p3, p4, p5, p6) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 7 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7>(args, p1, p2, p3, p4, p5, p6, p7) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 8 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>(args, p1, p2, p3, p4, p5, p6, p7, p8) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 9 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 10 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 11 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 12 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 13 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 14 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) );
        return establishMagicalBackLinks(result, object);
    }
 
    /** call "free method" with 15 arguments translated from python arguments, passing object as first argument
     */
    template <typename R, typename P0, 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>
    static PyObject* callFree( PyObject* args, PyObject* object, std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)> freeMethod )
    {
        typedef std::function<R(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)> TFunction;
        typedef ArgumentTraits<P0> TArg0; typedef typename TArg0::TStorage S0; S0 p0 = S0();
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
        typedef ArgumentTraits<P3> TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
        typedef ArgumentTraits<P4> TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
        typedef ArgumentTraits<P5> TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
        typedef ArgumentTraits<P6> TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
        typedef ArgumentTraits<P7> TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
        typedef ArgumentTraits<P8> TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
        typedef ArgumentTraits<P9> TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
        typedef ArgumentTraits<P10> TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
        typedef ArgumentTraits<P11> TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
        typedef ArgumentTraits<P12> TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
        typedef ArgumentTraits<P13> TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
        typedef ArgumentTraits<P14> TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
        typedef ArgumentTraits<P15> TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
        
        if ( pyGetSimpleObject(object, p0) != 0 || decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>(args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) != 0 )
        {
            return 0;
        }
        PyObject* result = Caller<R>::template callFunction<TFunction>(
            freeMethod, TArg0::arg(p0), TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) );
        return establishMagicalBackLinks(result, object);
    }
 
 
    // member getters and setters
 
    /** call const getter function.
     *
     *  Getters and Setters never release the GIL, as it is assumed they're cheap.
     */
    template <typename C, typename R>
    static PyObject* get(PyObject* object, R (C::*method)() const)
    {
        typename ShadowTraits::TConstCppClassPtr self;
        if (ShadowTraits::getObject(object, self) != 0)
        {
            return 0;
        }
        try
        {
            PyObject* result = pyBuildSimpleObject(((*self).*method)());
            return establishMagicalBackLinks(result, object);
        }
        LASS_PYTHON_CATCH_AND_RETURN
    }
    
    /** call getter function.
     *
     *  Getters and Setters never release the GIL, as it is assumed they're cheap.
     */
    template <typename C, typename R>
    static PyObject* get(PyObject* object, R (C::*method)())
    {
        typename ShadowTraits::TCppClassPtr self;
        if (ShadowTraits::getObject(object, self) != 0)
        {
            return 0;
        }
        try
        {
            PyObject* result = pyBuildSimpleObject(((*self).*method)());
            return establishMagicalBackLinks(result, object);
        }
        LASS_PYTHON_CATCH_AND_RETURN
    }
 
    /** call explicit setter function like <tt>void Foo::setBar(const Bar& iBar)</tt>.
     *
     *  Getters and Setters never release the GIL, as it is assumed they're cheap.
     */
    template <typename C, typename P>
    static int set( PyObject* args, PyObject* object, void (C::*method)(P) )
    {
        typename ShadowTraits::TCppClassPtr self;
        typedef ArgumentTraits<P> TArg; typedef typename TArg::TStorage S; S p = S();
        if (ShadowTraits::getObject(object, self) != 0 || pyGetSimpleObject(args, p) != 0)
        {
            return -1;
        }
        try
        {
            ((*self).*method)(TArg::arg(p));
        }
        LASS_PYTHON_CATCH_AND_RETURN_EX(-1)
        return 0;
    }
 
    /** call implicit setter function like <tt>Bar& Foo::bar()</tt>.
     *
     *  Getters and Setters never release the GIL, as it is assumed they're cheap.
     */
    template <typename C, typename P>
    static int set( PyObject* args, PyObject* object, P& (C::*method)() )
    {
        typename ShadowTraits::TCppClassPtr self;
        typedef ArgumentTraits<P> TArg; typedef typename TArg::TStorage S; S p = S();
        if(ShadowTraits::getObject(object, self) != 0 || pyGetSimpleObject(args, p) != 0)
        {
            return -1;
        }
        try
        {
            ((*self).*method)() = TArg::arg(p);
        }
        LASS_PYTHON_CATCH_AND_RETURN_EX(-1)
        return 0;
    }
 
    template <typename C, typename R>
    static PyObject* freeGet(PyObject* object, R (*function)(C&) )
    {
        typedef typename meta::Select<
            meta::IsConst<C>,
            typename ShadowTraits::TConstCppClassPtr,
            typename ShadowTraits::TCppClassPtr
            >::Type TSelfPtr;
        TSelfPtr self;
        if (ShadowTraits::getObject(object, self) != 0)
        {
            return 0;
        }
        try
        {
            PyObject* result = pyBuildSimpleObject(function(*self));
            return establishMagicalBackLinks(result, object);
        }
        LASS_PYTHON_CATCH_AND_RETURN
    }
 
    template <typename C, typename P>
    static int freeSet( PyObject* args, PyObject* object, void (*function)(C&, P) )
    {
        typename ShadowTraits::TCppClassPtr self;
        typedef ArgumentTraits<P> TArg; typedef typename TArg::TStorage S; S p = S();
        if(ShadowTraits::getObject(object, self) != 0 || pyGetSimpleObject(args, p) != 0)
        {
            return -1;
        }
        try
        {
            function(*self, TArg::arg(p));
        }
        LASS_PYTHON_CATCH_AND_RETURN_EX(-1)
        return 0;
    }
};
 
 
 
// --- constructors --------------------------------------------------------------------------------
 
/** allocate a new object with default constructor.
 */
template <typename ShadowTraits>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    
    if( decodeTuple(args) != 0 )
    {
        return 0;
    }
    
    try
    {
        const TCppClassPtr cppObject(new TCppClass);
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        // actually the iSubType should be used but appearently the tp_dict does not get properly initialized
        // so for now, old-style, consequence: no inheritance from extension classes
        forceObjectType(result, subType);
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 1 arguments.
 */
template <typename ShadowTraits, typename P1>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    
 
    if ( decodeTuple<S1>( args, p1 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 2 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    
 
    if ( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 3 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    
 
    if ( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 4 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    
 
    if ( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 5 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 6 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 7 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 8 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 9 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 10 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 11 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits< P11 > TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 12 arguments.
 */
template <typename ShadowTraits, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits< P11 > TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits< P12 > TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 13 arguments.
 */
template <typename ShadowTraits, 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>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits< P11 > TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits< P12 > TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits< P13 > TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 14 arguments.
 */
template <typename ShadowTraits, 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>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits< P11 > TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits< P12 > TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits< P13 > TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits< P14 > TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
/** allocate a new object with 15 arguments.
 */
template <typename ShadowTraits, 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>
PyObject* construct( PyTypeObject* subType, PyObject* args )
{
    typedef typename ShadowTraits::TCppClass TCppClass;
    typedef typename ShadowTraits::TCppClassPtr TCppClassPtr;
    typedef typename ShadowTraits::TPyClassPtr TPyClassPtr;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1 = S1();
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2 = S2();
    typedef ArgumentTraits< P3 > TArg3; typedef typename TArg3::TStorage S3; S3 p3 = S3();
    typedef ArgumentTraits< P4 > TArg4; typedef typename TArg4::TStorage S4; S4 p4 = S4();
    typedef ArgumentTraits< P5 > TArg5; typedef typename TArg5::TStorage S5; S5 p5 = S5();
    typedef ArgumentTraits< P6 > TArg6; typedef typename TArg6::TStorage S6; S6 p6 = S6();
    typedef ArgumentTraits< P7 > TArg7; typedef typename TArg7::TStorage S7; S7 p7 = S7();
    typedef ArgumentTraits< P8 > TArg8; typedef typename TArg8::TStorage S8; S8 p8 = S8();
    typedef ArgumentTraits< P9 > TArg9; typedef typename TArg9::TStorage S9; S9 p9 = S9();
    typedef ArgumentTraits< P10 > TArg10; typedef typename TArg10::TStorage S10; S10 p10 = S10();
    typedef ArgumentTraits< P11 > TArg11; typedef typename TArg11::TStorage S11; S11 p11 = S11();
    typedef ArgumentTraits< P12 > TArg12; typedef typename TArg12::TStorage S12; S12 p12 = S12();
    typedef ArgumentTraits< P13 > TArg13; typedef typename TArg13::TStorage S13; S13 p13 = S13();
    typedef ArgumentTraits< P14 > TArg14; typedef typename TArg14::TStorage S14; S14 p14 = S14();
    typedef ArgumentTraits< P15 > TArg15; typedef typename TArg15::TStorage S15; S15 p15 = S15();
    
 
    if ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9, S10, S11, S12, S13, S14, S15>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) != 0 )
    {
        return 0;
    }
 
    try
    {
        TCppClassPtr cppObject;
        {
            UnblockThreads LASS_UNUSED(unlock);
            cppObject = TCppClassPtr(new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8), TArg9::arg(p9), TArg10::arg(p10), TArg11::arg(p11), TArg12::arg(p12), TArg13::arg(p13), TArg14::arg(p14), TArg15::arg(p15) ));
        }
        const TPyClassPtr result = ShadowTraits::buildObject(cppObject);
        forceObjectType(result, subType);
        result->ob_type = subType;
        return fromSharedPtrToNakedCast(result);
    }
    LASS_PYTHON_CATCH_AND_RETURN
}
 
 
 
 
// --- explicit resolver ---------------------------------------------------------------------------
 
template <typename ShadowTraits, typename R, typename... P>
struct ExplicitResolver
{
    static PyObject* callFunction(PyObject* args, R(*iFunction)(P...))
    {
        return ::lass::python::impl::callFunction<R, P...>(args, iFunction);
    }
    template <typename C> static PyObject* callMethod(PyObject* args, PyObject* object, R(C::* method)(P...))
    {
        return CallMethod<ShadowTraits>::call(args, object, method);
    }
    template <typename C> static PyObject* callMethod(PyObject* args, PyObject* object, R(C::* method)(P...) const)
    {
        return CallMethod<ShadowTraits>::call(args, object, method);
    }
    static PyObject* callFreeMethod(PyObject* args, PyObject* object, R(*freeMethod)(P...))
    {
        return CallMethod<ShadowTraits>::callFree(args, object, freeMethod);
    }
    static PyObject* callConstructor(PyTypeObject* subType, PyObject* args)
    {
        return construct<ShadowTraits, P...>(subType, args);
    }
};
 
// unwrap TypeTuple
template <typename ShadowTraits, typename R, typename... P>
struct ExplicitResolver<ShadowTraits, R, lass::meta::TypeTuple<P...>>:
    public ExplicitResolver<ShadowTraits, R, P...>
{
};
 
// unwrap TypeList element per element
// current Head always comes behind already unwrapped elements
template <typename ShadowTraits, typename R, typename Head, typename Tail, typename... P>
struct ExplicitResolver<ShadowTraits, R, lass::meta::TypeList<Head, Tail>, P...> :
    public ExplicitResolver<ShadowTraits, R, Tail, P..., Head>
{
};
 
// unwrap NullType as an empty TypeList
template <typename ShadowTraits, typename R, typename... P>
struct ExplicitResolver<ShadowTraits, R, lass::meta::NullType, P...>:
    public ExplicitResolver<ShadowTraits, R, P...>
{
};
 
}
 
}
 
}
 
#if LASS_COMPILER_TYPE == LASS_COMPILER_TYPE_MSVC
#   pragma warning(pop)
#endif
 
#endif
 
// EOF