--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ossrv_pub/boost_apis/boost/python/slice.hpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,266 @@
+#ifndef BOOST_PYTHON_SLICE_JDB20040105_HPP
+#define BOOST_PYTHON_SLICE_JDB20040105_HPP
+
+// Copyright (c) 2004 Jonathan Brandmeyer
+// Use, modification and distribution are subject to 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)
+
+#include <boost/python/detail/prefix.hpp>
+#include <boost/config.hpp>
+#include <boost/python/object.hpp>
+#include <boost/python/extract.hpp>
+#include <boost/python/converter/pytype_object_mgr_traits.hpp>
+
+#include <boost/iterator/iterator_traits.hpp>
+
+#include <iterator>
+#include <algorithm>
+
+namespace boost { namespace python {
+
+namespace detail
+{
+ class BOOST_PYTHON_DECL slice_base : public object
+ {
+ public:
+ // Get the Python objects associated with the slice. In principle, these
+ // may be any arbitrary Python type, but in practice they are usually
+ // integers. If one or more parameter is ommited in the Python expression
+ // that created this slice, than that parameter is None here, and compares
+ // equal to a default-constructed boost::python::object.
+ // If a user-defined type wishes to support slicing, then support for the
+ // special meaning associated with negative indicies is up to the user.
+ object start() const;
+ object stop() const;
+ object step() const;
+
+ protected:
+ explicit slice_base(PyObject*, PyObject*, PyObject*);
+
+ BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(slice_base, object)
+ };
+}
+
+class slice : public detail::slice_base
+{
+ typedef detail::slice_base base;
+ public:
+ // Equivalent to slice(::)
+ slice() : base(0,0,0) {}
+
+ // Each argument must be slice_nil, or implicitly convertable to object.
+ // They should normally be integers.
+ template<typename Integer1, typename Integer2>
+ slice( Integer1 start, Integer2 stop)
+ : base( object(start).ptr(), object(stop).ptr(), 0 )
+ {}
+
+ template<typename Integer1, typename Integer2, typename Integer3>
+ slice( Integer1 start, Integer2 stop, Integer3 stride)
+ : base( object(start).ptr(), object(stop).ptr(), object(stride).ptr() )
+ {}
+
+ // The following algorithm is intended to automate the process of
+ // determining a slice range when you want to fully support negative
+ // indicies and non-singular step sizes. Its functionallity is simmilar to
+ // PySlice_GetIndicesEx() in the Python/C API, but tailored for C++ users.
+ // This template returns a slice::range struct that, when used in the
+ // following iterative loop, will traverse a slice of the function's
+ // arguments.
+ // while (start != end) {
+ // do_foo(...);
+ // std::advance( start, step);
+ // }
+ // do_foo(...); // repeat exactly once more.
+
+ // Arguments: a [begin, end) pair of STL-conforming random-access iterators.
+
+ // Return: slice::range, where start and stop define a _closed_ interval
+ // that covers at most [begin, end-1] of the provided arguments, and a step
+ // that is non-zero.
+
+ // Throws: error_already_set() if any of the indices are neither None nor
+ // integers, or the slice has a step value of zero.
+ // std::invalid_argument if the resulting range would be empty. Normally,
+ // you should catch this exception and return an empty sequence of the
+ // appropriate type.
+
+ // Performance: constant time for random-access iterators.
+
+ // Rationale:
+ // closed-interval: If an open interval were used, then for a non-singular
+ // value for step, the required state for the end iterator could be
+ // beyond the one-past-the-end postion of the specified range. While
+ // probably harmless, the behavior of STL-conforming iterators is
+ // undefined in this case.
+ // exceptions on zero-length range: It is impossible to define a closed
+ // interval over an empty range, so some other form of error checking
+ // would have to be used by the user to prevent undefined behavior. In
+ // the case where the user fails to catch the exception, it will simply
+ // be translated to Python by the default exception handling mechanisms.
+
+ template<typename RandomAccessIterator>
+ struct range
+ {
+ RandomAccessIterator start;
+ RandomAccessIterator stop;
+ typename iterator_difference<RandomAccessIterator>::type step;
+ };
+
+ template<typename RandomAccessIterator>
+ slice::range<RandomAccessIterator>
+ get_indicies( const RandomAccessIterator& begin,
+ const RandomAccessIterator& end) const
+ {
+ // This is based loosely on PySlice_GetIndicesEx(), but it has been
+ // carefully crafted to ensure that these iterators never fall out of
+ // the range of the container.
+ slice::range<RandomAccessIterator> ret;
+
+ typedef typename iterator_difference<RandomAccessIterator>::type difference_type;
+ difference_type max_dist = boost::detail::distance(begin, end);
+
+ object slice_start = this->start();
+ object slice_stop = this->stop();
+ object slice_step = this->step();
+
+ // Extract the step.
+ if (slice_step == object()) {
+ ret.step = 1;
+ }
+ else {
+ ret.step = extract<long>( slice_step);
+ if (ret.step == 0) {
+ PyErr_SetString( PyExc_IndexError, "step size cannot be zero.");
+ throw_error_already_set();
+ }
+ }
+
+ // Setup the start iterator.
+ if (slice_start == object()) {
+ if (ret.step < 0) {
+ ret.start = end;
+ --ret.start;
+ }
+ else
+ ret.start = begin;
+ }
+ else {
+ difference_type i = extract<long>( slice_start);
+ if (i >= max_dist && ret.step > 0)
+ throw std::invalid_argument( "Zero-length slice");
+ if (i >= 0) {
+ ret.start = begin;
+ BOOST_USING_STD_MIN();
+ std::advance( ret.start, min BOOST_PREVENT_MACRO_SUBSTITUTION(i, max_dist-1));
+ }
+ else {
+ if (i < -max_dist && ret.step < 0)
+ throw std::invalid_argument( "Zero-length slice");
+ ret.start = end;
+ // Advance start (towards begin) not farther than begin.
+ std::advance( ret.start, (-i < max_dist) ? i : -max_dist );
+ }
+ }
+
+ // Set up the stop iterator. This one is a little trickier since slices
+ // define a [) range, and we are returning a [] range.
+ if (slice_stop == object()) {
+ if (ret.step < 0) {
+ ret.stop = begin;
+ }
+ else {
+ ret.stop = end;
+ std::advance( ret.stop, -1);
+ }
+ }
+ else {
+ difference_type i = extract<long>(slice_stop);
+ // First, branch on which direction we are going with this.
+ if (ret.step < 0) {
+ if (i+1 >= max_dist || i == -1)
+ throw std::invalid_argument( "Zero-length slice");
+
+ if (i >= 0) {
+ ret.stop = begin;
+ std::advance( ret.stop, i+1);
+ }
+ else { // i is negative, but more negative than -1.
+ ret.stop = end;
+ std::advance( ret.stop, (-i < max_dist) ? i : -max_dist);
+ }
+ }
+ else { // stepping forward
+ if (i == 0 || -i >= max_dist)
+ throw std::invalid_argument( "Zero-length slice");
+
+ if (i > 0) {
+ ret.stop = begin;
+ std::advance( ret.stop, (std::min)( i-1, max_dist-1));
+ }
+ else { // i is negative, but not more negative than -max_dist
+ ret.stop = end;
+ std::advance( ret.stop, i-1);
+ }
+ }
+ }
+
+ // Now the fun part, handling the possibilites surrounding step.
+ // At this point, step has been initialized, ret.stop, and ret.step
+ // represent the widest possible range that could be traveled
+ // (inclusive), and final_dist is the maximum distance covered by the
+ // slice.
+ typename iterator_difference<RandomAccessIterator>::type final_dist =
+ boost::detail::distance( ret.start, ret.stop);
+
+ // First case, if both ret.start and ret.stop are equal, then step
+ // is irrelevant and we can return here.
+ if (final_dist == 0)
+ return ret;
+
+ // Second, if there is a sign mismatch, than the resulting range and
+ // step size conflict: std::advance( ret.start, ret.step) goes away from
+ // ret.stop.
+ if ((final_dist > 0) != (ret.step > 0))
+ throw std::invalid_argument( "Zero-length slice.");
+
+ // Finally, if the last step puts us past the end, we move ret.stop
+ // towards ret.start in the amount of the remainder.
+ // I don't remember all of the oolies surrounding negative modulii,
+ // so I am handling each of these cases separately.
+ if (final_dist < 0) {
+ difference_type remainder = -final_dist % -ret.step;
+ std::advance( ret.stop, remainder);
+ }
+ else {
+ difference_type remainder = final_dist % ret.step;
+ std::advance( ret.stop, -remainder);
+ }
+
+ return ret;
+ }
+
+ public:
+ // This declaration, in conjunction with the specialization of
+ // object_manager_traits<> below, allows C++ functions accepting slice
+ // arguments to be called from from Python. These constructors should never
+ // be used in client code.
+ BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(slice, detail::slice_base)
+};
+
+
+namespace converter {
+
+template<>
+struct object_manager_traits<slice>
+ : pytype_object_manager_traits<&PySlice_Type, slice>
+{
+};
+
+} // !namesapce converter
+
+} } // !namespace ::boost::python
+
+
+#endif // !defined BOOST_PYTHON_SLICE_JDB20040105_HPP