boost/python/suite/indexing/indexing_suite.hpp
// (C) Copyright Joel de Guzman 2003. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef INDEXING_SUITE_JDG20036_HPP # define INDEXING_SUITE_JDG20036_HPP # include <boost/python/class.hpp> # include <boost/python/def_visitor.hpp> # include <boost/python/register_ptr_to_python.hpp> # include <boost/python/suite/indexing/detail/indexing_suite_detail.hpp> # include <boost/python/return_internal_reference.hpp> # include <boost/python/iterator.hpp> # include <boost/mpl/or.hpp> # include <boost/mpl/not.hpp> # include <boost/type_traits/is_same.hpp> namespace boost { namespace python { // indexing_suite class. This class is the facade class for // the management of C++ containers intended to be integrated // to Python. The objective is make a C++ container look and // feel and behave exactly as we'd expect a Python container. // By default indexed elements are returned by proxy. This can be // disabled by supplying *true* in the NoProxy template parameter. // // Derived classes provide the hooks needed by the indexing_suite // to do its job: // // static data_type& // get_item(Container& container, index_type i); // // static object // get_slice(Container& container, index_type from, index_type to); // // static void // set_item(Container& container, index_type i, data_type const& v); // // static void // set_slice( // Container& container, index_type from, // index_type to, data_type const& v // ); // // template <class Iter> // static void // set_slice(Container& container, index_type from, // index_type to, Iter first, Iter last // ); // // static void // delete_item(Container& container, index_type i); // // static void // delete_slice(Container& container, index_type from, index_type to); // // static size_t // size(Container& container); // // template <class T> // static bool // contains(Container& container, T const& val); // // static index_type // convert_index(Container& container, PyObject* i); // // static index_type // adjust_index(index_type current, index_type from, // index_type to, size_type len // ); // // Most of these policies are self explanatory. convert_index and // adjust_index, however, deserves some explanation. // // convert_index converts an Python index into a C++ index that the // container can handle. For instance, negative indexes in Python, by // convention, indexes from the right (e.g. C[-1] indexes the rightmost // element in C). convert_index should handle the necessary conversion // for the C++ container (e.g. convert -1 to C.size()-1). convert_index // should also be able to convert the type of the index (A dynamic Python // type) to the actual type that the C++ container expects. // // When a container expands or contracts, held indexes to its elements // must be adjusted to follow the movement of data. For instance, if // we erase 3 elements, starting from index 0 from a 5 element vector, // what used to be at index 4 will now be at index 1: // // [a][b][c][d][e] ---> [d][e] // ^ ^ // 4 1 // // adjust_index takes care of the adjustment. Given a current index, // the function should return the adjusted index when data in the // container at index from..to is replaced by *len* elements. // template < class Container , class DerivedPolicies , bool NoProxy = false , bool NoSlice = false , class Data = typename Container::value_type , class Index = typename Container::size_type , class Key = typename Container::value_type > class indexing_suite : public def_visitor< indexing_suite< Container , DerivedPolicies , NoProxy , NoSlice , Data , Index , Key > > { private: typedef mpl::or_< mpl::bool_<NoProxy> , mpl::not_<is_class<Data> > , typename mpl::or_< is_same<Data, std::string> , is_same<Data, std::complex<float> > , is_same<Data, std::complex<double> > , is_same<Data, std::complex<long double> > >::type> no_proxy; typedef detail::container_element<Container, Index, DerivedPolicies> container_element_t; #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) struct return_policy : return_internal_reference<> {}; #else typedef return_internal_reference<> return_policy; #endif typedef typename mpl::if_< no_proxy , iterator<Container> , iterator<Container, return_policy> >::type def_iterator; typedef typename mpl::if_< no_proxy , detail::no_proxy_helper< Container , DerivedPolicies , container_element_t , Index> , detail::proxy_helper< Container , DerivedPolicies , container_element_t , Index> >::type proxy_handler; typedef typename mpl::if_< mpl::bool_<NoSlice> , detail::no_slice_helper< Container , DerivedPolicies , proxy_handler , Data , Index> , detail::slice_helper< Container , DerivedPolicies , proxy_handler , Data , Index> >::type slice_handler; public: template <class Class> void visit(Class& cl) const { // Hook into the class_ generic visitation .def function proxy_handler::register_container_element(); cl .def("__len__", base_size) .def("__setitem__", &base_set_item) .def("__delitem__", &base_delete_item) .def("__getitem__", &base_get_item) .def("__contains__", &base_contains) .def("__iter__", def_iterator()) ; DerivedPolicies::extension_def(cl); } template <class Class> static void extension_def(Class& cl) { // default. // no more extensions } private: static object base_get_item(back_reference<Container&> container, PyObject* i) { if (PySlice_Check(i)) return slice_handler::base_get_slice( container.get(), static_cast<PySliceObject*>(static_cast<void*>(i))); return proxy_handler::base_get_item_(container, i); } static void base_set_item(Container& container, PyObject* i, PyObject* v) { if (PySlice_Check(i)) { slice_handler::base_set_slice(container, static_cast<PySliceObject*>(static_cast<void*>(i)), v); } else { extract<Data&> elem(v); // try if elem is an exact Data if (elem.check()) { DerivedPolicies:: set_item(container, DerivedPolicies:: convert_index(container, i), elem()); } else { // try to convert elem to Data extract<Data> elem(v); if (elem.check()) { DerivedPolicies:: set_item(container, DerivedPolicies:: convert_index(container, i), elem()); } else { PyErr_SetString(PyExc_TypeError, "Invalid assignment"); throw_error_already_set(); } } } } static void base_delete_item(Container& container, PyObject* i) { if (PySlice_Check(i)) { slice_handler::base_delete_slice( container, static_cast<PySliceObject*>(static_cast<void*>(i))); return; } Index index = DerivedPolicies::convert_index(container, i); proxy_handler::base_erase_index(container, index, mpl::bool_<NoSlice>()); DerivedPolicies::delete_item(container, index); } static size_t base_size(Container& container) { return DerivedPolicies::size(container); } static bool base_contains(Container& container, PyObject* key) { extract<Key const&> x(key); // try if key is an exact Key type if (x.check()) { return DerivedPolicies::contains(container, x()); } else { // try to convert key to Key type extract<Key> x(key); if (x.check()) return DerivedPolicies::contains(container, x()); else return false; } } }; }} // namespace boost::python #endif // INDEXING_SUITE_JDG20036_HPP