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