1

我正在尝试将 C++ 容器暴露给 Python。我有：

class Container {
    std::auto_ptr<Iterator> __iter__();
};

class Iterator {
    Container & parent;
    Item __next__();
};

class Item {
    Container & parent;
};

Item类在内部引用存在于 Container 中的数据。Iterator返回Item的实例不必存在Item即可使用。

c = Container()
for i in c:
    store = i

print store

在上面的代码中，我希望得到Container,Iterator和几个Item实例。当它到达print语句时，我希望Iterator它已经被破坏，但Container实例显然仍然存在store。

现在问题来了。我不知道CallPolicy用什么来达到这个效果：定义：

class_<Container>("Container", ...)
  .def("__iter__", &Container::__iter__, return_interal_reference<>() )
;

class_<Iterator>("Iterator", ...)
  .def("next", &Iterator::__next__, what_call_policy_here? )
;

class_<Item>("Item", ...)
  .def("__str__", ... )
;

我应该用什么代替what_call_policy_here？

4

1 回答 1

2

好的，经过长时间的挖掘，我想我想出了对暴露类型透明的解决方案。

简短的介绍

基本上解决方案是创建CallPolicy将自动存储对返回的子对象（即）内的父对象（即）的引用作为其属性（我使用了一个私有名称，但 Python 在这方面非常自由）。ContainerIterator

然后自动将其复制到所有兄弟对象（兄弟是parent的另一个孩子，但是是通过调用另一个孩子的方法创建的，所以不是直接来自parent）。

执行

这需要对CallPolicy. 我必须创建两个自定义的：

// This policy is used for methods returning items that require object to be
// kept as long as return thing is alive.
// It stores reference in attribute named Property_::name
template <typename Property_, class BasePolicy_ = boost::python::default_call_policies>
struct store_parent_reference: public BasePolicy_
{
    template <class ArgumentPackage>
    static PyObject* postcall(ArgumentPackage const& args_, PyObject* result)
    {
        result = BasePolicy_::postcall(args_, result);

        PyObject* parent = detail::get_prev< std::size_t(1) >::execute(args_, result);
        PyObject* child = result;

        if( PyObject_SetAttrString( child, Property_::name, parent ) == -1 )
        {
            std::ostringstream err;
            err << "store_parent_reference::postcall could not set attribute `"                    << Property_::name
                << "` on newly allocated object `"
                << extract<std::string>( object( handle<>(borrowed(child))).attr("__str__")() )()
                << "`";
            throw std::runtime_error(err.str());
        }



        return result;
    }
};


// This policy is used for methods returning "sibling" in the meaning both the returned object
// and one that has this method called on require "parent" object to be alive.
//
// It copies reference to "parent" to attribute named ChildProperty_::name
// from "original" object's attribute named SiblingProperty_::name
template <typename ChildProperty_, typename SiblingProperty_ = ChildProperty_, class BasePolicy_ = boost::python::default_call_policies>
struct copy_parent_from_sibling: public BasePolicy_
{
    template <class ArgumentPackage>
    static PyObject* postcall(ArgumentPackage const& args_, PyObject* result)
    {
        result = BasePolicy_::postcall(args_, result);

        PyObject* sibling = detail::get_prev< std::size_t(1) >::execute(args_, result);
        PyObject* new_child = result;

        PyObject* parent = PyObject_GetAttrString( sibling, SiblingProperty_::name );

        if( parent == NULL )
        {
            std::ostringstream err;
            err << "copy_parent_from_sibling::postcall could not get attribute `"
                << SiblingProperty_::name
                << "` from sibling `"
                << extract<std::string>( object( handle<>(borrowed(sibling))).attr("__str__")() )()
                << "` to set up attribute `"
                << ChildProperty_::name
                << "` of returned object which is `"
                << extract<std::string>( object( handle<>(borrowed(new_child))).attr("__str__")() )()
                << "`";
            throw std::runtime_error(err.str());
        }

        if( PyObject_SetAttrString( new_child, ChildProperty_::name, parent ) == -1 )
        {
            std::ostringstream err;
            err << "copy_parent_from_sibling::postcall could not set attribute `"
                << ChildProperty_::name
                << "` on returned object which is `"
                << extract<std::string>( object( handle<>(borrowed(new_child))).attr("__str__")() )()
                << "`";
            throw std::runtime_error(err.str());
        }

        Py_DECREF(parent);

        return result;
    }
};

用法

现在的用法：

struct ContainerProperty {
    static const char * const name;
};
const char * const ContainerProperty::name = "__container"

class_<Container>("Container", ...)
    .def("__iter__", &Container::__iter__, store_parent_reference< ContainerProperty >() )
;

class_<Iterator>("Iterator", ...)
    .def("next", &Iterator::__next__, copy_parent_from_sibling< ContainerProperty >() )
;

class_<Item>("Item", ...)
;

注意：很难给出完整的最小工作示例boost::python，所以我可能错过了上面的一些细节，但解决方案对我来说似乎工作正常（我正在跟踪析构函数调用以进行检查）。

这也不是唯一的解决方案。请注意，这store_parent_reference有点类似于return_internal_reference它明确需要一个存储数据的地方。这只是因为copy_parent_from_sibling需要从某个地方复制它。

这种方法的主要好处是它不需要原始类来了解 Python 的东西。

于 2012-11-28T14:49:39.590 回答