从boostpython模块内部的pyside导入类

PySide提供了与Shiboken的Qt绑定。Shiboken生成Python C API绑定，支持自己的类型转换系统。这些转换的知识存在于Shiboken生成的绑定中，而不是Python类型的系统中。因此，PySide知道如何将QPointF对象转换为C++/Python；Python的类型系统没有。

当一个对象通过Boost.Python公开的函数转换时，Boost.Pathon将检查其注册表中是否有合适的类型转换器。这些转换器为Boost.Python提供了如何为通过Boost.Pathon公开的类型转换为C++/Python的知识。因此，当Boost.Pthon试图将QPointF C++类型返回给Python时，它会抛出一个异常，因为转换尚未在Boost.PPython中注册。

这是带注释的代码：

import myBoostPythonModule
from PySide.QtCore import *
...
x=myBoostPythonModule.X('foo') # Boost.Python knows how to convert C++ X
                               # to Python X.  Python's type system does not.
w=QPointF()                    # Shiboken knows how to convert C++ QPointF to
                               # Python QPointF.  Python's type system does not.
print(w)                       # Shiboken knows how to represent C++ QPointF as
                               # a string.
y=x.getY()                     # Boost.Python knows how to invoke X::getY(),
                               # but only Shiboken knows how to convert C++
                               # QPointF to Python QPointF.  Thus, the TypeError
                               # exception is raised.

可以用另一种实现方式来实现Boost.Python的转换器。在Shiboken类型转换器示例的基础上，下面是一个完整的Boost.Python转换器示例，它是用Shiboken的旧类型转换器实现的。我本想使用新的Shiboken类型转换器API，但我不清楚它是基于什么文档。

#include <iostream>
#include <boost/python.hpp>
/// @brief Mockup Complex class from Shiboken documentation.
class Complex
{
public:
  Complex(double real, double imaginary)
    : real_(real),
      imaginary_(imaginary)
  {}
  double real() const      { return real_;      }
  double imaginary() const { return imaginary_; }
private:
  double real_;
  double imaginary_;
};
/// @brief Mocked up Shiboken converter.
namespace Shiboken {
template <typename> struct Converter;
template <> struct Converter<Complex>
{
public:
  // ...
  static inline bool isConvertible(PyObject* pyObj)
  {
    std::cout << "Shiboken::Converter<Complex>::isConvertible()" << std::endl;
    return PyComplex_Check(pyObj);
  }
  // ...
  static inline PyObject* toPython(const Complex& cpx)
  {
    std::cout << "Shiboken::Converter<Complex>::toPython()" << std::endl;
    return PyComplex_FromDoubles(cpx.real(), cpx.imaginary());
  }
  static inline Complex toCpp(PyObject* pyobj)
  {
    std::cout << "Shiboken::Converter<Complex>::toCpp()" << std::endl;
    double real      =  PyComplex_RealAsDouble(pyobj);
    double imaginary =  PyComplex_ImagAsDouble(pyobj);
    return Complex(real, imaginary);
  }
};
} // namespace Shiboken
/// @brief Type used to convert a complex to Python.
struct complex_converter_to_python
{
  static PyObject* convert(const Complex& c)
  {
    // Delegate to Shiboken.
    std::cout << "complex_converter_to_python::convert()" << std::endl;
    return Shiboken::Converter<Complex>::toPython(c);
  }
};
/// @brief Type that registers a Python Complex type to C++
///        Complex when passing through Boost.Python.
struct complex_converter_from_python
{
  /// @note Registers converter from a python complex to C++ complex.
  complex_converter_from_python()
  {
    boost::python::converter::registry::push_back(
      &complex_converter_from_python::convertible,
      &complex_converter_from_python::construct,
      boost::python::type_id<Complex>());
  }
  /// @brief Check if PyObject is a Complex.
  static void* convertible(PyObject* object)
  {
    // Delegate to Shiboken.  Based on the documentation, the
    // isConvertible function is gone, so explicit checking may
    // be required based on the version of Shiboken.
    std::cout << "complex_converter_from_python::convertible()" << std::endl;
    return Shiboken::Converter<Complex>::isConvertible(object)
      ? object 
      : NULL;
  }
  /// @brief Convert Python Complex to C++ Complex.
  static void construct(
    PyObject* object,
    boost::python::converter::rvalue_from_python_stage1_data* data)
  {
    // Obtain a handle to the memory block that the Boost.Python
    // converter has allocated for the C++ type.
    namespace python = boost::python;
    typedef python::converter::rvalue_from_python_storage<Complex>
                                                                storage_type;
    void* storage = reinterpret_cast<storage_type*>(data)->storage.bytes;
    // In-place construct a Complex type via copy-constructor, passing
    // in a Complex created from Shiboken.
    std::cout << "complex_converter_from_python::construct()" << std::endl;
    data->convertible = new (storage) Complex(
      Shiboken::Converter<Complex>::toCpp(object));
  }
};
/// @brief Factory function used to exercise to-python conversion.
Complex make_complex(double real, double imaginary)
{
  return Complex(real, imaginary);
}
/// @brief Printing function used to exercise from-python converison.
void print_complex(const Complex& c)
{
  std::cout << "In print_complex: "
            << c.real() << ", "
            << c.imaginary() << std::endl;
}
BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  // Register Complex from python converter.
  complex_converter_from_python();
  // Register Complex to python converter.
  python::to_python_converter<
    Complex,
    complex_converter_to_python>();
  python::def("make_complex",  &make_complex);
  python::def("print_complex", &print_complex);
}

及其用途：

>>> import example
>>> x = example.make_complex(4, 2)
complex_converter_to_python::convert()
Shiboken::Converter<Complex>::toPython()
>>> example.print_complex(x)
complex_converter_from_python::convertible()
Shiboken::Converter<Complex>::isConvertible()
complex_converter_from_python::construct()
Shiboken::Converter<Complex>::toCpp()
In print_complex: 4, 2

另一种方法虽然不是最优雅的方法，但可以使用Boost中公开的函数。Python使用boost::python::object类型，并通过Python语句与对象接口。类似于：

boost::python::object X::getY()
{ 
  return boost::python::exec("QPointF()", ...); 
}

上面的代码将让Python实例化一个QPointFPython对象，该对象将委托给Shiboken的类型系统。由于X::getY()返回一个泛型对象，当对象句柄从C++转换到Python时，Boost.Python不会尝试执行类型转换。

根据前面的回复和我发现的其他信息，这里有一个有点通用的例程，允许像PySide.QtGui.QColor参数这样的东西传递到boost::python包装的c++方法中，该方法需要QColor&输入参数：

template<class QtGuiClass,int SBK_BOGAN_IDX>
struct QtGui_from_python {
QtGui_from_python() {
  qDebug()<<" registering type: " << typeid(this).name() << " in " << __FUNCTION__;
  boost::python::converter::registry::push_back(
    &convertible,
    &construct,
    boost::python::type_id<QtGuiClass>());
}
static void* convertible(PyObject* obj_ptr) {
    if(!PyObject_TypeCheck(obj_ptr,
            (PyTypeObject*)XSbkPySide_QtGuiTypes[SBK_BOGAN_IDX]))
    {    qDebug()<<"Failed type check!?"; }
    return obj_ptr;
}
static void construct( PyObject* obj_ptr, 
   bp::converter::rvalue_from_python_stage1_data* data)
{
    void* storage = (
    (boost::python::converter::rvalue_from_python_storage<QtGuiClass>*)
    data)->storage.bytes;
    SbkObject* result = reinterpret_cast<SbkObject*>(obj_ptr);
    auto _ptr = (QtGuiClass*) (Shiboken::Object::cppPointer(
                                       result,Py_TYPE(result)));
    new (storage) QtGuiClass(*_ptr);
    qDebug() << "__alloc'd " << typeid(*_ptr).name() <<" at "<<_ptr;
    data->convertible = storage;
}
};

以及，从启动函数调用以上内容：

QtGui_from_python<QColor,SBK_QCOLOR_IDX>();