- 
|
@@ -363,16 +372,48 @@ namespace boost { namespace python { namespace indexing {
- enum IndexStyle
+ enum index_style_t
|
@@ -1017,7 +1058,7 @@ namespace boost { namespace python { namespace indexing {
The following block of code shows a simplistic implementation of
ContainerTraits for the container
- std::set<std::string, int>. The actual
+ std::map<std::string, int>. The actual
implementation used by the suite relies on template
metaprogramming techniques, whereas this example is designed to
show only the essential elements of a
@@ -1030,7 +1071,7 @@ namespace boost { namespace python { namespace indexing {
#include <map>
#include <string>
#include <boost/python/suite/indexing/iterator_traits.hpp>
-// Include iterator_traits to get IndexStyle
+// Include iterator_traits to get index_style_t
struct simple_map_traits {
// Traits information for std::map<std::string, int>
@@ -1057,7 +1098,7 @@ struct simple_map_traits {
static bool const has_push_back = false;
static bool const is_reorderable = false;
- static boost::python::indexing::IndexStyle const index_style
+ static boost::python::indexing::index_style_t const index_style
= boost::python::indexing::index_style_nonlinear;
struct value_traits_ {
@@ -1093,11 +1134,11 @@ struct simple_map_traits {
BOOST_PYTHON_MODULE(test_simple) {
using namespace boost::python;
- typedef std::map<std::string, int> Container;
- typedef indexing::map_algorithms<simple_map_traits> Algorithms;
+ typedef std::map<std::string, int> container_t;
+ typedef indexing::map_algorithms<simple_map_traits> algorithms_t;
- class_<Container> ("map")
- .def (indexing::container_suite<Container, Algorithms>());
+ class_<container_t> ("map")
+ .def (indexing::container_suite<container_t, algorithms_t>());
}
@@ -1114,7 +1155,7 @@ BOOST_PYTHON_MODULE(test_simple) {
interfaces to the functions can vary to some extent, since the
def function calls used internally by the
visitor deduce the function type
- automatically. However, certain points must be confomed to:
+ automatically. However, certain points should be confomed to:
|
+
+ The default_algorithms template attempts to place
+ as few restrictions as possible on the container type, by using
+ iterators and standard algorithms in most of its functions. It
+ accepts an optional second template parameter, which can be used
+ via the curiously recurring template idiom to replace any of its
+ functions that it relies on internally. For instance, if you've
+ created an iterator-style interface to a container that is not
+ at all STL-like (let's call it weird_container),
+ you might be able to re-use most of
+ default_algorithms by replacing its basic functions
+ like this:
+
+
+
+namespace indexing = boost::python::indexing;
+
+struct my_algorithms
+ : public indexing::default_algorithms <
+ weird_container_traits, my_algorithms
+ >
+{
+ size_t size (weird_container const &c) {
+ return ...;
+ }
+
+ my_iterator_t begin (weird_container &c) {
+ return ...;
+ }
+
+ my_iterator_t end (weird_container &c) {
+ return ...;
+ }
+};
+
+
+
+ SliceHelper
+ +
+
+ Support code for Python slices is split into two portions, the
+ slice_handler template, and a "slice helper" that
+ can easily be replaced by client code via a typedef and factory
+ function in the Algorithms argument supplied to
+ container_suite. The slice helper object takes care
+ of reading and writing elements from a slice in a C++ container,
+ and optionally insertion and deletion. Effectively, the slice
+ helper object maintains a pointer to the current element of the
+ slice within the container, and provides a next
+ function to advance to the next element of the slice. The
+ container suite uses the following interface for slices:
+
+
+
| + + Expression + + | ++ + Return type + + | ++ + Notes + + | +
|---|---|---|
+
+ Algorithms::
+make_slice_helper
+(c, s)
+
+ |
+
+
+ Algorithms::
+slice_helper
+
+ |
+
+
+ Returns a newly constructed slice_helper
+ object by value, where c is of type
+ Algorithms::container & and s is
+ of type indexing::slice const &.
+
+ |
+
+
+ slice_helper.
+next()
+
+ |
+
+
+ bool
+
+ |
+ + + Advances the slice helper's current element pointer to the + next element of the slice. Returns true if such an element + exists, and false otherwise. The first time this function + is called, it should set the current pointer to the first + element of the slice (if any). + + | +
+
+ slice_helper.
+current()
+
+ |
+
+
+ Algorithms::
+reference
+
+ |
+
+
+ Returns a reference to the current element of the
+ slice. This will only be called after a prior successful
+ call to next().
+
+ |
+
+
+ slice_helper.
+write (v)
+
+ |
+
+
+ void
+
+ |
+
+
+ Advances to the next element of the slice, as defined in
+ next, and writes the given value
+ v at the new location in the
+ container. v will be convertible to
+ Algorthims::value_param. If the slice is
+ exhausted (i.e. next would return false) then
+ write either inserts the value into
+ the container at the next location (past the end of the
+ slice), or sets a Python exception and throws.
+
+ |
+
+
+ slice_helper.
+erase_remaining()
+
+ |
+
+
+ void
+
+ |
+
+
+ Either erases any remaining elements in the slice
+ not already consumed by calls to next or
+ write,
+ or sets a Python exception and throws.
+
+ |
+
+
+ The container suite provides a generic implementation of the
+ SliceHelper requirements for containers that have
+ integer-like indexes. It is parameterized with a
+ SliceType parameter that allows the integer index
+ values to come from various different sources, the default being
+ the PySlice_GetIndices function. Refer to the
+ header file int_slice_helper.hpp
+ and the references to it in the algorithms.hpp
+ header for details.
+
container_proxy
@@ -1400,6 +1672,9 @@ namespace boost { namespace python { namespace indexing { + +Synopsis: boost/python/suite/indexing/container_proxy.hpp
+
namespace boost { namespace python { namespace indexing {
template<class Container
@@ -1570,34 +1845,47 @@ namespace boost { namespace python { namespace indexing {