interface.hpp

#ifndef HALCHECK_LIB_ITERATOR_INTERFACE_HPP
#define HALCHECK_LIB_ITERATOR_INTERFACE_HPP
 
// IWYU pragma: private, include <halcheck/lib/iterator.hpp>
 
#include <halcheck/lib/iterator/base.hpp>
#include <halcheck/lib/iterator/range.hpp>
#include <halcheck/lib/numeric.hpp>
#include <halcheck/lib/type_traits.hpp>
 
namespace halcheck { namespace lib {
 
namespace detail {
template<typename I>
using dereference = decltype(*std::declval<I &>());
 
template<typename I>
using equality = lib::boolean_testable<decltype(std::declval<const I &>() == std::declval<const I &>())>;
 
template<typename I, typename D = decltype(std::declval<const I &>() - std::declval<const I &>())>
using difference = lib::enable_if_t<std::is_integral<D>() && std::is_signed<D>()>;
 
template<typename I>
using increment = decltype(++std::declval<I &>());
 
template<typename I>
using decrement = decltype(--std::declval<I &>());
 
template<typename I, typename N>
using addition = lib::same<decltype(std::declval<I &>() += std::declval<const N &>()), I &>;
} // namespace detail
 
template<typename Self>
class iterator_interface {
protected:
  iterator_interface() = default;
 
public:
  template<
      typename I = Self,
      HALCHECK_REQUIRE(lib::is_detected<detail::dereference, I>()),
      HALCHECK_REQUIRE(lib::is_detected<detail::addition, I, lib::iter_difference_t<I>>())>
  constexpr lib::iter_reference_t<I> operator[](lib::iter_difference_t<I> n) const {
    return *(static_cast<const I &>(*this) + n);
  }
 
  template<
      typename I = Self,
      HALCHECK_REQUIRE(lib::is_detected<detail::increment, I>()),
      HALCHECK_REQUIRE(lib::is_copyable<I>())>
  I operator++(int) {
    I &self = *static_cast<I *>(this);
    auto output = self;
    ++self;
    return output;
  }
 
  template<
      typename I = Self,
      HALCHECK_REQUIRE(lib::is_detected<detail::increment, I>()),
      HALCHECK_REQUIRE(!lib::is_copyable<I>())>
  void operator++(int) {
    ++*static_cast<I *>(this);
  }
 
  template<
      typename I = Self,
      HALCHECK_REQUIRE(lib::is_detected<detail::decrement, I>()),
      HALCHECK_REQUIRE(lib::is_copyable<I>())>
  I operator--(int) {
    I &self = *static_cast<I *>(this);
    auto output = self;
    --self;
    return output;
  }
 
  template<
      typename I = Self,
      HALCHECK_REQUIRE(lib::is_detected<detail::decrement, I>()),
      HALCHECK_REQUIRE(!lib::is_copyable<I>())>
  void operator--(int) {
    --*static_cast<I *>(this);
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::addition, I, lib::iter_difference_t<I>>())>
  I &operator-=(lib::iter_difference_t<I> n) {
    I &self = *static_cast<I *>(this);
    self += -n;
    return self;
  }
 
private:
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::equality, I>())>
  friend bool operator!=(const Self &lhs, const Self &rhs) {
    return !bool(lhs == rhs);
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::difference, I>())>
  friend bool operator<(const Self &lhs, const Self &rhs) {
    return (lhs - rhs) < 0;
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::difference, I>())>
  friend bool operator>(const Self &lhs, const Self &rhs) {
    return rhs < lhs;
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::difference, I>())>
  friend bool operator<=(const Self &lhs, const Self &rhs) {
    return !(rhs < lhs);
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::difference, I>())>
  friend bool operator>=(const Self &lhs, const Self &rhs) {
    return !(lhs < rhs);
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::addition, I, lib::iter_difference_t<I>>())>
  friend Self operator+(Self i, lib::iter_difference_t<I> n) {
    i += n;
    return i;
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::addition, I, lib::iter_difference_t<I>>())>
  friend Self operator+(lib::iter_difference_t<I> n, Self i) {
    i += n;
    return i;
  }
 
  template<typename I = Self, HALCHECK_REQUIRE(lib::is_detected<detail::addition, I, lib::iter_difference_t<I>>())>
  friend Self operator-(Self i, lib::iter_difference_t<I> n) {
    i -= n;
    return i;
  }
};
 
template<
    typename Self,
    HALCHECK_REQUIRE(std::is_class<Self>()),
    HALCHECK_REQUIRE(std::is_same<Self, lib::remove_cv_t<Self>>())>
class view_interface : public lib::view_base {
private:
  template<typename T = Self>
  T &self() {
    return static_cast<T &>(*this);
  }
 
  template<typename T = Self>
  const T &self() const {
    return static_cast<const T &>(*this);
  }
 
public:
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_sized_range<const T>())>
  constexpr bool empty() const {
    return lib::size(self()) == 0;
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(!lib::is_sized_range<const T>() && lib::is_forward_range<const T>())>
  constexpr bool empty() const {
    return lib::begin(self()) == lib::end(self());
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_sized_range<T>())>
  bool empty() {
    return lib::size(self()) == 0;
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(!lib::is_sized_range<T>() && lib::is_forward_range<T>())>
  bool empty() {
    return lib::begin(self()) == lib::end(self());
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_sized_range<const T>() || lib::is_forward_range<const T>())>
  constexpr explicit operator bool() const {
    return !empty();
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_sized_range<T>() || lib::is_forward_range<T>())>
  explicit operator bool() {
    return !empty();
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_random_access_range<const T>())>
  constexpr auto size() const -> decltype(lib::to_unsigned(lib::end(self<T>()) - lib::begin(self<T>()))) {
    return lib::to_unsigned(lib::end(self()) - lib::begin(self()));
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_random_access_range<T>())>
  auto size() -> decltype(lib::to_unsigned(lib::end(self<T>()) - lib::begin(self<T>()))) {
    return lib::to_unsigned(lib::end(self()) - lib::begin(self()));
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_forward_range<const T>())>
  constexpr auto front() const -> decltype(*lib::begin(self<T>())) {
    return *lib::begin(self());
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_forward_range<T>())>
  auto front() -> decltype(*lib::begin(self<T>())) {
    return *lib::begin(self());
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_bidirectional_range<const T>())>
  constexpr auto back() const -> decltype(*std::prev(lib::end(self<T>()))) {
    return *std::prev(lib::end(self()));
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_bidirectional_range<T>())>
  auto back() -> decltype(*std::prev(lib::end(self<T>()))) {
    return *std::prev(lib::end(self()));
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_random_access_range<const T>())>
  constexpr auto operator[](lib::range_difference_t<T> n) const -> decltype(lib::begin(self<T>())[n]) {
    return lib::begin(self<T>())[n];
  }
 
  template<typename T = Self, HALCHECK_REQUIRE(lib::is_random_access_range<T>())>
  auto operator[](lib::range_difference_t<T> n) -> decltype(lib::begin(self<T>())[n]) {
    return lib::begin(self<T>())[n];
  }
};
 
}} // namespace halcheck::lib
 
#endif