random_access_iterator.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/core.hpp>
 
namespace bio::ranges::detail
{
 
template <typename range_type, template <typename...> typename derived_t_template>
class random_access_iterator_base
{
protected:
    typename std::add_pointer_t<range_type> host{nullptr};
    using position_type = std::make_unsigned_t<typename range_type::difference_type>;
    position_type pos{static_cast<position_type>(0)};
 
    template <typename, template <typename...> typename>
    friend class random_access_iterator_base;
 
    using derived_t = derived_t_template<range_type>;
 
public:
    using difference_type = typename range_type::difference_type; // TODO should be range_ but is broken in ranges
    using value_type      = typename range_type::value_type;
    using reference       = std::
      conditional_t<std::is_const_v<range_type>, typename range_type::const_reference, typename range_type::reference>;
    using const_reference   = typename range_type::const_reference; //TODO: there is no type trait for this, yet :o
    using pointer           = value_type *;
    using iterator_category = std::random_access_iterator_tag;
 
    constexpr random_access_iterator_base() noexcept                                                = default;
    constexpr random_access_iterator_base(random_access_iterator_base const &) noexcept             = default;
    constexpr random_access_iterator_base & operator=(random_access_iterator_base const &) noexcept = default;
    constexpr random_access_iterator_base(random_access_iterator_base &&) noexcept                  = default;
    constexpr random_access_iterator_base & operator=(random_access_iterator_base &&) noexcept      = default;
    ~random_access_iterator_base() noexcept                                                         = default;
 
    explicit constexpr random_access_iterator_base(range_type & host) noexcept : host{&host} {}
    constexpr random_access_iterator_base(range_type & host, position_type const pos) noexcept : host{&host}, pos{pos}
    {}
 
    template <typename range_type2>
        requires(std::is_const_v<range_type> && (!std::is_const_v<range_type2>) &&
                 std::is_same_v<std::remove_const_t<range_type>, range_type2>)
    constexpr random_access_iterator_base(
      random_access_iterator_base<range_type2, derived_t_template> const & rhs) noexcept :
      host{rhs.host}, pos{rhs.pos}
    {}
 
    constexpr friend bool operator==(derived_t const & lhs, derived_t const & rhs) noexcept
    {
        return lhs.pos == rhs.pos;
    }
 
    constexpr friend auto operator<=>(derived_t const & lhs, derived_t const & rhs) noexcept
    {
        return lhs.pos <=> rhs.pos;
    }
 
    constexpr derived_t & operator++() noexcept
    {
        ++pos;
        return *this_derived();
    }
 
    constexpr derived_t operator++(int) noexcept
    {
        derived_t cpy{*this_derived()};
        ++pos;
        return cpy;
    }
 
    constexpr derived_t & operator--() noexcept
    {
        --pos;
        return *this_derived();
    }
 
    constexpr derived_t operator--(int) noexcept
    {
        derived_t cpy{*this_derived()};
        --pos;
        return cpy;
    }
 
    constexpr derived_t & operator+=(difference_type const skip) noexcept
    {
        pos += skip;
        return *this_derived();
    }
 
    constexpr derived_t operator+(difference_type const skip) const noexcept
    {
        derived_t cpy{*this_derived()};
        return cpy += skip;
    }
 
    constexpr friend derived_t operator+(difference_type const skip, derived_t const & it) noexcept
    {
        return it + skip;
    }
 
    constexpr derived_t & operator-=(difference_type const skip) noexcept
    {
        pos -= skip;
        return *this_derived();
    }
 
    constexpr derived_t operator-(difference_type const skip) const noexcept
    {
        derived_t cpy{*this_derived()};
        return cpy -= skip;
    }
 
    constexpr friend derived_t operator-(difference_type const skip, derived_t const & it) noexcept
    {
        return it - skip;
    }
 
    constexpr friend difference_type operator-(derived_t const & lhs, derived_t const & rhs) noexcept
    {
        return static_cast<difference_type>(lhs.pos - rhs.pos);
    }
 
    constexpr reference operator*() const noexcept(noexcept((*host)[pos])) { return (*host)[pos]; }
 
    constexpr pointer operator->() const noexcept(noexcept((&host)[pos])) { return &host[pos]; }
 
    constexpr reference operator[](position_type const n) const noexcept(noexcept((*host)[pos + n]))
    {
        return (*host)[pos + n];
    }
 
private:
    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); }
};
 
template <typename range_type>
class random_access_iterator : public random_access_iterator_base<range_type, random_access_iterator>
{
private:
    using base = random_access_iterator_base<range_type, random_access_iterator>;
    using typename base::position_type;
 
public:
    using typename base::const_reference;
    using typename base::difference_type;
    using typename base::iterator_category;
    using typename base::pointer;
    using typename base::reference;
    using typename base::value_type;
 
    using base::base;
};
 
} // namespace bio::ranges::detail