From dd6ea902ade974f5bc6f9b571d36e884e68e6584 Mon Sep 17 00:00:00 2001
From: namark <namark@disroot.org>
Date: Sun, 15 Aug 2021 18:41:30 +0400
Subject: [PATCH] Couple of convenience member function for range,
also did I really forget the != operator?
---
source/simple/support/range.hpp | 25 ++++++++++++++++++-------
unit_tests/range.cpp | 17 +++++++++++++++++
2 files changed, 35 insertions(+), 7 deletions(-)
diff --git a/source/simple/support/range.hpp b/source/simple/support/range.hpp
index d0f839e..2c5c9c4 100644
--- a/source/simple/support/range.hpp
+++ b/source/simple/support/range.hpp
@@ -47,9 +47,9 @@ namespace simple::support
constexpr const Type& upper() const noexcept { return bounds[1]; }
constexpr bool operator ==(const range& other) const
- {
- return bounds == other.bounds;
- }
+ { return bounds == other.bounds; }
+ constexpr bool operator !=(const range& other) const
+ { return !(*this == other); }
template <typename It = Type,
std::enable_if_t<is_iterable<It>{}>...>
@@ -109,6 +109,12 @@ namespace simple::support
return range{*this}.fix();
}
+ [[nodiscard]]
+ constexpr range fixed() const
+ {
+ return range{*this}.fix();
+ }
+
[[nodiscard]]
constexpr auto reverse() const
{
@@ -144,13 +150,18 @@ namespace simple::support
{ return lower() <= other.upper() && upper() >= other.lower(); }
// { return intersection(other).valid(); } // why is the cool way always inefficient :/
- constexpr range intersection(range other) const
+ constexpr range& intersect(const range& other)
{
using std::min;
using std::max;
- other.lower() = max(other.lower(), lower());
- other.upper() = min(other.upper(), upper());
- return other;
+ lower() = max(lower(), other.lower());
+ upper() = min(upper(), other.upper());
+ return *this;
+ }
+
+ constexpr range intersection(range other) const
+ {
+ return other.intersect(*this);
}
template <typename Other, std::enable_if_t<
diff --git a/unit_tests/range.cpp b/unit_tests/range.cpp
index 796dc6f..31f6ccd 100644
--- a/unit_tests/range.cpp
+++ b/unit_tests/range.cpp
@@ -11,11 +11,18 @@ void Validity()
assert(valid_range.valid());
valid_range.fix();
assert(valid_range.valid());
+ assert(valid_range.fixed() == valid_range);
+ assert(valid_range.fixed().valid());
range invalid_range{valid_range.upper(), valid_range.lower()};
const range const_invalid_range = invalid_range;
assert(!invalid_range.valid());
assert(!const_invalid_range.valid());
+
+ assert(invalid_range.fixed().valid());
+ assert(invalid_range.fixed() == valid_range);
+ assert(!invalid_range.valid());
+
invalid_range.fix();
const range const_valid_range = const_invalid_range.fix();
assert(invalid_range.valid());
@@ -89,11 +96,21 @@ void SetLikePredicates()
assert(!intersects(r, {-67, -102}));
assert(( intersection(r, {12,56}) == range{12,31} ));
+ assert(( r != range{12,31} ));
assert(( intersection(r, {12,22}) == range{12,22} ));
+ assert(( r != range{12,22} ));
assert(( intersection(r, {-31,13}) == range{-13,13} ));
+ assert(( r != range{-13,13} ));
assert(( !intersection(r, {-31,-21}).valid() ));
assert(( !intersection(r, {32,52}).valid() ));
+ r.intersect({12,56});
+ assert(( r == range{12,31} ));
+ r.intersect({12,22});
+ assert(( r == range{12,22} ));
+ r.intersect({-31,13});
+ assert(( r == range{12,13} ));
+
}
void Clamping()
--
GitLab