boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-20 16:52:15 +00:00
Code Issues Projects Releases Wiki Activity

detail-ified the gen_*.py scripts

Browse Source 
changed defaults to handle up to 10 arguments


[SVN r8274]
This commit is contained in:
Dave Abrahams
2000-11-21 15:00:54 +00:00
parent b7805af02c
commit caae49861f
12 changed files with 1753 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

473
callback.h
View File

@@ -6,7 +6,7 @@
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file was generated for 5-argument python callbacks by gen_callback.py
// This file was generated for 10-argument python callbacks by gen_callback.py
#ifndef CALLBACK_DWA_052100_H_
# define CALLBACK_DWA_052100_H_
@@ -187,6 +187,251 @@ struct Callback
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr p10(to_python(a10));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get(),
p10.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr p10(to_python(a10));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get(),
p10.get()));
detail::callback_adjust_refcount(result.get(), Type<R>());
return from_python(result.get(), Type<R>());
}
};
// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
@@ -331,6 +576,231 @@ struct Callback<void>
p4.get(),
p5.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr p10(to_python(a10));
Ptr result(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(OOOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get(),
p10.get()));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
{
Ptr p1(to_python(a1));
Ptr p2(to_python(a2));
Ptr p3(to_python(a3));
Ptr p4(to_python(a4));
Ptr p5(to_python(a5));
Ptr p6(to_python(a6));
Ptr p7(to_python(a7));
Ptr p8(to_python(a8));
Ptr p9(to_python(a9));
Ptr p10(to_python(a10));
Ptr result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
p1.get(),
p2.get(),
p3.get(),
p4.get(),
p5.get(),
p6.get(),
p7.get(),
p8.get(),
p9.get(),
p10.get()));
}
};
// Make it a compile-time error to try to return a const char* from a virtual
@@ -357,4 +827,3 @@ struct Callback<const char*>
} // namespace py
#endif // CALLBACK_DWA_052100_H_

774
caller.h
View File

@@ -6,7 +6,7 @@
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file generated for 5-argument member functions and 5-argument free
// This file generated for 10-argument member functions and 11-argument free
// functions by gen_caller.py
#ifndef CALLER_DWA05090_H_
@@ -103,6 +103,126 @@ struct Caller
from_python(a5, Type<A5>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>())));
}
template <class T>
static PyObject* call(R (T::*pmf)() const, PyObject* args, PyObject* /* keywords */ ) {
@@ -183,6 +303,126 @@ struct Caller
from_python(a5, Type<A5>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>())));
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(R (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
T& target = from_python(self, Type<T&>());
return to_python((target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>())));
}
// Free functions
static PyObject* call(R (*f)(), PyObject* args, PyObject* /* keywords */ ) {
if (!PyArg_ParseTuple(args, const_cast<char*>("")))
@@ -250,6 +490,144 @@ struct Caller
from_python(a5, Type<A5>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>())));
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
static PyObject* call(R (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
PyObject* a11;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
return 0;
return to_python(f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>()),
from_python(a11, Type<A11>())));
}
};
template <>
@@ -340,6 +718,131 @@ struct Caller<void>
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>()));
return detail::none();
}
template <class T>
static PyObject* call(void (T::*pmf)() const, PyObject* args, PyObject* /* keywords */ ) {
@@ -426,6 +929,131 @@ struct Caller<void>
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()));
return detail::none();
}
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(void (T::*pmf)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, PyObject* args, PyObject* /* keywords */ ) {
PyObject* self;
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &self, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
T& target = from_python(self, Type<T&>());
(target.*pmf)(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>()));
return detail::none();
}
// Free functions
static PyObject* call(void (*f)(), PyObject* args, PyObject* /* keywords */ ) {
@@ -500,6 +1128,150 @@ struct Caller<void>
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()));
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()));
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()));
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()));
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>()));
return detail::none();
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
static PyObject* call(void (*f)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11), PyObject* args, PyObject* /* keywords */ ) {
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
PyObject* a11;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11))
return 0;
f(from_python(a1, Type<A1>()),
from_python(a2, Type<A2>()),
from_python(a3, Type<A3>()),
from_python(a4, Type<A4>()),
from_python(a5, Type<A5>()),
from_python(a6, Type<A6>()),
from_python(a7, Type<A7>()),
from_python(a8, Type<A8>()),
from_python(a9, Type<A9>()),
from_python(a10, Type<A10>()),
from_python(a11, Type<A11>()));
return detail::none();
}
};
}

41
extclass.h
View File

@@ -6,7 +6,7 @@
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file automatically generated for 5-argument constructors by
// This file automatically generated for 10-argument constructors by
// gen_extclass.py
#ifndef EXTENSION_CLASS_DWA052000_H_
@@ -363,8 +363,8 @@ class ExtensionClass
~ExtensionClass();
// define constructors
template <class A1, class A2, class A3, class A4, class A5>
inline void def(Constructor<A1, A2, A3, A4, A5>)
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
inline void def(Constructor<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>)
// The following incantation builds a Signature1, Signature2,... object. It
// should _all_ get optimized away.
{ add_constructor(
@@ -373,9 +373,15 @@ class ExtensionClass
prepend(Type<A3>::Id(),
prepend(Type<A4>::Id(),
prepend(Type<A5>::Id(),
Signature0()))))));
prepend(Type<A6>::Id(),
prepend(Type<A7>::Id(),
prepend(Type<A8>::Id(),
prepend(Type<A9>::Id(),
prepend(Type<A10>::Id(),
Signature0())))))))))));
}
// export homogeneous operators (type of both lhs and rhs is 'operator')
// usage: foo_class.def(py::operators<(py::op_add | py::op_sub), Foo>());
@@ -603,7 +609,6 @@ class ExtensionClass
{
this->add_constructor_object(InitFunction<Holder>::create(sig));
}
};
// A simple wrapper over a T which allows us to use ExtensionClass<T> with a
@@ -625,6 +630,16 @@ public:
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : T(a1, a2, a3, a4) {}
template <class A1, class A2, class A3, class A4, class A5>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : T(a1, a2, a3, a4, a5) {}
template <class A1, class A2, class A3, class A4, class A5, class A6>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : T(a1, a2, a3, a4, a5, a6) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : T(a1, a2, a3, a4, a5, a6, a7) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : T(a1, a2, a3, a4, a5, a6, a7, a8) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
HeldInstance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
};
// Abstract base class for all instance holders. Base for template class
@@ -676,6 +691,21 @@ public:
template <class A1, class A2, class A3, class A4, class A5>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
m_held(p, a1, a2, a3, a4, a5) {}
template <class A1, class A2, class A3, class A4, class A5, class A6>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
m_held(p, a1, a2, a3, a4, a5, a6) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
m_held(p, a1, a2, a3, a4, a5, a6, a7) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
m_held(p, a1, a2, a3, a4, a5, a6, a7, a8) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
InstanceValueHolder(ExtensionInstance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
public: // implementation of InstanceHolderBase required interface
bool held_by_value() { return true; }
@@ -831,4 +861,3 @@ std::vector<DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;
}} // namespace py::detail
#endif // EXTENSION_CLASS_DWA052000_H_

2
gen_all.py
View File

@@ -17,7 +17,7 @@ if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
args = 5
args = 10
else:
args = int(sys.argv[1])

2
gen_caller.py
View File

@@ -92,7 +92,7 @@ def gen_caller(member_function_args, free_function_args = None):
free_function_args = member_function_args + 1
return_none = ''';
return none();'''
return detail::none();'''
return (header % (member_function_args, free_function_args)
+ body_sections[0]

336
gen_extclass.py
View File

@@ -30,12 +30,26 @@ def gen_extclass(args):
namespace py {
// forward declarations
template <long which, class operand> struct operators;
template <class T> struct left_operand;
template <class T> struct right_operand;
enum WithoutDowncast { without_downcast };
namespace detail {
// forward declarations
class ExtensionInstance;
class ExtensionClassBase;
template <class T> class InstanceHolder;
template <class T, class U> class InstanceValueHolder;
template <class Ptr, class T> class InstancePtrHolder;
template <class Specified> struct operand_select;
template <long> struct choose_op;
template <long> struct choose_rop;
template <long> struct choose_unary_op;
template <long> struct define_operator;
MetaClass<ExtensionInstance>* extension_meta_class();
ExtensionInstance* get_extension_instance(PyObject* p);
@@ -54,23 +68,21 @@ T* check_non_null(T* p)
template <class T> class HeldInstance;
namespace detail {
typedef void* (*ConversionFunction)(void*);
typedef void* (*ConversionFunction)(void*);
struct BaseClassInfo
{
BaseClassInfo(ExtensionClassBase* t, ConversionFunction f)
:class_object(t), convert(f)
{}
struct BaseClassInfo
{
BaseClassInfo(ExtensionClassBase* t, ConversionFunction f)
:class_object(t), convert(f)
{}
ExtensionClassBase* class_object;
ConversionFunction convert;
};
ExtensionClassBase* class_object;
ConversionFunction convert;
};
typedef BaseClassInfo DerivedClassInfo;
typedef BaseClassInfo DerivedClassInfo;
struct add_operator_base;
}
struct add_operator_base;
class ExtensionClassBase : public Class<ExtensionInstance>
{
@@ -89,11 +101,11 @@ class ExtensionClassBase : public Class<ExtensionInstance>
private:
virtual void* extract_object_from_holder(InstanceHolderBase* v) const = 0;
virtual std::vector<py::detail::BaseClassInfo> const& base_classes() const = 0;
virtual std::vector<py::detail::DerivedClassInfo> const& derived_classes() const = 0;
virtual std::vector<BaseClassInfo> const& base_classes() const = 0;
virtual std::vector<DerivedClassInfo> const& derived_classes() const = 0;
protected:
friend struct detail::add_operator_base;
friend struct add_operator_base;
void add_method(PyPtr<Function> method, const char* name);
void add_method(Function* method, const char* name);
@@ -114,19 +126,19 @@ class ClassRegistry
static void unregister_class(ExtensionClassBase*);
// Establish C++ inheritance relationships
static void register_base_class(py::detail::BaseClassInfo const&);
static void register_derived_class(py::detail::DerivedClassInfo const&);
static void register_base_class(BaseClassInfo const&);
static void register_derived_class(DerivedClassInfo const&);
// Query the C++ inheritance relationships
static std::vector<py::detail::BaseClassInfo> const& base_classes();
static std::vector<py::detail::DerivedClassInfo> const& derived_classes();
static std::vector<BaseClassInfo> const& base_classes();
static std::vector<DerivedClassInfo> const& derived_classes();
private:
static ExtensionClassBase* static_class_object;
static std::vector<py::detail::BaseClassInfo> static_base_class_info;
static std::vector<py::detail::DerivedClassInfo> static_derived_class_info;
static std::vector<BaseClassInfo> static_base_class_info;
static std::vector<DerivedClassInfo> static_derived_class_info;
};
}
}} // namespace py::detail
PY_BEGIN_CONVERSION_NAMESPACE
@@ -134,7 +146,7 @@ PY_BEGIN_CONVERSION_NAMESPACE
// and U. T is the class the user really intends to wrap. U is a class derived
// from T with some virtual function overriding boilerplate, or if there are no
// virtual functions, U = HeldInstance<T>.
template <class T, class U = py::HeldInstance<T> >
template <class T, class U = py::detail::HeldInstance<T> >
class PyExtensionClassConverters
{
public:
@@ -165,10 +177,10 @@ class PyExtensionClassConverters
// writes code which causes us to try to copy a T.
PyObject* to_python(const T& x) const
{
py::PyPtr<py::ExtensionInstance> result(create_instance());
py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
result->add_implementation(
std::auto_ptr<py::InstanceHolderBase>(
new py::InstanceValueHolder<T,U>(result.get(), x)));
std::auto_ptr<py::detail::InstanceHolderBase>(
new py::detail::InstanceValueHolder<T,U>(result.get(), x)));
return result.release();
}
@@ -176,21 +188,21 @@ class PyExtensionClassConverters
friend T* from_python(PyObject* obj, py::Type<T*>)
{
// Downcast to an ExtensionInstance, then find the actual T
py::ExtensionInstance* self = py::get_extension_instance(obj);
typedef std::vector<py::InstanceHolderBase*>::const_iterator Iterator;
py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
for (Iterator p = self->wrapped_objects().begin();
p != self->wrapped_objects().end(); ++p)
{
py::InstanceHolder<T>* held = dynamic_cast<py::InstanceHolder<T>*>(*p);
py::detail::InstanceHolder<T>* held = dynamic_cast<py::detail::InstanceHolder<T>*>(*p);
if (held != 0)
return held->target();
// see extclass.cpp for an explanation of try_class_conversions()
void* target = py::ClassRegistry<T>::class_object()->try_class_conversions(*p);
void* target = py::detail::ClassRegistry<T>::class_object()->try_class_conversions(*p);
if(target)
return static_cast<T*>(target);
}
py::report_missing_instance_data(self, py::ClassRegistry<T>::class_object(), typeid(T));
py::detail::report_missing_instance_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
throw py::ArgumentError();
}
@@ -199,38 +211,38 @@ class PyExtensionClassConverters
static PtrType& ptr_from_python(PyObject* obj, py::Type<PtrType>)
{
// Downcast to an ExtensionInstance, then find the actual T
py::ExtensionInstance* self = py::get_extension_instance(obj);
typedef std::vector<py::InstanceHolderBase*>::const_iterator Iterator;
py::detail::ExtensionInstance* self = py::detail::get_extension_instance(obj);
typedef std::vector<py::detail::InstanceHolderBase*>::const_iterator Iterator;
for (Iterator p = self->wrapped_objects().begin();
p != self->wrapped_objects().end(); ++p)
{
py::InstancePtrHolder<PtrType, T>* held =
dynamic_cast<py::InstancePtrHolder<PtrType, T>*>(*p);
py::detail::InstancePtrHolder<PtrType, T>* held =
dynamic_cast<py::detail::InstancePtrHolder<PtrType, T>*>(*p);
if (held != 0)
return held->ptr();
}
py::report_missing_ptr_data(self, py::ClassRegistry<T>::class_object(), typeid(T));
py::detail::report_missing_ptr_data(self, py::detail::ClassRegistry<T>::class_object(), typeid(T));
throw py::ArgumentError();
}
template <class PtrType>
static PyObject* ptr_to_python(PtrType x)
{
py::PyPtr<py::ExtensionInstance> result(create_instance());
py::PyPtr<py::detail::ExtensionInstance> result(create_instance());
result->add_implementation(
std::auto_ptr<py::InstanceHolderBase>(
new py::InstancePtrHolder<PtrType,T>(x)));
std::auto_ptr<py::detail::InstanceHolderBase>(
new py::detail::InstancePtrHolder<PtrType,T>(x)));
return result.release();
}
static py::PyPtr<py::ExtensionInstance> create_instance()
static py::PyPtr<py::detail::ExtensionInstance> create_instance()
{
PyTypeObject* class_object = py::ClassRegistry<T>::class_object();
PyTypeObject* class_object = py::detail::ClassRegistry<T>::class_object();
if (class_object == 0)
py::report_missing_class_object(typeid(T));
py::detail::report_missing_class_object(typeid(T));
return py::PyPtr<py::ExtensionInstance>(
new py::ExtensionInstance(class_object));
return py::PyPtr<py::detail::ExtensionInstance>(
new py::detail::ExtensionInstance(class_object));
}
// Convert to const T*
@@ -247,7 +259,7 @@ class PyExtensionClassConverters
// Convert to T&
friend T& from_python(PyObject* p, py::Type<T&>)
{ return *py::check_non_null(from_python(p, py::Type<T*>())); }
{ return *py::detail::check_non_null(from_python(p, py::Type<T*>())); }
// Convert to const T&
friend const T& from_python(PyObject* p, py::Type<const T&>)
@@ -298,6 +310,8 @@ namespace py {
PY_IMPORT_CONVERSION(PyExtensionClassConverters);
namespace detail {
template <class T> class InstanceHolder;
class ReadOnlySetattrFunction : public Function
@@ -310,72 +324,6 @@ class ReadOnlySetattrFunction : public Function
String m_name;
};
enum operator_id
{
op_add = 0x1,
op_sub = 0x2,
op_mul = 0x4,
op_div = 0x8,
op_mod = 0x10,
op_divmod =0x20,
op_pow = 0x40,
op_lshift = 0x80,
op_rshift = 0x100,
op_and = 0x200,
op_xor = 0x400,
op_or = 0x800,
op_neg = 0x1000,
op_pos = 0x2000,
op_abs = 0x4000,
op_invert = 0x8000,
op_int = 0x10000,
op_long = 0x20000,
op_float = 0x40000,
op_str = 0x80000,
op_cmp = 0x100000
};
namespace detail
{
struct auto_operand {};
template <class Specified>
struct operand_select
{
template <class WrappedType>
struct wrapped
{
typedef Specified type;
};
};
template <>
struct operand_select<auto_operand>
{
template <class WrappedType>
struct wrapped
{
typedef const WrappedType& type;
};
};
template <long> struct define_operator;
template <long> struct choose_op;
template <long> struct choose_rop;
template <long> struct choose_unary_op;
}
template <long which, class operand = py::detail::auto_operand>
struct operators {};
template <class T>
struct left_operand {};
template <class T>
struct right_operand {};
namespace detail
{
template <class From, class To>
struct DefineConversion
{
@@ -389,9 +337,6 @@ namespace detail
return dynamic_cast<To*>(static_cast<From*>(v));
}
};
}
enum WithoutDowncast { without_downcast };
// An easy way to make an extension base class which wraps T. Note that Python
// subclasses of this class will simply be Class<ExtensionInstance> objects.
@@ -445,7 +390,7 @@ class ExtensionClass
template <long which, class Operand>
inline void def(operators<which,Operand>)
{
typedef typename detail::operand_select<Operand>::template wrapped<T>::type true_operand;
typedef typename operand_select<Operand>::template wrapped<T>::type true_operand;
def_operators(operators<which,true_operand>());
}
@@ -459,7 +404,7 @@ class ExtensionClass
template <long which, class Left, class Right>
inline void def(operators<which,Left>, right_operand<Right> r)
{
typedef typename detail::operand_select<Left>::template wrapped<T>::type true_left;
typedef typename operand_select<Left>::template wrapped<T>::type true_left;
def_operators(operators<which,true_left>(), r);
}
@@ -475,7 +420,7 @@ class ExtensionClass
template <long which, class Left, class Right>
inline void def(operators<which,Right>, left_operand<Left> l)
{
typedef typename detail::operand_select<Right>::template wrapped<T>::type true_right;
typedef typename operand_select<Right>::template wrapped<T>::type true_right;
def_operators(operators<which,true_right>(), l);
}
@@ -488,7 +433,7 @@ class ExtensionClass
template <class Fn>
inline void def_raw(Fn fn, const char* name)
{
this->add_method(py::detail::new_raw_arguments_function(fn), name);
this->add_method(new_raw_arguments_function(fn), name);
}
// define member functions. In fact this works for free functions, too -
@@ -507,7 +452,7 @@ class ExtensionClass
template <class Fn, class DefaultFn>
inline void def(Fn fn, const char* name, DefaultFn default_fn)
{
this->add_method(py::detail::new_virtual_function(Type<T>(), fn, default_fn), name);
this->add_method(new_virtual_function(Type<T>(), fn, default_fn), name);
}
// Provide a function which implements x.<name>, reading from the given
@@ -541,10 +486,10 @@ class ExtensionClass
this->def_getter(pm, name);
this->def_setter(pm, name);
}
// define the standard coercion needed for operator overloading
void def_standard_coerce();
// declare the given class a base class of this one and register
// up and down conversion functions
template <class S, class V>
@@ -552,13 +497,13 @@ class ExtensionClass
{
// see extclass.cpp for an explanation of why we need to register
// conversion functions
detail::BaseClassInfo baseInfo(base,
&detail::DefineConversion<S, T>::downcast_ptr);
BaseClassInfo baseInfo(base,
&DefineConversion<S, T>::downcast_ptr);
ClassRegistry<T>::register_base_class(baseInfo);
add_base(Ptr(as_object(base), Ptr::new_ref));
detail::DerivedClassInfo derivedInfo(this,
&detail::DefineConversion<T, S>::upcast_ptr);
DerivedClassInfo derivedInfo(this,
&DefineConversion<T, S>::upcast_ptr);
ClassRegistry<S>::register_derived_class(derivedInfo);
}
@@ -569,12 +514,12 @@ class ExtensionClass
{
// see extclass.cpp for an explanation of why we need to register
// conversion functions
detail::BaseClassInfo baseInfo(base, 0);
BaseClassInfo baseInfo(base, 0);
ClassRegistry<T>::register_base_class(baseInfo);
add_base(Ptr(as_object(base), Ptr::new_ref));
detail::DerivedClassInfo derivedInfo(this,
&detail::DefineConversion<T, S>::upcast_ptr);
DerivedClassInfo derivedInfo(this,
&DefineConversion<T, S>::upcast_ptr);
ClassRegistry<S>::register_derived_class(derivedInfo);
}
@@ -582,8 +527,8 @@ class ExtensionClass
typedef InstanceValueHolder<T,U> Holder;
private: // ExtensionClassBase virtual function implementations
std::vector<detail::BaseClassInfo> const& base_classes() const;
std::vector<detail::DerivedClassInfo> const& derived_classes() const;
std::vector<BaseClassInfo> const& base_classes() const;
std::vector<DerivedClassInfo> const& derived_classes() const;
void* extract_object_from_holder(InstanceHolderBase* v) const;
private: // Utility functions
@@ -591,28 +536,32 @@ class ExtensionClass
inline void def_operators(operators<which,Operand>)
{
def_standard_coerce();
detail::choose_op<(which & op_add)>::template args<Operand>::add(this);
detail::choose_op<(which & op_sub)>::template args<Operand>::add(this);
detail::choose_op<(which & op_mul)>::template args<Operand>::add(this);
detail::choose_op<(which & op_div)>::template args<Operand>::add(this);
detail::choose_op<(which & op_mod)>::template args<Operand>::add(this);
detail::choose_op<(which & op_divmod)>::template args<Operand>::add(this);
detail::choose_op<(which & op_pow)>::template args<Operand>::add(this);
detail::choose_op<(which & op_lshift)>::template args<Operand>::add(this);
detail::choose_op<(which & op_rshift)>::template args<Operand>::add(this);
detail::choose_op<(which & op_and)>::template args<Operand>::add(this);
detail::choose_op<(which & op_xor)>::template args<Operand>::add(this);
detail::choose_op<(which & op_or)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_invert)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_int)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_long)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_float)>::template args<Operand>::add(this);
detail::choose_op<(which & op_cmp)>::template args<Operand>::add(this);
detail::choose_unary_op<(which & op_str)>::template args<Operand>::add(this);
// for some strange reason, this prevents MSVC from having an
// "unrecoverable block scoping error"!
typedef choose_op<(which & op_add)> choose_add;
choose_op<(which & op_add)>::template args<Operand>::add(this);
choose_op<(which & op_sub)>::template args<Operand>::add(this);
choose_op<(which & op_mul)>::template args<Operand>::add(this);
choose_op<(which & op_div)>::template args<Operand>::add(this);
choose_op<(which & op_mod)>::template args<Operand>::add(this);
choose_op<(which & op_divmod)>::template args<Operand>::add(this);
choose_op<(which & op_pow)>::template args<Operand>::add(this);
choose_op<(which & op_lshift)>::template args<Operand>::add(this);
choose_op<(which & op_rshift)>::template args<Operand>::add(this);
choose_op<(which & op_and)>::template args<Operand>::add(this);
choose_op<(which & op_xor)>::template args<Operand>::add(this);
choose_op<(which & op_or)>::template args<Operand>::add(this);
choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
choose_unary_op<(which & op_invert)>::template args<Operand>::add(this);
choose_unary_op<(which & op_int)>::template args<Operand>::add(this);
choose_unary_op<(which & op_long)>::template args<Operand>::add(this);
choose_unary_op<(which & op_float)>::template args<Operand>::add(this);
choose_op<(which & op_cmp)>::template args<Operand>::add(this);
choose_unary_op<(which & op_str)>::template args<Operand>::add(this);
}
template <long which, class Left, class Right>
@@ -620,19 +569,19 @@ class ExtensionClass
{
def_standard_coerce();
detail::choose_op<(which & op_add)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_sub)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_mul)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_div)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_mod)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_divmod)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_pow)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_lshift)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_rshift)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_and)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_or)>::template args<Left,Right>::add(this);
detail::choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
choose_op<(which & op_add)>::template args<Left,Right>::add(this);
choose_op<(which & op_sub)>::template args<Left,Right>::add(this);
choose_op<(which & op_mul)>::template args<Left,Right>::add(this);
choose_op<(which & op_div)>::template args<Left,Right>::add(this);
choose_op<(which & op_mod)>::template args<Left,Right>::add(this);
choose_op<(which & op_divmod)>::template args<Left,Right>::add(this);
choose_op<(which & op_pow)>::template args<Left,Right>::add(this);
choose_op<(which & op_lshift)>::template args<Left,Right>::add(this);
choose_op<(which & op_rshift)>::template args<Left,Right>::add(this);
choose_op<(which & op_and)>::template args<Left,Right>::add(this);
choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
choose_op<(which & op_or)>::template args<Left,Right>::add(this);
choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
}
template <long which, class Left, class Right>
@@ -640,19 +589,19 @@ class ExtensionClass
{
def_standard_coerce();
detail::choose_rop<(which & op_add)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_sub)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_mul)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_div)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_mod)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_divmod)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_pow)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_lshift)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_rshift)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_and)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_xor)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_or)>::template args<Left,Right>::add(this);
detail::choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
choose_rop<(which & op_add)>::template args<Left,Right>::add(this);
choose_rop<(which & op_sub)>::template args<Left,Right>::add(this);
choose_rop<(which & op_mul)>::template args<Left,Right>::add(this);
choose_rop<(which & op_div)>::template args<Left,Right>::add(this);
choose_rop<(which & op_mod)>::template args<Left,Right>::add(this);
choose_rop<(which & op_divmod)>::template args<Left,Right>::add(this);
choose_rop<(which & op_pow)>::template args<Left,Right>::add(this);
choose_rop<(which & op_lshift)>::template args<Left,Right>::add(this);
choose_rop<(which & op_rshift)>::template args<Left,Right>::add(this);
choose_rop<(which & op_and)>::template args<Left,Right>::add(this);
choose_rop<(which & op_xor)>::template args<Left,Right>::add(this);
choose_rop<(which & op_or)>::template args<Left,Right>::add(this);
choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
}
template <class Signature>
@@ -758,10 +707,7 @@ class ExtensionInstance : public Instance
// Template function implementations
//
namespace detail
{
Tuple extension_class_coerce(Ptr l, Ptr r);
}
Tuple extension_class_coerce(Ptr l, Ptr r);
template <class T, class U>
ExtensionClass<T, U>::ExtensionClass()
@@ -778,17 +724,17 @@ ExtensionClass<T, U>::ExtensionClass(const char* name)
}
template <class T, class U>
void ExtensionClass<T, U>::register_coerce()
void ExtensionClass<T, U>::def_standard_coerce()
{
Ptr coerce_fct = dict().get_item(String("__coerce__"));
if(coerce_fct.get() == 0) // not yet defined
this->def(&py::detail::extension_class_coerce, "__coerce__");
this->def(&extension_class_coerce, "__coerce__");
}
template <class T, class U>
inline
std::vector<detail::BaseClassInfo> const&
std::vector<BaseClassInfo> const&
ExtensionClass<T, U>::base_classes() const
{
return ClassRegistry<T>::base_classes();
@@ -796,7 +742,7 @@ ExtensionClass<T, U>::base_classes() const
template <class T, class U>
inline
std::vector<detail::DerivedClassInfo> const&
std::vector<DerivedClassInfo> const&
ExtensionClass<T, U>::derived_classes() const
{
return ClassRegistry<T>::derived_classes();
@@ -805,7 +751,7 @@ ExtensionClass<T, U>::derived_classes() const
template <class T, class U>
void* ExtensionClass<T, U>::extract_object_from_holder(InstanceHolderBase* v) const
{
py::InstanceHolder<T>* held = dynamic_cast<py::InstanceHolder<T>*>(v);
InstanceHolder<T>* held = dynamic_cast<InstanceHolder<T>*>(v);
if(held)
return held->target();
return 0;
@@ -835,25 +781,25 @@ inline void ClassRegistry<T>::unregister_class(ExtensionClassBase* p)
}
template <class T>
void ClassRegistry<T>::register_base_class(py::detail::BaseClassInfo const& i)
void ClassRegistry<T>::register_base_class(BaseClassInfo const& i)
{
static_base_class_info.push_back(i);
}
template <class T>
void ClassRegistry<T>::register_derived_class(py::detail::DerivedClassInfo const& i)
void ClassRegistry<T>::register_derived_class(DerivedClassInfo const& i)
{
static_derived_class_info.push_back(i);
}
template <class T>
std::vector<py::detail::BaseClassInfo> const& ClassRegistry<T>::base_classes()
std::vector<BaseClassInfo> const& ClassRegistry<T>::base_classes()
{
return static_base_class_info;
}
template <class T>
std::vector<py::detail::DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
std::vector<DerivedClassInfo> const& ClassRegistry<T>::derived_classes()
{
return static_derived_class_info;
}
@@ -864,11 +810,11 @@ std::vector<py::detail::DerivedClassInfo> const& ClassRegistry<T>::derived_class
template <class T>
ExtensionClassBase* ClassRegistry<T>::static_class_object;
template <class T>
std::vector<py::detail::BaseClassInfo> ClassRegistry<T>::static_base_class_info;
std::vector<BaseClassInfo> ClassRegistry<T>::static_base_class_info;
template <class T>
std::vector<py::detail::DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;
std::vector<DerivedClassInfo> ClassRegistry<T>::static_derived_class_info;
} // namespace py
}} // namespace py::detail
#endif // EXTENSION_CLASS_DWA052000_H_
""")

3
gen_init_function.py
View File

@@ -105,7 +105,6 @@ namespace detail {
private:
const_reference value;
};
}
class ExtensionInstance;
class InstanceHolderBase;
@@ -150,7 +149,7 @@ struct Init%x : Init
{ return typeid(void (*)(T&%(, A%n%%))).name(); }
};""", args) + """
}
}} // namespace py::detail
#endif // INIT_FUNCTION_DWA052000_H_
""")

14
gen_signatures.py
View File

@@ -58,9 +58,11 @@ def gen_signatures(args):
namespace py {
namespace detail {
// A stand-in for the built-in void. This one can be passed to functions and
// (under MSVC, which has a bug, be used as a default template type parameter).
struct Void {};
}
// An envelope in which type information can be delivered for the purposes
// of selecting an overloaded from_python() function. This is needed to work
@@ -79,11 +81,12 @@ struct Type
};
template <>
struct Type<Void>
struct Type<py::detail::Void>
{
typedef Void Id;
typedef py::detail::Void Id;
};
namespace detail {
// These basically encapsulate a chain of types, , used to make the syntax of
// add(Constructor<T1, ...>()) work. We need to produce a unique type for each number
// of non-default parameters to Constructor<>. Q: why not use a recursive
@@ -97,14 +100,17 @@ struct Type<Void>
// This one terminates the chain. Prepending Void to the head of a Void
// signature results in a Void signature again.
inline Signature0 prepend(Void, Signature0) { return Signature0(); }
} // namespace detail
"""
+ gen_function("""
template <%(class A%n% = Void%:, %)>
template <%(class A%n% = detail::Void%:, %)>
struct Constructor
{
};
""", args)
+ """
namespace detail {
// Return value extraction:
// This is just another little envelope for carrying a typedef (see Type,
@@ -135,7 +141,7 @@ ReturnValue<R> return_value(R (T::*)(%(A%n%:, %)) const) { return ReturnValue<R>
""", args)
+ """
}
}} // namespace py::detail
#endif
""")

4
gen_singleton.py
View File

@@ -16,7 +16,7 @@ def gen_singleton(args):
# include "pyconfig.h"
namespace py {
namespace py { namespace detail {
struct Empty {};
template <class Derived, class Base = Empty>
@@ -42,7 +42,7 @@ Derived* Singleton<Derived,Base>::singleton()
return &x;
}
}
}} // namespace py::detail
#endif
""")

220
init_function.h
View File

@@ -110,6 +110,11 @@ template <class T, class A1, class A2> struct Init2;
template <class T, class A1, class A2, class A3> struct Init3;
template <class T, class A1, class A2, class A3, class A4> struct Init4;
template <class T, class A1, class A2, class A3, class A4, class A5> struct Init5;
template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct Init6;
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct Init7;
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct Init8;
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct Init9;
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct Init10;
template <class T>
struct InitFunction
@@ -157,6 +162,71 @@ struct InitFunction
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference>;
}
template <class A1, class A2, class A3, class A4, class A5, class A6>
static Init* create(Signature6<A1, A2, A3, A4, A5, A6>) {
return new Init6<T,
detail::parameter_traits<A1>::const_reference,
detail::parameter_traits<A2>::const_reference,
detail::parameter_traits<A3>::const_reference,
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference,
detail::parameter_traits<A6>::const_reference>;
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
static Init* create(Signature7<A1, A2, A3, A4, A5, A6, A7>) {
return new Init7<T,
detail::parameter_traits<A1>::const_reference,
detail::parameter_traits<A2>::const_reference,
detail::parameter_traits<A3>::const_reference,
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference,
detail::parameter_traits<A6>::const_reference,
detail::parameter_traits<A7>::const_reference>;
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
static Init* create(Signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
return new Init8<T,
detail::parameter_traits<A1>::const_reference,
detail::parameter_traits<A2>::const_reference,
detail::parameter_traits<A3>::const_reference,
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference,
detail::parameter_traits<A6>::const_reference,
detail::parameter_traits<A7>::const_reference,
detail::parameter_traits<A8>::const_reference>;
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
static Init* create(Signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
return new Init9<T,
detail::parameter_traits<A1>::const_reference,
detail::parameter_traits<A2>::const_reference,
detail::parameter_traits<A3>::const_reference,
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference,
detail::parameter_traits<A6>::const_reference,
detail::parameter_traits<A7>::const_reference,
detail::parameter_traits<A8>::const_reference,
detail::parameter_traits<A9>::const_reference>;
}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
static Init* create(Signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
return new Init10<T,
detail::parameter_traits<A1>::const_reference,
detail::parameter_traits<A2>::const_reference,
detail::parameter_traits<A3>::const_reference,
detail::parameter_traits<A4>::const_reference,
detail::parameter_traits<A5>::const_reference,
detail::parameter_traits<A6>::const_reference,
detail::parameter_traits<A7>::const_reference,
detail::parameter_traits<A8>::const_reference,
detail::parameter_traits<A9>::const_reference,
detail::parameter_traits<A10>::const_reference>;
}
};
class Init : public Function
@@ -282,6 +352,156 @@ struct Init5 : Init
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5)).name(); }
};
template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
struct Init6 : Init
{
virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
{
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
throw ArgumentError();
return new T(self,
py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
py::detail::reference_parameter<A6>(from_python(a6, Type<A6>()))
);
}
const char* description() const
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6)).name(); }
};
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
struct Init7 : Init
{
virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
{
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
throw ArgumentError();
return new T(self,
py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
py::detail::reference_parameter<A7>(from_python(a7, Type<A7>()))
);
}
const char* description() const
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7)).name(); }
};
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
struct Init8 : Init
{
virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
{
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
throw ArgumentError();
return new T(self,
py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
py::detail::reference_parameter<A8>(from_python(a8, Type<A8>()))
);
}
const char* description() const
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8)).name(); }
};
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
struct Init9 : Init
{
virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
{
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
throw ArgumentError();
return new T(self,
py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
py::detail::reference_parameter<A8>(from_python(a8, Type<A8>())),
py::detail::reference_parameter<A9>(from_python(a9, Type<A9>()))
);
}
const char* description() const
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9)).name(); }
};
template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
struct Init10 : Init
{
virtual InstanceHolderBase* create_holder(ExtensionInstance* self, PyObject* args, PyObject* /*keywords*/) const
{
PyObject* a1;
PyObject* a2;
PyObject* a3;
PyObject* a4;
PyObject* a5;
PyObject* a6;
PyObject* a7;
PyObject* a8;
PyObject* a9;
PyObject* a10;
if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
throw ArgumentError();
return new T(self,
py::detail::reference_parameter<A1>(from_python(a1, Type<A1>())),
py::detail::reference_parameter<A2>(from_python(a2, Type<A2>())),
py::detail::reference_parameter<A3>(from_python(a3, Type<A3>())),
py::detail::reference_parameter<A4>(from_python(a4, Type<A4>())),
py::detail::reference_parameter<A5>(from_python(a5, Type<A5>())),
py::detail::reference_parameter<A6>(from_python(a6, Type<A6>())),
py::detail::reference_parameter<A7>(from_python(a7, Type<A7>())),
py::detail::reference_parameter<A8>(from_python(a8, Type<A8>())),
py::detail::reference_parameter<A9>(from_python(a9, Type<A9>())),
py::detail::reference_parameter<A10>(from_python(a10, Type<A10>()))
);
}
const char* description() const
{ return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
};
}} // namespace py::detail
#endif // INIT_FUNCTION_DWA052000_H_

87
signatures.h
View File

@@ -6,13 +6,13 @@
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
//
// This file automatically generated by gen_signatures.py for 5 arguments.
// This file automatically generated by gen_signatures.py for 10 arguments.
#ifndef SIGNATURES_DWA050900_H_
# define SIGNATURES_DWA050900_H_
# include "pyconfig.h"
namespace py {
namespace py {
namespace detail {
// A stand-in for the built-in void. This one can be passed to functions and
@@ -50,9 +50,44 @@ namespace detail {
// that involve recursive template nesting.
//
// Signature chaining
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
struct Signature10 {};
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
struct Signature9 {};
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class X>
inline Signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(Type<X>, Signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
{ return Signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9>(); }
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
struct Signature8 {};
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class X>
inline Signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(Type<X>, Signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
{ return Signature9<X, T1, T2, T3, T4, T5, T6, T7, T8>(); }
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
struct Signature7 {};
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class X>
inline Signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(Type<X>, Signature7<T1, T2, T3, T4, T5, T6, T7>)
{ return Signature8<X, T1, T2, T3, T4, T5, T6, T7>(); }
template <class T1, class T2, class T3, class T4, class T5, class T6>
struct Signature6 {};
template <class T1, class T2, class T3, class T4, class T5, class T6, class X>
inline Signature7<X, T1, T2, T3, T4, T5, T6> prepend(Type<X>, Signature6<T1, T2, T3, T4, T5, T6>)
{ return Signature7<X, T1, T2, T3, T4, T5, T6>(); }
template <class T1, class T2, class T3, class T4, class T5>
struct Signature5 {};
template <class T1, class T2, class T3, class T4, class T5, class X>
inline Signature6<X, T1, T2, T3, T4, T5> prepend(Type<X>, Signature5<T1, T2, T3, T4, T5>)
{ return Signature6<X, T1, T2, T3, T4, T5>(); }
template <class T1, class T2, class T3, class T4>
struct Signature4 {};
@@ -94,13 +129,12 @@ inline Signature0 prepend(Void, Signature0) { return Signature0(); }
} // namespace detail
template <class A1 = detail::Void, class A2 = detail::Void, class A3 = detail::Void, class A4 = detail::Void, class A5 = detail::Void>
template <class A1 = detail::Void, class A2 = detail::Void, class A3 = detail::Void, class A4 = detail::Void, class A5 = detail::Void, class A6 = detail::Void, class A7 = detail::Void, class A8 = detail::Void, class A9 = detail::Void, class A10 = detail::Void>
struct Constructor
{
};
namespace detail {
// Return value extraction:
// This is just another little envelope for carrying a typedef (see Type,
@@ -128,6 +162,21 @@ ReturnValue<R> return_value(R (*)(A1, A2, A3, A4)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return ReturnValue<R>(); }
template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
ReturnValue<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return ReturnValue<R>(); }
// TODO(?): handle 'const void'
// member functions
@@ -149,6 +198,21 @@ ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4)) { return ReturnValue<R>();
template <class R, class T, class A1, class A2, class A3, class A4, class A5>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return ReturnValue<R>(); }
template <class R, class T>
ReturnValue<R> return_value(R (T::*)() const) { return ReturnValue<R>(); }
@@ -167,6 +231,21 @@ ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return ReturnValue
template <class R, class T, class A1, class A2, class A3, class A4, class A5>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return ReturnValue<R>(); }
template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
ReturnValue<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return ReturnValue<R>(); }
}} // namespace py::detail
#endif

15
singleton.h
View File

@@ -39,6 +39,21 @@ struct Singleton : Base
template <class A1, class A2, class A3, class A4, class A5>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
template <class A1, class A2, class A3, class A4, class A5, class A6>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
Singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
};
template <class Derived, class Base>