global_iterator.hpp

Go to the documentation of this file.

#pragma once
 
#include "ityr/common/util.hpp"
#include "ityr/ori/ori.hpp"
#include "ityr/pattern/count_iterator.hpp"
#include "ityr/container/checkout_span.hpp"
 
namespace ityr {
 
template <typename T, typename = void>
struct is_global_iterator : public std::false_type {};
 
template <typename T>
struct is_global_iterator<T, std::void_t<typename T::checkout_iterator>> : public std::true_type {};
 
template <typename T>
inline constexpr bool is_global_iterator_v = is_global_iterator<T>::value;
 
namespace internal {
 
template <typename GPtr, typename Mode>
using checkout_iterator_t =
  std::conditional_t<std::is_same_v<Mode, checkout_mode::no_access_t>,
                     GPtr,
                     std::conditional_t<std::is_same_v<Mode, checkout_mode::read_t>,
                                        const typename GPtr::value_type*,
                                        typename GPtr::value_type*>>;
 
template <typename T>
using src_checkout_mode_t = std::conditional_t<std::is_trivially_copyable_v<T>,
                                               checkout_mode::read_t,
                                               checkout_mode::read_write_t>;
 
template <typename T>
using dest_checkout_mode_t = std::conditional_t<std::is_trivially_copyable_v<T>,
                                                checkout_mode::write_t,
                                                checkout_mode::read_write_t>;
 
}
 
template <typename T, typename Mode>
class global_iterator : public ori::global_ptr<T> {
  using this_t = global_iterator<T, Mode>;
  using base_t = ori::global_ptr<T>;
 
public:
  using value_type        = typename base_t::value_type;
  using difference_type   = typename base_t::difference_type;
  using pointer           = typename base_t::pointer;
  using reference         = typename base_t::reference;
  using iterator_category = typename base_t::iterator_category;
  using mode              = Mode;
  using checkout_iterator = internal::checkout_iterator_t<base_t, Mode>;
 
  global_iterator() : base_t(nullptr) {}
  global_iterator(ori::global_ptr<T> gptr) : base_t(gptr) {}
 
  constexpr this_t& operator+=(difference_type diff) noexcept {
    base_t::operator+=(diff);
    return *this;
  }
 
  constexpr this_t& operator-=(difference_type diff) noexcept {
    base_t::operator-=(diff);
    return *this;
  }
 
  constexpr this_t& operator++() noexcept { return (*this) += 1; }
  constexpr this_t& operator--() noexcept { return (*this) -= 1; }
 
  constexpr this_t operator++(int) noexcept { this_t tmp(*this); ++(*this); return tmp; }
  constexpr this_t operator--(int) noexcept { this_t tmp(*this); --(*this); return tmp; }
 
  constexpr this_t operator+(difference_type diff) const noexcept {
    return this_t(base_t::operator+(diff));
  }
 
  constexpr this_t operator-(difference_type diff) const noexcept {
    return this_t(base_t::operator-(diff));
  }
 
  auto checkout_nb(std::size_t count) const {
    if constexpr(std::is_same_v<mode, checkout_mode::no_access_t>) {
      return std::make_tuple(nullptr, base_t(*this));
    } else {
      checkout_span<T, mode> cs;
      cs.checkout_nb(base_t(*this), count, mode{});
      return std::make_tuple(std::move(cs), cs.data());
    }
  }
};
 
template <typename T, typename Mode>
inline global_iterator<T, Mode>
make_global_iterator(ori::global_ptr<T> gptr, Mode) {
  return global_iterator<T, Mode>(gptr);
}
 
template <typename GlobalIterator>
class global_move_iterator : public GlobalIterator {
  using this_t = global_move_iterator<GlobalIterator>;
  using base_t = GlobalIterator;
 
public:
  using value_type        = typename base_t::value_type;
  using difference_type   = typename base_t::difference_type;
  using pointer           = typename base_t::pointer;
  using reference         = typename base_t::reference;
  using iterator_category = typename base_t::iterator_category;
  using mode              = typename GlobalIterator::mode;
  using checkout_iterator = std::move_iterator<typename GlobalIterator::checkout_iterator>;
 
  static_assert(std::is_same_v<mode, internal::src_checkout_mode_t<value_type>>);
 
  explicit global_move_iterator(GlobalIterator git)
    : base_t(git) {}
 
  GlobalIterator base() const {
    return static_cast<base_t>(*this);
  }
 
  constexpr this_t& operator+=(difference_type diff) noexcept {
    base_t::operator+=(diff);
    return *this;
  }
 
  constexpr this_t& operator-=(difference_type diff) noexcept {
    base_t::operator-=(diff);
    return *this;
  }
 
  constexpr this_t& operator++() noexcept { return (*this) += 1; }
  constexpr this_t& operator--() noexcept { return (*this) -= 1; }
 
  constexpr this_t operator++(int) noexcept { this_t tmp(*this); ++(*this); return tmp; }
  constexpr this_t operator--(int) noexcept { this_t tmp(*this); --(*this); return tmp; }
 
  constexpr this_t operator+(difference_type diff) const noexcept {
    return this_t(base_t::operator+(diff));
  }
 
  constexpr this_t operator-(difference_type diff) const noexcept {
    return this_t(base_t::operator-(diff));
  }
 
  auto checkout_nb(std::size_t count) const {
    auto&& [cs, it] = base_t::checkout_nb(count);
    return std::make_tuple(std::move(cs), std::make_move_iterator(it));
  }
};
 
template <typename T>
inline global_move_iterator<global_iterator<T, internal::src_checkout_mode_t<T>>>
make_move_iterator(ori::global_ptr<T> gptr) {
  return global_move_iterator(make_global_iterator(gptr, internal::src_checkout_mode_t<T>{}));
}
 
template <typename GlobalIterator>
class global_reverse_iterator : public std::reverse_iterator<GlobalIterator> {
  using this_t = global_reverse_iterator<GlobalIterator>;
  using base_t = std::reverse_iterator<GlobalIterator>;
 
public:
  using value_type        = typename base_t::value_type;
  using difference_type   = typename base_t::difference_type;
  using pointer           = typename base_t::pointer;
  using reference         = typename base_t::reference;
  using iterator_category = typename base_t::iterator_category;
  using mode              = typename GlobalIterator::mode;
  using checkout_iterator = std::reverse_iterator<typename GlobalIterator::checkout_iterator>;
 
  explicit global_reverse_iterator(GlobalIterator git)
    : base_t(git) {}
 
  GlobalIterator base() const {
    return static_cast<base_t>(*this).base();
  }
 
  constexpr this_t& operator+=(difference_type diff) noexcept {
    base_t::operator+=(diff);
    return *this;
  }
 
  constexpr this_t& operator-=(difference_type diff) noexcept {
    base_t::operator-=(diff);
    return *this;
  }
 
  constexpr this_t& operator++() noexcept { return (*this) += 1; }
  constexpr this_t& operator--() noexcept { return (*this) -= 1; }
 
  constexpr this_t operator++(int) noexcept { this_t tmp(*this); ++(*this); return tmp; }
  constexpr this_t operator--(int) noexcept { this_t tmp(*this); --(*this); return tmp; }
 
  constexpr this_t operator+(difference_type diff) const noexcept {
    return this_t(base_t::operator+(diff));
  }
 
  constexpr this_t operator-(difference_type diff) const noexcept {
    return this_t(base_t::operator-(diff));
  }
 
  auto checkout_nb(std::size_t count) const {
    GlobalIterator git = base();
    auto&& [cs, it] = std::prev(git, count).checkout_nb(count);
    return std::make_tuple(std::move(cs), std::make_reverse_iterator(std::next(it, count)));
  }
};
 
template <typename T, typename Mode>
inline global_reverse_iterator<global_iterator<T, Mode>>
make_reverse_iterator(ori::global_ptr<T> gptr, Mode mode) {
  return global_reverse_iterator(make_global_iterator(gptr, mode));
}
 
template <typename GlobalIterator>
class global_construct_iterator : public GlobalIterator {
  using this_t = global_construct_iterator<GlobalIterator>;
  using base_t = GlobalIterator;
 
  static_assert(std::is_same_v<typename GlobalIterator::mode, checkout_mode::write_t>);
 
public:
  using value_type        = typename base_t::value_type;
  using difference_type   = typename base_t::difference_type;
  using pointer           = typename base_t::pointer;
  using reference         = typename base_t::reference;
  using iterator_category = typename base_t::iterator_category;
  using mode              = typename GlobalIterator::mode;
  using checkout_iterator = count_iterator<typename GlobalIterator::checkout_iterator>;
 
  explicit global_construct_iterator(GlobalIterator git)
    : base_t(git) {}
 
  GlobalIterator base() const {
    return static_cast<base_t>(*this);
  }
 
  constexpr this_t& operator+=(difference_type diff) noexcept {
    base_t::operator+=(diff);
    return *this;
  }
 
  constexpr this_t& operator-=(difference_type diff) noexcept {
    base_t::operator-=(diff);
    return *this;
  }
 
  constexpr this_t& operator++() noexcept { return (*this) += 1; }
  constexpr this_t& operator--() noexcept { return (*this) -= 1; }
 
  constexpr this_t operator++(int) noexcept { this_t tmp(*this); ++(*this); return tmp; }
  constexpr this_t operator--(int) noexcept { this_t tmp(*this); --(*this); return tmp; }
 
  constexpr this_t operator+(difference_type diff) const noexcept {
    return this_t(base_t::operator+(diff));
  }
 
  constexpr this_t operator-(difference_type diff) const noexcept {
    return this_t(base_t::operator-(diff));
  }
 
  auto checkout_nb(std::size_t count) const {
    auto&& [cs, it] = base_t::checkout_nb(count);
    return std::make_tuple(std::move(cs), make_count_iterator(it));
  }
};
 
template <typename GlobalIterator>
inline global_construct_iterator<GlobalIterator>
make_construct_iterator(GlobalIterator git) {
  return global_construct_iterator(git);
}
 
template <typename T>
inline global_construct_iterator<global_iterator<T, checkout_mode::write_t>>
make_construct_iterator(ori::global_ptr<T> gptr) {
  return global_construct_iterator(make_global_iterator(gptr, checkout_mode::write));
}
 
template <typename GlobalIterator>
class global_destruct_iterator : public GlobalIterator {
  using this_t = global_destruct_iterator<GlobalIterator>;
  using base_t = GlobalIterator;
 
  static_assert(std::is_same_v<typename GlobalIterator::mode, checkout_mode::read_write_t>);
 
public:
  using value_type        = typename base_t::value_type;
  using difference_type   = typename base_t::difference_type;
  using pointer           = typename base_t::pointer;
  using reference         = typename base_t::reference;
  using iterator_category = typename base_t::iterator_category;
  using mode              = typename GlobalIterator::mode;
  using checkout_iterator = count_iterator<typename GlobalIterator::checkout_iterator>;
 
  explicit global_destruct_iterator(GlobalIterator git)
    : base_t(git) {}
 
  GlobalIterator base() const {
    return static_cast<base_t>(*this);
  }
 
  constexpr this_t& operator+=(difference_type diff) noexcept {
    base_t::operator+=(diff);
    return *this;
  }
 
  constexpr this_t& operator-=(difference_type diff) noexcept {
    base_t::operator-=(diff);
    return *this;
  }
 
  constexpr this_t& operator++() noexcept { return (*this) += 1; }
  constexpr this_t& operator--() noexcept { return (*this) -= 1; }
 
  constexpr this_t operator++(int) noexcept { this_t tmp(*this); ++(*this); return tmp; }
  constexpr this_t operator--(int) noexcept { this_t tmp(*this); --(*this); return tmp; }
 
  constexpr this_t operator+(difference_type diff) const noexcept {
    return this_t(base_t::operator+(diff));
  }
 
  constexpr this_t operator-(difference_type diff) const noexcept {
    return this_t(base_t::operator-(diff));
  }
 
  auto checkout_nb(std::size_t count) const {
    auto&& [cs, it] = base_t::checkout_nb(count);
    return std::make_tuple(std::move(cs), make_count_iterator(it));
  }
};
 
template <typename GlobalIterator>
inline global_destruct_iterator<GlobalIterator>
make_destruct_iterator(GlobalIterator git) {
  return global_destruct_iterator(git);
}
 
template <typename T>
inline global_destruct_iterator<global_iterator<T, checkout_mode::read_write_t>>
make_destruct_iterator(ori::global_ptr<T> gptr) {
  return global_destruct_iterator(make_global_iterator(gptr, checkout_mode::read_write));
}
 
// Definitions for ADL
 
template <typename T, typename Mode>
inline global_move_iterator<global_iterator<T, Mode>>
make_move_iterator(global_iterator<T, Mode> git) {
  return global_move_iterator(git);
}
 
template <typename GlobalIterator>
inline global_move_iterator<global_reverse_iterator<GlobalIterator>>
make_move_iterator(global_reverse_iterator<GlobalIterator> git) {
  return global_move_iterator(git);
}
 
template <typename T, typename Mode>
inline global_reverse_iterator<global_iterator<T, Mode>>
make_reverse_iterator(global_iterator<T, Mode> git) {
  return global_reverse_iterator(git);
}
 
template <typename GlobalIterator>
inline global_reverse_iterator<global_move_iterator<GlobalIterator>>
make_reverse_iterator(global_move_iterator<GlobalIterator> git) {
  return global_reverse_iterator(git);
}
 
static_assert(is_global_iterator_v<global_iterator<int, checkout_mode::read_write_t>>);
static_assert(is_global_iterator_v<global_move_iterator<global_iterator<int, checkout_mode::read_t>>>);
static_assert(is_global_iterator_v<global_reverse_iterator<global_iterator<int, checkout_mode::read_write_t>>>);
static_assert(is_global_iterator_v<global_move_iterator<global_reverse_iterator<global_iterator<int, checkout_mode::read_t>>>>);
static_assert(!is_global_iterator_v<int>);
static_assert(!is_global_iterator_v<ori::global_ptr<int>>);
 
}