iterator.h

Go to the documentation of this file.

 
#pragma once
 
#include <iterator>
 
namespace emlabcpp
{
 
template < typename Derived >
concept nothrow_dereference = requires( Derived d ) {
        { *d } noexcept;
};
 
template < typename Derived >
concept nothrow_add_assign = requires( Derived d ) {
        { d += 1 } noexcept;
};
 
template < typename Derived >
concept nothrow_sub_assign = requires( Derived d ) {
        { d -= 1 } noexcept;
};
 
template < typename Derived >
concept nothrow_threeway_compare = requires( Derived d ) {
        { d <=> d } noexcept;
};
 
template < typename Derived >
concept nothrow_equality_compare = requires( Derived d ) {
        { d == d } noexcept;
};
 
 
template < typename Derived >
struct generic_iterator;
 
template < typename Derived >
class generic_iterator_base
{
        [[nodiscard]] constexpr Derived& impl() noexcept
        {
                return static_cast< Derived& >( *this );
        }
 
        [[nodiscard]] constexpr Derived const& impl() const noexcept
        {
                return static_cast< Derived const& >( *this );
        }
 
        generic_iterator_base() noexcept = default;
        friend Derived;
        friend generic_iterator< Derived >;
 
public:
        using value_type        = typename std::iterator_traits< Derived >::value_type;
        using pointer           = typename std::iterator_traits< Derived >::pointer;
        using const_pointer     = typename std::iterator_traits< Derived >::const_pointer;
        using iterator_category = typename std::iterator_traits< Derived >::iterator_category;
        using reference         = typename std::iterator_traits< Derived >::reference;
        using const_reference   = reference const;
        using difference_type   = typename std::iterator_traits< Derived >::difference_type;
 
        constexpr pointer operator->() noexcept( nothrow_dereference< Derived > )
        {
                return &*impl();
        }
 
        constexpr const_pointer operator->() const noexcept( nothrow_dereference< Derived > )
        {
                return &*impl();
        }
};
 
template < typename Derived >
requires( std::same_as<
          typename std::iterator_traits< Derived >::iterator_category,
          std::random_access_iterator_tag > )
struct generic_iterator< Derived > : public generic_iterator_base< Derived >
{
        using generic_iterator_base< Derived >::impl;
 
        using difference_type = typename std::iterator_traits< Derived >::difference_type;
 
        constexpr Derived& operator++() noexcept( nothrow_add_assign< Derived > )
        {
                impl() += 1;
                return impl();
        }
 
        constexpr Derived operator++( int const ) noexcept(
            nothrow_add_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                impl() += 1;
                return copy;
        }
 
        constexpr Derived& operator--() noexcept( nothrow_sub_assign< Derived > )
        {
                impl() -= 1;
                return impl();
        }
 
        constexpr Derived operator--( int const ) noexcept(
            nothrow_sub_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                impl() -= 1;
                return copy;
        }
 
        constexpr Derived operator+( difference_type v ) const noexcept(
            nothrow_add_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                copy += v;
                return copy;
        }
 
        constexpr Derived operator-( difference_type v ) const noexcept(
            nothrow_sub_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                copy -= v;
                return copy;
        }
};
 
template < typename Derived >
requires( std::same_as<
          typename std::iterator_traits< Derived >::iterator_category,
          std::bidirectional_iterator_tag > )
struct generic_iterator< Derived > : public generic_iterator_base< Derived >
{
        using generic_iterator_base< Derived >::impl;
 
        constexpr Derived operator++( int const ) noexcept(
            nothrow_add_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                ++impl();
                return copy;
        }
 
        constexpr Derived operator--( int const ) noexcept(
            nothrow_sub_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                --impl();
                return copy;
        }
};
 
template < typename Derived >
requires( std::same_as<
          typename std::iterator_traits< Derived >::iterator_category,
          std::input_iterator_tag > )
struct generic_iterator< Derived > : public generic_iterator_base< Derived >
{
        using generic_iterator_base< Derived >::impl;
 
        constexpr Derived operator++( int const ) noexcept(
            nothrow_add_assign< Derived > && std::is_nothrow_copy_constructible_v< Derived > )
        {
                auto copy = impl();
                ++impl();
                return copy;
        }
};
 
}  // namespace emlabcpp