inherited_iterator_base.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2022 deCODE Genetics
// Copyright (c) 2006-2020, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2020, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/biocpp/biocpp-core/blob/main/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <cassert>
#include <iterator>
#include <type_traits>
 
#include <bio/meta/detail/empty_type.hpp>
#include <bio/ranges/type_traits.hpp>
 
namespace bio::ranges::detail
{
 
template <typename derived_t, std::input_or_output_iterator base_t>
class inherited_iterator_base :
  public std::conditional_t<std::is_pointer_v<base_t> || !std::semiregular<base_t>, meta::detail::empty_type, base_t>
{
private:
    static constexpr bool wrap_base = std::is_pointer_v<base_t> || !std::semiregular<base_t>;
 
public:
    using difference_type   = std::iter_difference_t<base_t>;
    using value_type        = std::iter_value_t<base_t>;
    using reference         = std::iter_reference_t<base_t>;
    using pointer           = detail::iter_pointer_t<base_t>;
    using iterator_category = detail::iterator_category_tag_t<base_t>;
    using iterator_concept  = detail::iterator_concept_tag_t<base_t>;
 
    constexpr inherited_iterator_base() noexcept(
      std::is_nothrow_default_constructible_v<base_t>) = default;                          
    constexpr inherited_iterator_base(inherited_iterator_base const & rhs) noexcept(
      std::is_nothrow_copy_constructible_v<base_t>) = default;                             
    constexpr inherited_iterator_base(inherited_iterator_base && rhs) noexcept(
      std::is_nothrow_move_constructible_v<base_t>) = default;                             
    constexpr inherited_iterator_base & operator=(inherited_iterator_base const & rhs) noexcept(
      std::is_nothrow_copy_assignable_v<base_t>) = default;                                
    constexpr inherited_iterator_base & operator=(inherited_iterator_base && rhs) noexcept(
      std::is_nothrow_move_assignable_v<base_t>)                                = default; 
    ~inherited_iterator_base() noexcept(std::is_nothrow_destructible_v<base_t>) = default; 
 
    constexpr inherited_iterator_base(base_t && it) noexcept(std::is_nothrow_move_constructible_v<base_t>)
        requires(!wrap_base)
      : base_t{std::move(it)}
    {}
 
    constexpr inherited_iterator_base(base_t const & it) noexcept(std::is_copy_constructible_v<base_t>)
        requires(!wrap_base)
      : base_t{it}
    {}
 
    constexpr inherited_iterator_base(base_t it) noexcept
        requires wrap_base
      : member{std::move(it)}
    {}
 
    constexpr friend bool operator==(derived_t const & lhs, derived_t const & rhs) noexcept(
      noexcept(std::declval<base_t &>() == std::declval<base_t &>()))
        requires std::equality_comparable<base_t>
    {
        return *lhs.this_to_base() == *rhs.this_to_base();
    }
 
    constexpr bool operator<(derived_t const & rhs) const
      noexcept(noexcept(std::declval<base_t &>() < std::declval<base_t &>()))
        requires std::totally_ordered<base_t>
    {
        return *this_to_base() < *rhs.this_to_base();
    }
 
    constexpr bool operator>(derived_t const & rhs) const
      noexcept(noexcept(std::declval<base_t &>() > std::declval<base_t &>()))
        requires std::totally_ordered<base_t>
    {
        return *this_to_base() > *rhs.this_to_base();
    }
 
    constexpr bool operator<=(derived_t const & rhs) const
      noexcept(noexcept(std::declval<base_t &>() > std::declval<base_t &>()))
        requires std::totally_ordered<base_t>
    {
        return !(*this > rhs);
    }
 
    constexpr bool operator>=(derived_t const & rhs) const
      noexcept(noexcept(std::declval<base_t &>() < std::declval<base_t &>()))
        requires std::totally_ordered<base_t>
    {
        return !(*this < rhs);
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t & operator++() noexcept(noexcept(++std::declval<base_t &>()))
        requires(requires(base_t_ i) { ++i; })
    {
        ++(*this_to_base());
        return *this_derived();
    }
 
    template <typename base_t_ = base_t>
    constexpr auto operator++(int) noexcept(noexcept(std::declval<base_t &>()++))
        requires(requires(base_t_ i) {
            i++;
            requires !std::same_as<decltype(i++), base_t_>;
        })
    {
        return (*this_to_base())++;
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t operator++(int) noexcept(
      noexcept(std::declval<base_t &>()++) && noexcept(derived_t(std::declval<base_t &>())))
        requires(requires(base_t_ i) {
            i++;
            {
                i++
            } -> std::same_as<base_t_>;
        } && std::constructible_from<derived_t, base_t_>)
    {
        return derived_t{(*this_to_base())++};
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t & operator--() noexcept(noexcept(--std::declval<base_t &>()))
        requires(requires(base_t_ i) { --i; })
    {
        --(*this_to_base());
        return *this_derived();
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t operator--(int) noexcept(
      noexcept(std::declval<base_t &>()--) && noexcept(derived_t{std::declval<base_t &>()}))
        requires(requires(base_t_ i) { i--; } && std::constructible_from<derived_t, base_t_>)
    {
        return derived_t{(*this_to_base())--};
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t & operator+=(difference_type const skip) noexcept(noexcept(std::declval<base_t &>() += skip))
        requires(requires(base_t_ i, difference_type const n) { i += n; })
    {
        *this_to_base() += skip;
        return *this_derived();
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t operator+(difference_type const skip) const
      noexcept(noexcept(std::declval<base_t &>() + skip) && noexcept(derived_t{std::declval<base_t &>()}))
        requires(requires(base_t_ const i, difference_type const n) { i + n; } &&
                 std::constructible_from<derived_t, base_t_>)
    {
        return derived_t{*this_to_base() + skip};
    }
 
    constexpr friend derived_t operator+(difference_type const skip,
                                         derived_t const & it) noexcept(noexcept(skip + std::declval<base_t const &>()))
        requires(requires(base_t const i, difference_type const n) { n + i; } &&
                 std::constructible_from<derived_t, base_t>)
    {
        return derived_t{skip + static_cast<base_t const &>(it)};
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t & operator-=(difference_type const skip) noexcept(noexcept(std::declval<base_t &>() -= skip))
        requires(requires(base_t_ i, difference_type const n) { i -= n; })
    {
        *this_to_base() -= skip;
        return *this_derived();
    }
 
    template <typename base_t_ = base_t>
    constexpr derived_t operator-(difference_type const skip) const
      noexcept(noexcept(std::declval<base_t const &>() - skip) && noexcept(derived_t(std::declval<base_t &>())))
        requires(requires(base_t_ i, difference_type const n) { i - n; } && std::constructible_from<derived_t, base_t_>)
    {
        return derived_t{*this_to_base() - skip};
    }
 
    constexpr difference_type operator-(derived_t const rhs) const
      noexcept(noexcept(std::declval<base_t &>() - std::declval<base_t &>()))
        requires std::sized_sentinel_for<base_t, base_t>
    {
        return static_cast<difference_type>(*this_to_base() - *rhs.this_to_base());
    }
 
    constexpr reference operator*() noexcept(noexcept(*std::declval<base_t &>()))
        requires std::indirectly_readable<base_t>
    {
        return **this_to_base();
    }
 
    constexpr decltype(auto) operator*() const noexcept(noexcept(*std::declval<base_t const &>()))
        requires std::indirectly_readable<base_t>
    {
        return **this_to_base();
    }
 
    constexpr pointer operator->() noexcept(noexcept(*std::declval<base_t &>()))
        requires std::input_iterator<base_t>
    {
        return &*this_to_base();
    }
 
    constexpr decltype(auto) operator->() const noexcept(noexcept(*std::declval<base_t const &>()))
        requires std::input_iterator<base_t>
    {
        return &*this_to_base();
    }
 
    template <typename base_t_ = base_t>
    constexpr decltype(auto) operator[](std::make_signed_t<difference_type> const n) noexcept(
      noexcept(std::declval<base_t &>()[0]))
        requires(requires(base_t_ i, difference_type const n) { i[n]; })
    {
        return (*this_to_base())[n];
    }
 
    template <typename base_t_ = base_t>
    constexpr decltype(auto) operator[](std::make_signed_t<difference_type> const n) const
      noexcept(noexcept(std::declval<base_t const &>()[0]))
        requires(requires(base_t_ const i, difference_type const n) { i[n]; })
    {
        return (*this_to_base())[n];
    }
 
private:
    std::conditional_t<wrap_base, base_t, meta::detail::empty_type> member;
 
    friend derived_t;
 
    constexpr derived_t * this_derived() { return static_cast<derived_t *>(this); }
 
    constexpr derived_t const * this_derived() const { return static_cast<derived_t const *>(this); }
 
    constexpr base_t * this_to_base()
    {
        if constexpr (wrap_base)
            return &member;
        else
            return static_cast<base_t *>(this);
    }
 
    constexpr base_t const * this_to_base() const
    {
        if constexpr (wrap_base)
            return &member;
        else
            return static_cast<base_t const *>(this);
    }
};
 
} // namespace bio::ranges::detail