| // (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 |