mirror of
https://github.com/yuzu-emu/ext-boost.git
synced 2024-12-23 04:15:36 +00:00
221 lines
6.1 KiB
C++
221 lines
6.1 KiB
C++
// 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 {
|
|
namespace iterators {
|
|
|
|
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::iterators::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 boost::detail::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 iterators
|
|
|
|
using iterators::counting_iterator;
|
|
using iterators::make_counting_iterator;
|
|
|
|
} // namespace boost
|
|
|
|
#endif // COUNTING_ITERATOR_DWA200348_HPP
|