normal.hxx

Go to the documentation of this file.

// -*- C++ -*- Header compatibility <normal.hxx>
 
 
#ifndef CORTEX_NORMAL_ITERATOR
#   define CORTEX_NORMAL_ITERATOR
 
#include <iterator> 
#include <ranges>
#include <type_traits>
#include <utility>
 
#if __cpp_lib_three_way_comparison
#    include <compare>
#endif  //< __cpp_lib_three_way_comparison
 
#if __cpp_concepts >= 201907L
#    include <concepts>
#endif  //< __cpp_concepts >= 201907L
 
namespace cxl
{
    template<typename Iterator, typename Container>
    class normal_iterator
    {
    protected:
        Iterator current;
 
        using iter_traits_type      = std::iterator_traits<Iterator>;
 
    public:
        using iterator_type         = Iterator;
        using iterator_category     = typename iter_traits_type::iterator_category;
 
#    if __cpp_concepts >= 201907L
        using iterator_concept = std::conditional_t<
            std::random_access_iterator<Iterator>,
            std::random_access_iterator_tag,
            std::conditional_t<
                std::bidirectional_iterator<Iterator>,
                std::bidirectional_iterator_tag,
                std::conditional_t<
                    std::forward_iterator<Iterator>,
                    std::forward_iterator_tag,
                    std::conditional_t<std::input_iterator<Iterator>,
                                       std::input_iterator_tag,
                                       std::output_iterator_tag>>>>;
#    endif  //< __cpp_concepts >= 201907L
 
        using value_type            = typename iter_traits_type::value_type;
        using difference_type       = typename iter_traits_type::difference_type;
        using pointer               = typename iter_traits_type::pointer;
        using reference             = typename iter_traits_type::reference;
 
public:
        constexpr
        normal_iterator() noexcept
            : current{ Iterator{} } 
        { }
 
        template<typename Iter>
            requires std::convertible_to<Iter, Iterator>
        constexpr
        normal_iterator(const normal_iterator<Iter, Container>& other) noexcept
            : current{ other.base() } 
        { }
 
        constexpr
        normal_iterator(const iterator_type& other) noexcept
            : current{ other } 
        { }
 
 
        constexpr auto
        operator* () noexcept -> reference 
        { return *current; }
 
        constexpr auto
        operator* () const noexcept -> reference 
        { return *current; }
 
        constexpr auto
        operator->() noexcept -> pointer
#    if __cplusplus > 201703L && __cpp_concepts >= 201907L
            requires std::is_pointer_v<iterator_type> ||
            requires (const iterator_type i) { i.operator->(); }
#    endif  //< __cplusplus > 201703L && __cpp_concepts >= 201907L
        { return _S_to_pointer(current); }
 
        constexpr auto
        operator->() const noexcept -> pointer
#    if __cplusplus > 201703L && __cpp_concepts >= 201907L
            requires std::is_pointer_v<iterator_type> ||
            requires (const iterator_type i) { i.operator->(); }
#    endif  //< __cplusplus > 201703L && __cpp_concepts >= 201907L
        { return _S_to_pointer(current); }
 
        constexpr auto
        operator++ () noexcept -> normal_iterator& 
        {
            ++current;
            return *this;
        }
 
        constexpr auto
        operator++ (int) noexcept -> normal_iterator 
        { return normal_iterator(current++); }
 
        constexpr auto
        operator-- () noexcept -> normal_iterator& 
        {
            --current;
            return *this;
        }
 
        constexpr auto
        operator-- (int) noexcept -> normal_iterator 
        { return normal_iterator(current--); }
 
        constexpr auto
        operator[] (difference_type n) noexcept -> reference 
        { return current[n]; }
 
        constexpr auto
        operator+= (difference_type step) noexcept
            -> normal_iterator& 
        {
            current += step;
            return *this;
        }
 
        constexpr auto
        operator-= (difference_type step) noexcept
            -> normal_iterator& 
        {
            current -= step;
            return *this;
        }
 
        constexpr auto
        operator+ (difference_type step) const noexcept
            -> normal_iterator 
        { return normal_iterator(current + step); }
 
        constexpr auto
        operator- (difference_type step) const noexcept
            -> normal_iterator 
        { return normal_iterator(current - step); }
 
        constexpr auto
        base() const noexcept -> iterator_type 
        { return current; }
 
    private:
        template<typename P>
        static constexpr auto
        _S_to_pointer(P* ptr) -> P* 
        { return ptr; }
 
        template<typename P>
        static constexpr auto
        _S_to_pointer(P obj) -> pointer 
        { return obj.operator->(); }
 
    };  //< class normal_iterator
 
#    if __cpp_lib_three_way_comparison  //< C++20
 
    template<typename IterL, typename IterR, typename Container>
        requires requires (IterL lhsI, IterR rhsI) 
            { { lhsI == rhsI } -> std::convertible_to<bool>; }
    constexpr auto
    operator== (const normal_iterator<IterL, Container>& lhs,
                const normal_iterator<IterR, Container>& rhs) 
        noexcept(noexcept(lhs.base() == rhs.base())) -> bool 
    { return lhs.base() == rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
        requires std::three_way_comparable_with<IterL, IterR, std::weak_ordering>
    constexpr auto
    operator<=> (const normal_iterator<IterL, Container>& lhs,
                 const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() <=> rhs.base())) -> std::weak_ordering 
    { return lhs.base() <=> rhs.base(); }
 
#    else  //< __cpp_lib_three_way_comparison -> C++20
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator== (const normal_iterator<IterL, Container>& lhs,
                const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() == rhs.base())) -> bool 
    { return lhs.base() == rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator== (const normal_iterator<Iterator, Container>& lhs,
                const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() == rhs.base())) -> bool
    { return lhs.base() == rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator!= (const normal_iterator<IterL, Container>& lhs,
                const normal_iterator<IterR, Container>& rhs) 
        noexcept(noexcept(lhs.base() != rhs.base())) -> bool 
    { return lhs.base() != rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator!= (const normal_iterator<Iterator, Container>& lhs,
                const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() != rhs.base())) -> bool 
    { return lhs.base() != rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator<(const normal_iterator<IterL, Container>& lhs,
              const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() < rhs.base())) -> bool 
    { return lhs.base() < rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator<(const normal_iterator<Iterator, Container>& lhs,
              const normal_iterator<Iterator, Container>& rhs) 
        noexcept(noexcept(lhs.base() < rhs.base())) -> bool 
    { return lhs.base() < rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator> (const normal_iterator<IterL, Container>& lhs,
               const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() > rhs.base())) -> bool 
    { return lhs.base() > rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator> (const normal_iterator<Iterator, Container>& lhs,
               const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() > rhs.base())) -> bool 
    { return lhs.base() > rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator<= (const normal_iterator<IterL, Container>& lhs,
                const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() <= rhs.base())) -> bool 
    { return lhs.base() <= rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator<= (const normal_iterator<Iterator, Container>& lhs,
                const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() <= rhs.base())) -> bool 
    { return lhs.base() <= rhs.base(); }
 
    template<typename IterL, typename IterR, typename Container>
    constexpr inline auto
    operator>= (const normal_iterator<IterL, Container>& lhs,
                const normal_iterator<IterR, Container>& rhs)
        noexcept(noexcept(lhs.base() >= rhs.base())) -> bool 
    { return lhs.base() >= rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline bool
    operator>= (const normal_iterator<Iterator, Container>& lhs,
                const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() >= rhs.base())) ->bool 
    { return lhs.base() >= rhs.base(); }
 
#    endif  //< __cpp_lib_three_way_comparison
 
    template<typename IterL, typename IterR, typename Container>
#    if __cplusplus >= 201103L  
    constexpr inline auto
    operator- (const normal_iterator<IterL, Container>& lhs,
               const normal_iterator<IterR, Container>& rhs) 
        noexcept(noexcept(lhs.base() - rhs.base())) 
        -> decltype(lhs.base() - rhs.base())
#    else   
    inline typename normal_iterator<IterL, Container>::difference_type
    operator- (const normal_iterator<IterL, Container>& lhs,
               const normal_iterator<IterR, Container>& rhs)
#    endif  //< __cplusplus >= 201103L
    { return lhs.base() - rhs.base(); }
 
    template<typename Iterator, typename Container>
#    if __cplusplus >= 201103L  
    constexpr inline auto
    operator- (const normal_iterator<Iterator, Container>& lhs,
               const normal_iterator<Iterator, Container>& rhs)
        noexcept(noexcept(lhs.base() - rhs.base()))
        -> decltype(lhs.base() - rhs.base())
#    else   //< ! C++11
    inline
        typename normal_iterator<Iterator, Container>::difference_type
        operator- (const normal_iterator<Iterator, Container>& lhs,
                   const normal_iterator<Iterator, Container>& rhs)
#    endif  //< __cplusplus >= 201103L
    { return lhs.base() - rhs.base(); }
 
    template<typename Iterator, typename Container>
    constexpr inline auto
    operator+ (typename normal_iterator<Iterator, Container>::difference_type n,
               const normal_iterator<Iterator, Container>& i) noexcept
        -> normal_iterator<Iterator, Container> 
    { return normal_iterator<Iterator, Container>(i.base() + n); }
 
    template<typename Container>
    constexpr auto
    make_normal_iterator(typename Container::iterator i) noexcept
        -> normal_iterator<typename Container::iterator, Container> 
    { return normal_iterator<typename Container::iterator, Container>(i); }
 
    template<typename Iterator, typename Container>
    constexpr auto
    make_normal_iterator(Iterator i) noexcept
        -> normal_iterator<Iterator, Container> 
    { return normal_iterator<Iterator, Container>(i); }
 
}  //< namespace cxl
 
namespace std
{
 
    template<typename Iterator, typename Container>
    constexpr auto
    iter_move(const cxl::normal_iterator<Iterator, Container>& i) 
        noexcept( 
            is_nothrow_copy_constructible_v<Iterator> 
         && noexcept(ranges::iter_move(declval<Iterator&>()))
        ) -> iter_rvalue_reference_t<Iterator> 
    { return ranges::iter_move(i.base()); }
 
    template<typename Iterator, std::indirectly_swappable<Iterator> Iter2, typename Container>
    constexpr auto
    iter_swap(const cxl::normal_iterator<Iterator, Container>& x,
              const cxl::normal_iterator<Iter2, Container>& y) 
        noexcept(
            std::is_nothrow_copy_constructible_v<Iterator>
         && std::is_nothrow_copy_constructible_v<Iter2>
         && noexcept(ranges::iter_swap(std::declval<Iterator&>(), std::declval<Iter2&>()))
        ) -> void 
    { ranges::iter_swap(x.base(), y.base()); }
 
}  //< namespace std
 
#endif  //< CORTEX_NORMAL_ITERATOR