要传递 Python 类型对象,需要创建一个 C++ 类型并注册一个自定义转换器。由于 Python 类型对象是一个 Python 对象,因此创建一个派生自的类型boost::python::object
是合适的:
/// @brief boost::python::object that refers to a type.
struct type_object:
public boost::python::object
{
/// @brief If the object is a type, then refer to it. Otherwise,
/// refer to the instance's type.
explicit
type_object(boost::python::object object):
boost::python::object(get_type(object))
{}
private:
/// @brief Get a type object from the given borrowed PyObject.
static boost::python::object get_type(boost::python::object object)
{
return PyType_Check(object.ptr())
? object
: object.attr("__class__");
}
};
// ... register custom converter for type_object.
然而,示例代码提出了一个额外的问题。 Python 类型对象和 C++ 类型之间无法直接进行比较。此外,Python 类型对象与 C++ 类型没有直接关联。为了进行比较,需要比较Python类型对象。
Boost.Python 使用内部注册表来关联 C++ 类型标识,其形式为boost::python::type_info http://www.boost.org/doc/libs/release/libs/python/doc/v2/type_id.html#type_info-spec,到一个Python类对象。这种关联是单向的,因为只能查找 Python 类对象。让我们扩展一下type_object
类允许提供辅助函数来检查 C++ 类型:
/// @brief boost::python::object that refers to a type.
struct type_object:
public boost::python::object
{
...
/// @brief Type identity check. Returns true if this is the object returned
/// returned from type() when passed an instance of an object created
/// from a C++ object with type T.
template <typename T>
bool is() const
{
// Perform an identity check that registartion for type T and type_object
// are the same Python type object.
return get_class_object<T>() == static_cast<void*>(ptr());
}
/// @brief Type identity check. Returns true if this is the object is a
/// subclass of the type returned returned from type() when passed
/// an instance of an object created from a C++ object with type T.
template <typename T>
bool is_subclass() const
{
return PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(ptr()),
get_class_object<T>());
}
private:
...
/// @brief Get the Python class object for C++ type T.
template <typename T>
static PyTypeObject* get_class_object()
{
namespace python = boost::python;
// Locate registration based on the C++ type.
const python::converter::registration* registration =
python::converter::registry::query(python::type_id<T>());
// If registration exists, then return the class object. Otherwise,
// return NULL.
return (registration) ? registration->get_class_object()
: NULL;
}
};
Now, if type
是一个实例type_object
,可以检查:
- If
type
是与 C++ 关联的 Python 类型Spam
键入type.is<Spam>()
.
- If
type
是与 C++ 相关的 Python 类型的子类Spam
键入type.is_subclass<Spam>()
.
这是一个基于原始代码的完整示例展示 http://coliru.stacked-crooked.com/a/3021cdc765dee604接收类型对象到函数,检查类型标识和子类:
#include <boost/python.hpp>
/// @brief boost::python::object that refers to a type.
struct type_object:
public boost::python::object
{
/// @brief If the object is a type, then refer to it. Otherwise,
/// refer to the instance's type.
explicit
type_object(boost::python::object object):
boost::python::object(get_type(object))
{}
/// @brief Type identity check. Returns true if this is the object returned
/// returned from type() when passed an instance of an object created
/// from a C++ object with type T.
template <typename T>
bool is() const
{
// Perform an identity check that registartion for type T and type_object
// are the same Python type object.
return get_class_object<T>() == static_cast<void*>(ptr());
}
/// @brief Type identity check. Returns true if this is the object is a
/// subclass of the type returned returned from type() when passed
/// an instance of an object created from a C++ object with type T.
template <typename T>
bool is_subclass() const
{
return PyType_IsSubtype(reinterpret_cast<PyTypeObject*>(ptr()),
get_class_object<T>());
}
private:
/// @brief Get a type object from the given borrowed PyObject.
static boost::python::object get_type(boost::python::object object)
{
return PyType_Check(object.ptr())
? object
: object.attr("__class__");
}
/// @brief Get the Python class object for C++ type T.
template <typename T>
static PyTypeObject* get_class_object()
{
namespace python = boost::python;
// Locate registration based on the C++ type.
const python::converter::registration* registration =
python::converter::registry::query(python::type_id<T>());
// If registration exists, then return the class object. Otherwise,
// return NULL.
return (registration) ? registration->get_class_object()
: NULL;
}
};
/// @brief Enable automatic conversions to type_object.
struct enable_type_object
{
enable_type_object()
{
boost::python::converter::registry::push_back(
&convertible,
&construct,
boost::python::type_id<type_object>());
}
static void* convertible(PyObject* object)
{
return (PyType_Check(object) || Py_TYPE(object)) ? object : NULL;
}
static void construct(
PyObject* object,
boost::python::converter::rvalue_from_python_stage1_data* data)
{
// Obtain a handle to the memory block that the converter has allocated
// for the C++ type.
namespace python = boost::python;
typedef python::converter::rvalue_from_python_storage<type_object>
storage_type;
void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
// Construct the type object within the storage. Object is a borrowed
// reference, so create a handle indicting it is borrowed for proper
// reference counting.
python::handle<> handle(python::borrowed(object));
new (storage) type_object(python::object(handle));
// Set convertible to indicate success.
data->convertible = storage;
}
};
// Mockup types.
struct A {};
struct B: public A {};
struct C {};
/// Mockup function that receives an object's type.
int func(type_object type)
{
if (type.is<A>()) return 0;
if (type.is<B>()) return 1;
return -1;
}
/// Mockup function that returns true if the provided object type is a
/// subclass of A.
bool isSubclassA(type_object type)
{
return type.is_subclass<A>();
}
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Enable receiving type_object as arguments.
enable_type_object();
python::class_<A>("A");
python::class_<B, python::bases<A> >("B");
python::class_<C>("C");
python::def("func", &func);
python::def("isSubclassA", &isSubclassA);
}
互动使用:
>>> import example
>>> assert(example.func(type("test")) == -1)
>>> assert(example.func(example.A) == 0)
>>> assert(example.func(example.B) == 1)
>>> assert(example.isSubclassA(example.A))
>>> assert(example.isSubclassA(example.B))
>>> assert(not example.isSubclassA(example.C))
>>> assert(example.func("test") == -1)
>>> assert(example.func(example.A()) == 0)
>>> assert(example.func(example.B()) == 1)
>>> assert(example.isSubclassA(example.A()))
>>> assert(example.isSubclassA(example.B()))
>>> assert(not example.isSubclassA(example.C()))