| // Copyright David Abrahams 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 COUNTING_ITERATOR_DWA200348_HPP |
| # define COUNTING_ITERATOR_DWA200348_HPP |
| |
| # include <boost/iterator/iterator_adaptor.hpp> |
| # include <boost/detail/numeric_traits.hpp> |
| # include <boost/mpl/bool.hpp> |
| # include <boost/mpl/if.hpp> |
| # include <boost/mpl/identity.hpp> |
| # include <boost/mpl/eval_if.hpp> |
| |
| namespace boost { |
| |
| template < |
| class Incrementable |
| , class CategoryOrTraversal |
| , class Difference |
| > |
| class counting_iterator; |
| |
| namespace detail |
| { |
| // Try to detect numeric types at compile time in ways compatible |
| // with the limitations of the compiler and library. |
| template <class T> |
| struct is_numeric_impl |
| { |
| // For a while, this wasn't true, but we rely on it below. This is a regression assert. |
| BOOST_STATIC_ASSERT(::boost::is_integral<char>::value); |
| |
| # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS |
| |
| BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized); |
| |
| # else |
| |
| # if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) |
| BOOST_STATIC_CONSTANT( |
| bool, value = ( |
| boost::is_convertible<int,T>::value |
| && boost::is_convertible<T,int>::value |
| )); |
| # else |
| BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value); |
| # endif |
| |
| # endif |
| }; |
| |
| template <class T> |
| struct is_numeric |
| : mpl::bool_<(::boost::detail::is_numeric_impl<T>::value)> |
| {}; |
| |
| # if defined(BOOST_HAS_LONG_LONG) |
| template <> |
| struct is_numeric< ::boost::long_long_type> |
| : mpl::true_ {}; |
| |
| template <> |
| struct is_numeric< ::boost::ulong_long_type> |
| : mpl::true_ {}; |
| # endif |
| |
| // Some compilers fail to have a numeric_limits specialization |
| template <> |
| struct is_numeric<wchar_t> |
| : mpl::true_ {}; |
| |
| template <class T> |
| struct numeric_difference |
| { |
| typedef typename boost::detail::numeric_traits<T>::difference_type type; |
| }; |
| |
| BOOST_STATIC_ASSERT(is_numeric<int>::value); |
| |
| template <class Incrementable, class CategoryOrTraversal, class Difference> |
| struct counting_iterator_base |
| { |
| typedef typename detail::ia_dflt_help< |
| CategoryOrTraversal |
| , mpl::eval_if< |
| is_numeric<Incrementable> |
| , mpl::identity<random_access_traversal_tag> |
| , iterator_traversal<Incrementable> |
| > |
| >::type traversal; |
| |
| typedef typename detail::ia_dflt_help< |
| Difference |
| , mpl::eval_if< |
| is_numeric<Incrementable> |
| , numeric_difference<Incrementable> |
| , iterator_difference<Incrementable> |
| > |
| >::type difference; |
| |
| typedef iterator_adaptor< |
| counting_iterator<Incrementable, CategoryOrTraversal, Difference> // self |
| , Incrementable // Base |
| , Incrementable // Value |
| # ifndef BOOST_ITERATOR_REF_CONSTNESS_KILLS_WRITABILITY |
| const // MSVC won't strip this. Instead we enable Thomas' |
| // criterion (see boost/iterator/detail/facade_iterator_category.hpp) |
| # endif |
| , traversal |
| , Incrementable const& // reference |
| , difference |
| > type; |
| }; |
| |
| // Template class distance_policy_select -- choose a policy for computing the |
| // distance between counting_iterators at compile-time based on whether or not |
| // the iterator wraps an integer or an iterator, using "poor man's partial |
| // specialization". |
| |
| template <bool is_integer> struct distance_policy_select; |
| |
| // A policy for wrapped iterators |
| template <class Difference, class Incrementable1, class Incrementable2> |
| struct iterator_distance |
| { |
| static Difference distance(Incrementable1 x, Incrementable2 y) |
| { |
| return y - x; |
| } |
| }; |
| |
| // A policy for wrapped numbers |
| template <class Difference, class Incrementable1, class Incrementable2> |
| struct number_distance |
| { |
| static Difference distance(Incrementable1 x, Incrementable2 y) |
| { |
| return numeric_distance(x, y); |
| } |
| }; |
| } |
| |
| template < |
| class Incrementable |
| , class CategoryOrTraversal = use_default |
| , class Difference = use_default |
| > |
| class counting_iterator |
| : public detail::counting_iterator_base< |
| Incrementable, CategoryOrTraversal, Difference |
| >::type |
| { |
| typedef typename detail::counting_iterator_base< |
| Incrementable, CategoryOrTraversal, Difference |
| >::type super_t; |
| |
| friend class iterator_core_access; |
| |
| public: |
| typedef typename super_t::difference_type difference_type; |
| |
| counting_iterator() { } |
| |
| counting_iterator(counting_iterator const& rhs) : super_t(rhs.base()) {} |
| |
| counting_iterator(Incrementable x) |
| : super_t(x) |
| { |
| } |
| |
| # if 0 |
| template<class OtherIncrementable> |
| counting_iterator( |
| counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& t |
| , typename enable_if_convertible<OtherIncrementable, Incrementable>::type* = 0 |
| ) |
| : super_t(t.base()) |
| {} |
| # endif |
| |
| private: |
| |
| typename super_t::reference dereference() const |
| { |
| return this->base_reference(); |
| } |
| |
| template <class OtherIncrementable> |
| difference_type |
| distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const |
| { |
| typedef typename mpl::if_< |
| detail::is_numeric<Incrementable> |
| , detail::number_distance<difference_type, Incrementable, OtherIncrementable> |
| , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable> |
| >::type d; |
| |
| return d::distance(this->base(), y.base()); |
| } |
| }; |
| |
| // Manufacture a counting iterator for an arbitrary incrementable type |
| template <class Incrementable> |
| inline counting_iterator<Incrementable> |
| make_counting_iterator(Incrementable x) |
| { |
| typedef counting_iterator<Incrementable> result_t; |
| return result_t(x); |
| } |
| |
| |
| } // namespace boost::iterator |
| |
| #endif // COUNTING_ITERATOR_DWA200348_HPP |