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 Sun Nov 09 16:55:51 2008.
 */

/** @file
 *  @author Bram de Greve (bramz@users.sourceforge.net)
 *  @author Tom De Muer (tomdemuer@users.sourceforge.net)
 *
 *  *** 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-2007 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 "util_common.h"
#include "pyobject_plus.h"
#include "py_tuple.h"
#include "pyshadow_object.h"
#include "call_traits.h"
#include "../meta/if.h"
#include "../meta/select.h"
#include "../meta/wrap.h"
#include "../meta/type_list.h"

#define LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN_EX(v_errorReturnValue)\
    catch (const ::lass::python::PythonException& error)\
    {\
        handlePythonException(error);\
        return v_errorReturnValue;\
    }\
    catch (const ::lass::util::Exception& error)\
    {\
        handleLassException(error);\
        return v_errorReturnValue;\
    }\
    catch (::std::exception& error)\
    {\
        handleStdException(error);\
        return v_errorReturnValue;\
    }

#define LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN\
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN_EX(0)

#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 -------------------------------------------------------------------------

inline void handlePythonException(const PythonException& error)
{
    PyErr_Restore(
        ::lass::python::fromSharedPtrToNakedCast(error.type()),
        ::lass::python::fromSharedPtrToNakedCast(error.value()),
        ::lass::python::fromSharedPtrToNakedCast(error.traceback()));
}

inline void handleLassException(const util::Exception& error)
{
    ::std::ostringstream buffer;
    buffer << error.message() << "\n\n(" << error.location() << ")";
    PyErr_SetString(PyExc_Exception, buffer.str().c_str());
}

inline void handleStdException(const std::exception& error)
{
    PyErr_SetString(PyExc_Exception, error.what());
}

// --- ArgumentTraits -----------------------------------------------------------------------------

template <typename T>
struct ArgValue
{
    typedef T TStorage;
protected:
    static const T* get(const TStorage& storage) { return &storage; }
};

template <typename T>
struct ArgPyPtr
{
    typedef typename PyObjectPtr<T>::Type TStorage;
protected:
    static T* get(const TStorage& storage) { return storage.get(); }
};


/** determines the right type for temporary storage of function arguments.
 */
template <typename T>
struct ArgumentTraits: public meta::If< IsPyObject<T>, meta::NullType, ArgValue<T> >
{
    template <typename S> static const T& arg(const S& storage) { return *get(storage); }
};

template <typename T>
struct ArgumentTraits<const T>: public meta::If< IsPyObject<T>, meta::NullType, ArgValue<T> >
{
    template <typename S> static const T& arg(const S& storage) { return *get(storage); }
};

template <typename T> 
struct ArgumentTraits<T&>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, meta::NullType >
{
    template <typename S> static T& arg(const S& storage) { return *get(storage); }
};

template <typename T>
struct ArgumentTraits<const T&>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, ArgValue<T> >
{
    template <typename S> static const T& arg(const S& storage) { return *get(storage); }
};

template <typename T> 
struct ArgumentTraits<T*>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, meta::NullType >
{
    template <typename S> static T* arg(const S& storage) { return get(storage); }
};

template <typename T> 
struct ArgumentTraits<const T*>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, meta::NullType >
{
    template <typename S> static const T* arg(const S& storage) { return get(storage); }
};

template <typename T> 
struct ArgumentTraits<T* const>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, meta::NullType >
{
    template <typename S> static T* arg(const S& storage) { return get(storage); }
};

template <typename T> 
struct ArgumentTraits<const T* const>: public meta::If< IsPyObject<T>, ArgPyPtr<T>, meta::NullType >
{
    template <typename S> static const T* arg(const S& storage) { return get(storage); }
};



// --- 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* function( Function iFunction )
    {
        try
        {
            return pyBuildSimpleObject( iFunction() );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    };
    
    template <typename Function, typename P1>
    static PyObject* function( Function iFunction, P1 p1 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2>
    static PyObject* function( Function iFunction, P1 p1, P2 p2 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14, P15 p15 )
    {
        try
        {
            return pyBuildSimpleObject( iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    

    // method

    template <typename CppClassPtr, typename Method>
    static PyObject* method( CppClassPtr iObject, Method iMethod )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)() );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    };
    
    template <typename CppClassPtr, typename Method, typename P1>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14) );
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14, P15 p15 )
    {
        try
        {
            return pyBuildSimpleObject( (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15) );
        }
        LASS_UTIL_PYOBJECT_CALL_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* function( Function iFunction )
    {
        try
        {
            iFunction();
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    };
    
    template <typename Function, typename P1>
    static PyObject* function( Function iFunction, P1 p1 )
    {
        try
        {
            iFunction(p1);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2>
    static PyObject* function( Function iFunction, P1 p1, P2 p2 )
    {
        try
        {
            iFunction(p1, p2);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3 )
    {
        try
        {
            iFunction(p1, p2, p3);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4 )
    {
        try
        {
            iFunction(p1, p2, p3, p4);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename Function, 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* function( Function iFunction, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14, P15 p15 )
    {
        try
        {
            iFunction(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    

    // methods

    template <typename CppClassPtr, typename Method>
    static PyObject* method( CppClassPtr iObject, Method iMethod )
    {
        try
        {
            (iObject->*iMethod)();
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    };
    
    template <typename CppClassPtr, typename Method, typename P1>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1 )
    {
        try
        {
            (iObject->*iMethod)(p1);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
    static PyObject* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
    template <typename CppClassPtr, typename Method, 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* method( CppClassPtr iObject, Method iMethod, P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14, P15 p15 )
    {
        try
        {
            (iObject->*iMethod)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
        Py_INCREF( Py_None );
        return Py_None;
    }
    
};



// --- free functions ------------------------------------------------------------------------------

/** calls C++ function without arguments
 */
template <typename R>
PyObject* callFunction( PyObject* args, R (*iFunction)() )
{
    typedef R(*TFunction)();
    if( decodeTuple(args) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction>( iFunction );
}

/** calls C++ function with 1 arguments, translated from python arguments
 */
template <typename R, typename P1>
PyObject* callFunction( PyObject* args, R (*iFunction)(P1) )
{
    typedef R (*TFunction)(P1);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
    
    if( decodeTuple<S1>( args, p1 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1>( 
        iFunction, 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 (*iFunction)(P1, P2) )
{
    typedef R (*TFunction)(P1, P2);
    typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
    typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
    
    if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2>( 
        iFunction, 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 (*iFunction)(P1, P2, P3) )
{
    typedef R (*TFunction)(P1, P2, P3);
    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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2, P3>( 
        iFunction, 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 (*iFunction)(P1, P2, P3, P4) )
{
    typedef R (*TFunction)(P1, P2, P3, P4);
    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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2, P3, P4>( 
        iFunction, 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 (*iFunction)(P1, P2, P3, P4, P5) )
{
    typedef R (*TFunction)(P1, P2, P3, P4, P5);
    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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2, P3, P4, P5>( 
        iFunction, 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 (*iFunction)(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;
    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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2, P3, P4, P5, P6>( 
        iFunction, 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 (*iFunction)(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;
    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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
    {
        return 0;
    }
    return Caller<R>::template function<TFunction, P1, P2, P3, P4, P5, P6, P7>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>( 
        iFunction, 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 (*iFunction)(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;
    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( 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 function<TFunction, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>( 
        iFunction, 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 <class CppClass>
struct CallMethod
{
    // non const methods

    /** call non const method without arguments
     */
    template <typename C, typename R>
    static PyObject* call( PyObject* args, CppClass* iObject, R (C::*iMethod)() )
    {
        typedef R (C::*TMethod)();
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod>(
            iObject, iMethod );
    }

    /** call non const method with 1 arguments, translated from python arguments
     */
    template <typename C, typename R, typename P1>
    static PyObject* call( PyObject* args, CppClass* iObject, R (C::*iMethod)(P1) )
    {
        typedef R (C::*TMethod)(P1);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1>( 
            iObject, iMethod, TArg1::arg(p1) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2) )
    {
        typedef R (C::*TMethod)(P1, P2);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3) )
    {
        typedef R (C::*TMethod)(P1, P2, P3);
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2, P3>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4);
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2, P3, P4>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5);
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2, P3, P4, P5>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6);
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8>( 
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (C::*TMethod)(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;
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>( 
            iObject, iMethod, 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) );
    }

    /** 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, CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (C::*TMethod)(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;
        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( 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 method<CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>( 
            iObject, iMethod, 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 methods

    /** call const method without arguments
     */
    template <typename C, typename R>
    static PyObject* call( PyObject* args, const CppClass* iObject, R (C::*iMethod)() const )
    {
        typedef R (C::*TMethod)() const;
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod>( 
            iObject, iMethod );
    }

    /** call const method with 1 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1>
    static PyObject* call( PyObject* args, const CppClass* iObject, R (C::*iMethod)(P1) const )
    {
        typedef R (C::*TMethod)(P1) const;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1>(
            iObject, iMethod, TArg1::arg(p1) );
    }

    /** call const method with 2 argument, translated from python arguments
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* call( PyObject* args, const CppClass* iObject, R (C::*iMethod)(P1, P2) const )
    {
        typedef R (C::*TMethod)(P1, P2) const;
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3) const;
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2, P3>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4) const;
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2, P3, P4>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5) const;
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2, P3, P4, P5>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6) const;
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7) const;
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8>(
            iObject, iMethod, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
            iObject, iMethod, 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) );
    }

    /** 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, const CppClass* iObject, R (C::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const )
    {
        typedef R (C::*TMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const;
        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( 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 method<const CppClass*, TMethod, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(
            iObject, iMethod, 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) );
    }

    // "free" non-const methods passing iObject as pointer

    /** call non const "free method" without arguments, passing iObject as pointer
     */
    template <typename C, typename R>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*) )
    {
        typedef R (*TFunction)(C*);
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C* >(
            iFreeMethod, iObject );
    }

    /** call non-const "free method" with 1 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1) )
    {
        typedef R (*TFunction)(C*, P1);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1>(
            iFreeMethod, iObject, TArg1::arg(p1) );
    }

    /** call non-const "free method" with 2 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2) )
    {
        typedef R (*TFunction)(C*, P1, P2);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** call non-const "free method" with 3 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3);
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2, P3>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** call non-const "free method" with 4 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4);
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2, P3, P4>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** call non-const "free method" with 5 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5);
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2, P3, P4, P5>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** call non-const "free method" with 6 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6);
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2, P3, P4, P5, P6>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** call non-const "free method" with 7 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** call non-const "free method" with 8 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** call non-const "free method" with 9 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 10 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 11 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 12 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 13 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (*TFunction)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 14 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (*TFunction)(C*, 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;
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
            iFreeMethod, iObject, 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) );
    }

    /** call non-const "free method" with 15 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (*TFunction)(C*, 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;
        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( 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 function<TFunction, C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(
            iFreeMethod, iObject, 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) );
    }


    // "free" non-const methods passing iObject as reference

    /** call non const "free method" without arguments, passing iObject as reference
     */
    template <typename C, typename R>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&) )
    {
        typedef R (*TFunction)(C&);
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C& >(
            iFreeMethod, *iObject );
    }

    /** call non-const "free method" with 1 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1) )
    {
        typedef R (*TFunction)(C&, P1);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1>(
            iFreeMethod, *iObject, TArg1::arg(p1) );
    }

    /** call non-const "free method" with 2 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2) )
    {
        typedef R (*TFunction)(C&, P1, P2);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** call non-const "free method" with 3 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3);
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** call non-const "free method" with 4 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4);
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** call non-const "free method" with 5 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5);
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** call non-const "free method" with 6 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6);
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** call non-const "free method" with 7 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** call non-const "free method" with 8 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** call non-const "free method" with 9 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 10 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 11 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 12 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 13 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (*TFunction)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 14 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (*TFunction)(C&, 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;
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
            iFreeMethod, *iObject, 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) );
    }

    /** call non-const "free method" with 15 arguments translated from python arguments, 
     *  passing iObject as reference
     */
    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* callFree( PyObject* args, CppClass* iObject, R (*iFreeMethod)(C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (*TFunction)(C&, 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;
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(
            iFreeMethod, *iObject, 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) );
    }


    // "free" const methods passing iObject as pointer

    /** call const "free method" without arguments, passing iObject as pointer
     */
    template <typename C, typename R>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*) )
    {
        typedef R (*TFunction)(const C*);
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C* >(
            iFreeMethod, iObject );
    }

    /** call const "free method" with 1 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1) )
    {
        typedef R (*TFunction)(const C*, P1);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1>(
            iFreeMethod, iObject, TArg1::arg(p1) );
    }

    /** call const "free method" with 2 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2) )
    {
        typedef R (*TFunction)(const C*, P1, P2);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** call const "free method" with 3 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3);
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2, P3>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** call const "free method" with 4 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4);
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2, P3, P4>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** call const "free method" with 5 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5);
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2, P3, P4, P5>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** call const "free method" with 6 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6);
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2, P3, P4, P5, P6>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** call const "free method" with 7 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        return Caller<R>::template function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** call const "free method" with 8 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8>(
            iFreeMethod, iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** call const "free method" with 9 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 10 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 11 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 12 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 13 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (*TFunction)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 14 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (*TFunction)(const C*, 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;
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
            iFreeMethod, iObject, 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) );
    }

    /** call const "free method" with 15 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (*TFunction)(const C*, 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;
        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( 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 function<TFunction, const C*, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(
            iFreeMethod, iObject, 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) );
    }


    // "free" const methods passing iObject as reference

    /** call non const "free method" without arguments, passing iObject as pointer
     */
    template <typename C, typename R>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&) )
    {
        typedef R (*TFunction)(const C&);
        if( decodeTuple(args) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C& >(
            iFreeMethod, *iObject );
    }

    /** call const "free method" with 1 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1) )
    {
        typedef R (*TFunction)(const C&, P1);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        
        if( decodeTuple<S1>( args, p1 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1>(
            iFreeMethod, *iObject, TArg1::arg(p1) );
    }

    /** call const "free method" with 2 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2) )
    {
        typedef R (*TFunction)(const C&, P1, P2);
        typedef ArgumentTraits<P1> TArg1; typedef typename TArg1::TStorage S1; S1 p1;
        typedef ArgumentTraits<P2> TArg2; typedef typename TArg2::TStorage S2; S2 p2;
        
        if( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2) );
    }

    /** call const "free method" with 3 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3);
        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( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) );
    }

    /** call const "free method" with 4 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4);
        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( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) );
    }

    /** call const "free method" with 5 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5);
        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( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) );
    }

    /** call const "free method" with 6 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6);
        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( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) );
    }

    /** call const "free method" with 7 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) );
    }

    /** call const "free method" with 8 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    template <typename C, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
    static PyObject* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8>(
            iFreeMethod, *iObject, TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7), TArg8::arg(p8) );
    }

    /** call const "free method" with 9 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9);
        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( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
        {
            return 0;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 10 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 11 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 12 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 13 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
    {
        typedef R (*TFunction)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13);
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 14 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
    {
        typedef R (*TFunction)(const C&, 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;
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>(
            iFreeMethod, *iObject, 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) );
    }

    /** call const "free method" with 15 arguments translated from python arguments, 
     *  passing iObject as pointer
     */
    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* callFree( PyObject* args, const CppClass* iObject, R (*iFreeMethod)(const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
    {
        typedef R (*TFunction)(const C&, 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;
        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( 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;
        }
        LASS_ASSERT(iObject);
        return Caller<R>::template function<TFunction, const C&, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>(
            iFreeMethod, *iObject, 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) );
    }


    // member getters and setters

    /** call const getter function
     */
    template <typename C, typename R>
    static PyObject* get( const CppClass* iObject, R (C::*iMethod)() const)
    {
        try
        {
            return pyBuildSimpleObject((iObject->*iMethod)());
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }

    /** call getter function, for non-assignable, although not read-only members
     */
    template <typename C, typename R>
    static PyObject* get( CppClass* iObject, R (C::*iMethod)() )
    {
        try
        {
            return pyBuildSimpleObject((iObject->*iMethod)());
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
    }


    /** call explicit setter function like <tt>void Foo::setBar(const Bar& iBar)</tt>
     */
    template <typename P>
    static int set( PyObject* args, CppClass* iObject, void (CppClass::*iMethod)(P) )
    {
        typedef ArgumentTraits<P> TArg;
        typename TArg::TStorage p;

        if( pyGetSimpleObject( args, p ) != 0 )
        {
            return -1;
        }

        try
        {
            (iObject->*iMethod)(TArg::arg(p));
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN_EX(-1)
        return 0;
    }

    /** call implicit setter function like <tt>Bar& Foo::bar()</tt>
     */
    template <typename P>
    static int set( PyObject* args, CppClass* iObject, P& (CppClass::*iMethod)() )
    {
        typedef ArgumentTraits<P> TArg;
        typename TArg::TStorage p;

        if( pyGetSimpleObject( args, p ) != 0 )
        {
            return -1;
        }

        try
        {
            (iObject->*iMethod)() = TArg::arg(p);
        }
        LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN_EX(-1)
        return 0;
    }
};



// --- constructors --------------------------------------------------------------------------------

/** allocate a new object with default constructor.
 */
template <class PyObjectClass>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    
    if( decodeTuple(args) != 0 )
    {
        return 0;
    }
    
    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass );
        // 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
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        // do not track the object using GC
//#pragma LASS_TODO("Check if we have created memory leak... yes we have :-/, read the comments here.")
        /* The reason why we can't use the GC mechanism of Python is that objects needs extra members for this and we don't 
           want to add them to PyObjectPlus.  So we do our own GC... tricky but one needs to live on the edge >:-D 
           In the future this should happen:
           - PyObjectPlus objects should be final... so no derivation and no GC problems.
           - PyObjectPlusSuperDeluxe will support everything.
           The shadowclasses can then be the 'deluxe' version 
        */
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 1 arguments.
 */
template <class PyObjectClass, typename P1>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1;
    

    if ( decodeTuple<S1>( args, p1 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 2 arguments.
 */
template <class PyObjectClass, typename P1, typename P2>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    typedef ArgumentTraits< P1 > TArg1; typedef typename TArg1::TStorage S1; S1 p1;
    typedef ArgumentTraits< P2 > TArg2; typedef typename TArg2::TStorage S2; S2 p2;
    

    if ( decodeTuple<S1, S2>( args, p1, p2 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 3 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3>( args, p1, p2, p3 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 4 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4>( args, p1, p2, p3, p4 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 5 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4, S5>( args, p1, p2, p3, p4, p5 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 6 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4, S5, S6>( args, p1, p2, p3, p4, p5, p6 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 7 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4, S5, S6, S7>( args, p1, p2, p3, p4, p5, p6, p7 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( new TCppClass( TArg1::arg(p1), TArg2::arg(p2), TArg3::arg(p3), TArg4::arg(p4), TArg5::arg(p5), TArg6::arg(p6), TArg7::arg(p7) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 8 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8>( args, p1, p2, p3, p4, p5, p6, p7, p8 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 9 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( decodeTuple<S1, S2, S3, S4, S5, S6, S7, S8, S9>( args, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) != 0 )
    {
        return 0;
    }

    try
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 10 arguments.
 */
template <class PyObjectClass, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
PyObject* construct( PyTypeObject* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 11 arguments.
 */
template <class PyObjectClass, 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* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 12 arguments.
 */
template <class PyObjectClass, 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* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 13 arguments.
 */
template <class PyObjectClass, 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* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 14 arguments.
 */
template <class PyObjectClass, 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* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}

/** allocate a new object with 15 arguments.
 */
template <class PyObjectClass, 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* iSubtype, PyObject* args )
{
    typedef ShadowTraits< PyObjectClass > TPyShadowTraits;
    typedef typename TPyShadowTraits::TCppClass TCppClass;
    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 ( 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
    {
        PyObjectClass* result = TPyShadowTraits::pyObject( 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) ) );
        impl::fixObjectType(result);
        result->ob_type = iSubtype;
        result->ob_type->tp_flags &= (~Py_TPFLAGS_HAVE_GC);
        Py_INCREF(result->ob_type);
        return result;
    }
    LASS_UTIL_PYOBJECT_CALL_CATCH_AND_RETURN
}




// --- explicit resolver ---------------------------------------------------------------------------

// This explicit resolver construct is a wicked meta function that will call the write
// template function based on template parameters in TypeListType.

template <class CppClass, typename R, typename TypeListType> struct ExplicitResolver;
template <class CppClass, typename R, typename P1, typename TypeListType> struct ExplicitResolver1;
template <class CppClass, typename R, typename P1, typename P2, typename TypeListType> struct ExplicitResolver2;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename TypeListType> struct ExplicitResolver3;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename TypeListType> struct ExplicitResolver4;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename TypeListType> struct ExplicitResolver5;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename TypeListType> struct ExplicitResolver6;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename TypeListType> struct ExplicitResolver7;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename TypeListType> struct ExplicitResolver8;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename TypeListType> struct ExplicitResolver9;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename TypeListType> struct ExplicitResolver10;
template <class CppClass, 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 TypeListType> struct ExplicitResolver11;
template <class CppClass, 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 TypeListType> struct ExplicitResolver12;
template <class CppClass, 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 TypeListType> struct ExplicitResolver13;
template <class CppClass, 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 TypeListType> struct ExplicitResolver14;
template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename TypeListType> struct ExplicitResolver15;

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename P16, typename TypeListType> struct ExplicitResolver16;


template <class CppClass, typename R>
struct ExplicitResolver<CppClass, R, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)() )
        {
            return ::lass::python::impl::callFunction<R>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)() )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)() const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass>( iSubtype, args );
        }
        static bool isConstMember( R (CppClass::*)() ) { return false; }
        static bool isConstMember( R (CppClass::*)() const ) { return true; }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1>
struct ExplicitResolver1<CppClass, R, P1, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1) )
        {
            return ::lass::python::impl::callFunction<R, P1>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2>
struct ExplicitResolver2<CppClass, R, P1, P2, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3>
struct ExplicitResolver3<CppClass, R, P1, P2, P3, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4>
struct ExplicitResolver4<CppClass, R, P1, P2, P3, P4, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
struct ExplicitResolver5<CppClass, R, P1, P2, P3, P4, P5, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
struct ExplicitResolver6<CppClass, R, P1, P2, P3, P4, P5, P6, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
struct ExplicitResolver7<CppClass, R, P1, P2, P3, P4, P5, P6, P7, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
struct ExplicitResolver8<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
struct ExplicitResolver9<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
struct ExplicitResolver10<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
struct ExplicitResolver11<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, 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>
struct ExplicitResolver12<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, 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>
struct ExplicitResolver13<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, 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>
struct ExplicitResolver14<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};

template <class CppClass, 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>
struct ExplicitResolver15<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, lass::meta::NullType>
{
    struct Impl
    {
        static PyObject* callFunction( PyObject* args, R (*iFunction)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
        {
            return ::lass::python::impl::callFunction<R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>( args, iFunction );
        }
        static PyObject* callMethod( PyObject* args, CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static PyObject* callMethod( PyObject* args, const CppClass* iObject, R (CppClass::*iMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const )
        {
            return CallMethod<CppClass>::call( args, iObject, iMethod );
        }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) ) { return false; }
        static bool isConstMember( R (CppClass::*)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) const ) { return true; }
        static PyObject* callFreeMethod( PyObject* args, CppClass* iObject, R (*iFreeMethod)(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15) )
        {
            return CallMethod<CppClass>::callFree( args, iObject, iFreeMethod );
        }
        static PyObject* callConstructor( PyTypeObject* iSubtype, PyObject* args )
        {
            return construct<CppClass, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15>( iSubtype, args );
        }
    };
    typedef Impl TImpl;
};


template <class CppClass, typename R, typename Head, typename Tail>
struct ExplicitResolver<CppClass, R, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver1<CppClass, R, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename Head, typename Tail>
struct ExplicitResolver1<CppClass, R, P1, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver2<CppClass, R, P1, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename Head, typename Tail>
struct ExplicitResolver2<CppClass, R, P1, P2, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver3<CppClass, R, P1, P2, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename Head, typename Tail>
struct ExplicitResolver3<CppClass, R, P1, P2, P3, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver4<CppClass, R, P1, P2, P3, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename Head, typename Tail>
struct ExplicitResolver4<CppClass, R, P1, P2, P3, P4, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver5<CppClass, R, P1, P2, P3, P4, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename Head, typename Tail>
struct ExplicitResolver5<CppClass, R, P1, P2, P3, P4, P5, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver6<CppClass, R, P1, P2, P3, P4, P5, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename Head, typename Tail>
struct ExplicitResolver6<CppClass, R, P1, P2, P3, P4, P5, P6, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver7<CppClass, R, P1, P2, P3, P4, P5, P6, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename Head, typename Tail>
struct ExplicitResolver7<CppClass, R, P1, P2, P3, P4, P5, P6, P7, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver8<CppClass, R, P1, P2, P3, P4, P5, P6, P7, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename Head, typename Tail>
struct ExplicitResolver8<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver9<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename Head, typename Tail>
struct ExplicitResolver9<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver10<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename Head, typename Tail>
struct ExplicitResolver10<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver11<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, Head, Tail>::TImpl TImpl;
};

template <class CppClass, 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 Head, typename Tail>
struct ExplicitResolver11<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver12<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, Head, Tail>::TImpl TImpl;
};

template <class CppClass, 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 Head, typename Tail>
struct ExplicitResolver12<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver13<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, Head, Tail>::TImpl TImpl;
};

template <class CppClass, 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 Head, typename Tail>
struct ExplicitResolver13<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver14<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, Head, Tail>::TImpl TImpl;
};

template <class CppClass, 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 Head, typename Tail>
struct ExplicitResolver14<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver15<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, Head, Tail>::TImpl TImpl;
};

template <class CppClass, typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11, typename P12, typename P13, typename P14, typename P15, typename Head, typename Tail>
struct ExplicitResolver15<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, meta::TypeList<Head, Tail> >
{
    typedef typename ExplicitResolver16<CppClass, R, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, Head, Tail>::TImpl TImpl;
};



}

}

}

#if LASS_COMPILER_TYPE == LASS_COMPILER_TYPE_MSVC
#   pragma warning(pop)
#endif

#endif

// EOF