llvm-project/libcxx/test/support/boolean_testable.h

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LIBCXX_TEST_SUPPORT_BOOLEAN_TESTABLE_H
#define LIBCXX_TEST_SUPPORT_BOOLEAN_TESTABLE_H

#include "test_macros.h"

#include <iterator>
#include <utility>

#if TEST_STD_VER > 17

struct BooleanTestable {
  constexpr operator bool() const { return value_; }

  friend constexpr BooleanTestable operator==(const BooleanTestable& lhs, const BooleanTestable& rhs) {
    return lhs.value_ == rhs.value_;
  }

  friend constexpr BooleanTestable operator!=(const BooleanTestable& lhs, const BooleanTestable& rhs) {
    return lhs.value_ != rhs.value_;
  }

  constexpr BooleanTestable&& operator!() && {
    value_ = !value_;
    return std::move(*this);
  }

  // this class should behave like a bool, so the constructor shouldn't be explicit
  constexpr BooleanTestable(bool value) : value_{value} {}
  constexpr BooleanTestable(const BooleanTestable&) = delete;
  constexpr BooleanTestable(BooleanTestable&&)      = delete;

private:
  bool value_;
};

static constexpr BooleanTestable yes(true);
static constexpr BooleanTestable no(false);

template <class T>
struct StrictComparable {
  StrictComparable() = default;

  // this shouldn't be explicit to make it easier to initialize inside arrays (which it almost always is)
  constexpr StrictComparable(T value) : value_{value} {}

  friend constexpr BooleanTestable const& operator==(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ == b.value_ ? yes : no;
  }

  friend constexpr BooleanTestable const& operator!=(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ != b.value_ ? yes : no;
  }

  friend constexpr BooleanTestable const& operator<(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ < b.value_ ? yes : no;
  }
  friend constexpr BooleanTestable const& operator<=(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ <= b.value_ ? yes : no;
  }
  friend constexpr BooleanTestable const& operator>(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ > b.value_ ? yes : no;
  }
  friend constexpr BooleanTestable const& operator>=(StrictComparable const& a, StrictComparable const& b) {
    return a.value_ >= b.value_ ? yes : no;
  }

  T value_;
};

auto StrictUnaryPredicate = []<class T>(StrictComparable<T> const& x) -> BooleanTestable const& {
  return x.value_ < 0 ? yes : no;
};

auto StrictBinaryPredicate =
    []<class T>(StrictComparable<T> const& x, StrictComparable<T> const& y) -> BooleanTestable const& {
  return x.value_ < y.value_ ? yes : no;
};

template <class It>
struct StrictBooleanIterator {
  using value_type                  = typename std::iterator_traits<It>::value_type;
  using reference                   = typename std::iterator_traits<It>::reference;
  using difference_type             = typename std::iterator_traits<It>::difference_type;
  constexpr StrictBooleanIterator() = default;
  constexpr explicit StrictBooleanIterator(It it) : iter_(it) {}
  constexpr reference operator*() const { return *iter_; }
  constexpr reference operator[](difference_type n) const { return iter_[n]; }
  constexpr StrictBooleanIterator& operator++() {
    ++iter_;
    return *this;
  }
  constexpr StrictBooleanIterator operator++(int) {
    auto copy = *this;
    ++iter_;
    return copy;
  }
  constexpr StrictBooleanIterator& operator--() {
    --iter_;
    return *this;
  }
  constexpr StrictBooleanIterator operator--(int) {
    auto copy = *this;
    --iter_;
    return copy;
  }
  constexpr StrictBooleanIterator& operator+=(difference_type n) {
    iter_ += n;
    return *this;
  }
  constexpr StrictBooleanIterator& operator-=(difference_type n) {
    iter_ -= n;
    return *this;
  }
  friend constexpr StrictBooleanIterator operator+(StrictBooleanIterator x, difference_type n) {
    x += n;
    return x;
  }
  friend constexpr StrictBooleanIterator operator+(difference_type n, StrictBooleanIterator x) {
    x += n;
    return x;
  }
  friend constexpr StrictBooleanIterator operator-(StrictBooleanIterator x, difference_type n) {
    x -= n;
    return x;
  }
  friend constexpr difference_type operator-(StrictBooleanIterator x, StrictBooleanIterator y) {
    return x.iter_ - y.iter_;
  }
  constexpr BooleanTestable const& operator==(StrictBooleanIterator const& other) const {
    return iter_ == other.iter_ ? yes : no;
  }
  constexpr BooleanTestable const& operator!=(StrictBooleanIterator const& other) const {
    return iter_ != other.iter_ ? yes : no;
  }
  constexpr BooleanTestable const& operator<(StrictBooleanIterator const& other) const {
    return iter_ < other.iter_ ? yes : no;
  }
  constexpr BooleanTestable const& operator<=(StrictBooleanIterator const& other) const {
    return iter_ <= other.iter_ ? yes : no;
  }
  constexpr BooleanTestable const& operator>(StrictBooleanIterator const& other) const {
    return iter_ > other.iter_ ? yes : no;
  }
  constexpr BooleanTestable const& operator>=(StrictBooleanIterator const& other) const {
    return iter_ >= other.iter_ ? yes : no;
  }

private:
  It iter_;
};
static_assert(std::forward_iterator<StrictBooleanIterator<int*>>);
static_assert(std::sentinel_for<StrictBooleanIterator<int*>, StrictBooleanIterator<int*>>);

#endif // TEST_STD_VER > 17

#endif // LIBCXX_TEST_SUPPORT_BOOLEAN_TESTABLE_H