boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-22 05:22:45 +00:00
Code Issues Projects Releases Wiki Activity

Added call() function so that a regular python function (as opposed to method or

Browse Source 
other function-as-attribute) can be called.

Added newlines for readability.


[SVN r8172]
This commit is contained in:
Dave Abrahams
2000-11-12 18:10:46 +00:00
parent 692123408b
commit 086527bcc2
2 changed files with 195 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
callback.h
View File

@@ -24,27 +24,110 @@ template <class R>
struct Callback
{
static R call_method(PyObject* self, const char* name)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("()"))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("()"))), Type<R>());
}
template <class A1>
static R call_method(PyObject* self, const char* name, const A1& a1)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(N)"), to_python(a1))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(N)"),
to_python(a1))), Type<R>());
}
template <class A1, class A2>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NN)"), to_python(a1), to_python(a2))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NN)"),
to_python(a1),
to_python(a2))), Type<R>());
}
template <class A1, class A2, class A3>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNN)"), to_python(a1), to_python(a2), to_python(a3))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNN)"),
to_python(a1),
to_python(a2),
to_python(a3))), Type<R>());
}
template <class A1, class A2, class A3, class A4>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNNN)"), to_python(a1), to_python(a2), to_python(a3), to_python(a4))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4))), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5>
static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
{ return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNNNN)"), to_python(a1), to_python(a2), to_python(a3), to_python(a4), to_python(a5))), Type<R>()); }
{
return from_python(expect_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4),
to_python(a5))), Type<R>());
}
static R call(PyObject* self)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("()"))), Type<R>());
}
template <class A1>
static R call(PyObject* self, const A1& a1)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("(N)"),
to_python(a1))), Type<R>());
}
template <class A1, class A2>
static R call(PyObject* self, const A1& a1, const A2& a2)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("(NN)"),
to_python(a1),
to_python(a2))), Type<R>());
}
template <class A1, class A2, class A3>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNN)"),
to_python(a1),
to_python(a2),
to_python(a3))), Type<R>());
}
template <class A1, class A2, class A3, class A4>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4))), Type<R>());
}
template <class A1, class A2, class A3, class A4, class A5>
static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
{
return from_python(expect_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4),
to_python(a5))), Type<R>());
}
};
@@ -55,30 +138,114 @@ template <>
struct Callback<void>
{
static void call_method(PyObject* self, const char* name)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("()"))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("()")));
}
template <class A1>
static void call_method(PyObject* self, const char* name, const A1& a1)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(N)"), to_python(a1))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(N)"),
to_python(a1)));
}
template <class A1, class A2>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NN)"), to_python(a1), to_python(a2))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NN)"),
to_python(a1),
to_python(a2)));
}
template <class A1, class A2, class A3>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNN)"), to_python(a1), to_python(a2), to_python(a3))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNN)"),
to_python(a1),
to_python(a2),
to_python(a3)));
}
template <class A1, class A2, class A3, class A4>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNNN)"), to_python(a1), to_python(a2), to_python(a3), to_python(a4))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4)));
}
template <class A1, class A2, class A3, class A4, class A5>
static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
{ expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(NNNNN)"), to_python(a1), to_python(a2), to_python(a3), to_python(a4), to_python(a5))); }
{
expect_and_absorb_non_null(PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(NNNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4),
to_python(a5)));
}
static void call(PyObject* self)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("()")));
}
template <class A1>
static void call(PyObject* self, const A1& a1)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("(N)"),
to_python(a1)));
}
template <class A1, class A2>
static void call(PyObject* self, const A1& a1, const A2& a2)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("(NN)"),
to_python(a1),
to_python(a2)));
}
template <class A1, class A2, class A3>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNN)"),
to_python(a1),
to_python(a2),
to_python(a3)));
}
template <class A1, class A2, class A3, class A4>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4)));
}
template <class A1, class A2, class A3, class A4, class A5>
static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
{
expect_and_absorb_non_null(PyEval_CallFunction(self, const_cast<char*>("(NNNNN)"),
to_python(a1),
to_python(a2),
to_python(a3),
to_python(a4),
to_python(a5)));
}
};
} // namespace py
#endif // CALLBACK_DWA_052100_H_

17
gen_callback.py
View File

@@ -5,7 +5,20 @@ def gen_callback(args):
# A template for the call_method function which we're going to generate
call_method = '''%{ template <%(class A%n%:, %)>
%} static %1 call_method(PyObject* self, const char* name%(, const A%n& a%n%))
{ %2PyEval_CallMethod(self, const_cast<char*>(name), const_cast<char*>("(%(N%))")%(, to_python(a%n)%))%3; }
{
%2PyEval_CallMethod(self, const_cast<char*>(name),
const_cast<char*>("(%(N%))")%(,
to_python(a%n)%))%3;
}
'''
call_function = '''%{ template <%(class A%n%:, %)>
%} static %1 call(PyObject* self%(, const A%n& a%n%))
{
%2PyEval_CallFunction(self, const_cast<char*>("(%(N%))")%(,
to_python(a%n)%))%3;
}
'''
non_void = ('R', 'return from_python(expect_non_null(', '), Type<R>())')
@@ -39,6 +52,7 @@ struct Callback
{
""" % args
+ gen_functions(call_method, args, 'R', 'return from_python(expect_non_null(', '), Type<R>())')
+ gen_functions(call_function, args, 'R', 'return from_python(expect_non_null(', '), Type<R>())')
+
"""};
@@ -50,6 +64,7 @@ struct Callback<void>
{
"""
+ gen_functions(call_method, args, 'void', 'expect_and_absorb_non_null(', ')')
+ gen_functions(call_function, args, 'void', 'expect_and_absorb_non_null(', ')')
+
"""};