v3/iterator/traits.hpp

0001 /// \file
0002 // Range v3 library
0003 //
0004 //  Copyright Eric Niebler 2013-present
0005 //
0006 //  Use, modification and distribution is subject to the
0007 //  Boost Software License, Version 1.0. (See accompanying
0008 //  file LICENSE_1_0.txt or copy at
0009 //  http://www.boost.org/LICENSE_1_0.txt)
0010 //
0011 // Project home: https://github.com/ericniebler/range-v3
0012 //
0013
0014 #ifndef RANGES_V3_ITERATOR_TRAITS_HPP
0015 #define RANGES_V3_ITERATOR_TRAITS_HPP
0016
0017 #include <iterator>
0018 #include <type_traits>
0019
0020 #include <meta/meta.hpp>
0021
0022 #include <concepts/concepts.hpp>
0023
0024 #include <range/v3/range_fwd.hpp>
0025
0026 #include <range/v3/iterator/access.hpp> // for iter_move, iter_swap
0027 #include <range/v3/utility/common_type.hpp>
0028
0029 #include <range/v3/detail/prologue.hpp>
0030
0031 namespace ranges
0032 {
0033     /// \addtogroup group-iterator
0034     /// @{
0035
0036     /// \cond
0037     using input_iterator_tag RANGES_DEPRECATED(
0038         "Please switch to the standard iterator tags") = std::input_iterator_tag;
0039     using forward_iterator_tag RANGES_DEPRECATED(
0040         "Please switch to the standard iterator tags") = std::forward_iterator_tag;
0041     using bidirectional_iterator_tag RANGES_DEPRECATED(
0042         "Please switch to the standard iterator tags") = std::bidirectional_iterator_tag;
0043     using random_access_iterator_tag RANGES_DEPRECATED(
0044         "Please switch to the standard iterator tags") = std::random_access_iterator_tag;
0045     /// \endcond
0046
0047     struct contiguous_iterator_tag : std::random_access_iterator_tag
0048     {};
0049
0050     /// \cond
0051     namespace detail
0052     {
0053         template<typename I, typename = iter_reference_t<I>,
0054                  typename R = decltype(iter_move(std::declval<I &>())), typename = R &>
0055         using iter_rvalue_reference_t = R;
0056
0057         template<typename I>
0058         RANGES_INLINE_VAR constexpr bool has_nothrow_iter_move_v =
0059             noexcept(iter_rvalue_reference_t<I>(ranges::iter_move(std::declval<I &>())));
0060     } // namespace detail
0061     /// \endcond
0062
0063     template<typename I>
0064     using iter_rvalue_reference_t = detail::iter_rvalue_reference_t<I>;
0065
0066     template<typename I>
0067     using iter_common_reference_t =
0068         common_reference_t<iter_reference_t<I>, iter_value_t<I> &>;
0069
0070 #if defined(RANGES_DEEP_STL_INTEGRATION) && RANGES_DEEP_STL_INTEGRATION && \
0071     !defined(RANGES_DOXYGEN_INVOKED)
0072     template<typename T>
0073     using iter_difference_t =
0074         typename meta::conditional_t<detail::is_std_iterator_traits_specialized_v<T>,
0075                                    std::iterator_traits<uncvref_t<T>>,
0076                                    incrementable_traits<uncvref_t<T>>>::difference_type;
0077 #else
0078     template<typename T>
0079     using iter_difference_t =
0080         typename incrementable_traits<uncvref_t<T>>::difference_type;
0081 #endif
0082
0083     // Defined in <range/v3/iterator/access.hpp>
0084     // template<typename T>
0085     // using iter_value_t = ...
0086
0087     // Defined in <range/v3/iterator/access.hpp>
0088     // template<typename R>
0089     // using iter_reference_t = detail::iter_reference_t_<R>;
0090
0091     // Defined in <range/v3/range_fwd.hpp>:
0092     // template<typename S, typename I>
0093     // inline constexpr bool disable_sized_sentinel = false;
0094
0095     /// \cond
0096     namespace detail
0097     {
0098         template<typename I>
0099         using iter_size_t =
0100             meta::_t<meta::conditional_t<std::is_integral<iter_difference_t<I>>::value,
0101                                std::make_unsigned<iter_difference_t<I>>,
0102                                meta::id<iter_difference_t<I>>>>;
0103
0104         template<typename I>
0105         using iter_arrow_t = decltype(std::declval<I &>().operator->());
0106
0107         template<typename I>
0108         using iter_pointer_t =
0109             meta::_t<meta::conditional_t<
0110                         meta::is_trait<meta::defer<iter_arrow_t, I>>::value,
0111                         meta::defer<iter_arrow_t, I>,
0112                         std::add_pointer<iter_reference_t<I>>>>;
0113
0114         template<typename T>
0115         struct difference_type_ : meta::defer<iter_difference_t, T>
0116         {};
0117
0118         template<typename T>
0119         struct value_type_ : meta::defer<iter_value_t, T>
0120         {};
0121
0122         template<typename T>
0123         struct size_type_ : meta::defer<iter_size_t, T>
0124         {};
0125     } // namespace detail
0126
0127     template<typename T>
0128     using difference_type_t RANGES_DEPRECATED(
0129         "ranges::difference_type_t is deprecated. Please use "
0130         "ranges::iter_difference_t instead.") = iter_difference_t<T>;
0131
0132     template<typename T>
0133     using value_type_t RANGES_DEPRECATED(
0134         "ranges::value_type_t is deprecated. Please use "
0135         "ranges::iter_value_t instead.") = iter_value_t<T>;
0136
0137     template<typename R>
0138     using reference_t RANGES_DEPRECATED(
0139         "ranges::reference_t is deprecated. Use ranges::iter_reference_t "
0140         "instead.") = iter_reference_t<R>;
0141
0142     template<typename I>
0143     using rvalue_reference_t RANGES_DEPRECATED(
0144         "rvalue_reference_t is deprecated; "
0145         "use iter_rvalue_reference_t instead") = iter_rvalue_reference_t<I>;
0146
0147     template<typename T>
0148     struct RANGES_DEPRECATED(
0149         "ranges::size_type is deprecated. Iterators do not have an associated "
0150         "size_type.") size_type : detail::size_type_<T>
0151     {};
0152
0153     template<typename I>
0154     using size_type_t RANGES_DEPRECATED("size_type_t is deprecated.") =
0155         detail::iter_size_t<I>;
0156     /// \endcond
0157
0158     namespace cpp20
0159     {
0160         using ranges::iter_common_reference_t;
0161         using ranges::iter_difference_t;
0162         using ranges::iter_reference_t;
0163         using ranges::iter_rvalue_reference_t;
0164         using ranges::iter_value_t;
0165
0166         // Specialize these in the ranges:: namespace
0167         using ranges::disable_sized_sentinel;
0168         template<typename T>
0169         using incrementable_traits = ranges::incrementable_traits<T>;
0170         template<typename T>
0171         using indirectly_readable_traits = ranges::indirectly_readable_traits<T>;
0172     } // namespace cpp20
0173     /// @}
0174 } // namespace ranges
0175
0176 #include <range/v3/detail/epilogue.hpp>
0177
0178 #endif // RANGES_V3_ITERATOR_TRAITS_HPP