based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
commit86ddedf8c342b753a74235494090e1cca2c5234f
parentd1ec827045286c6d448fe375506e2b95b999e873
authorDimitrije Dobrota <mail@dimitrijedobrota.com>
dateMon, 31 Mar 2025 14:06:52 +0200

Fix returned reference to temporary object

Diffstat:
Minclude/based/algorithm.hpp|+++++++++--------
Minclude/based/type_traits.hpp|+++++++++
Mtest/CMakeLists.txt|-----
Mtest/source/min_test.cpp|+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-----------

4 files changed, 113 insertions(+), 26 deletions(-)

diff --git a/include/based/algorithm.hpp b/include/based/algorithm.hpp

@@ -8,19 +8,20 @@

namespace based
{
// need to deal with returned reference to temporary object...
// returns min element, first if equal
template<Relation R>
const domain_t<R>& min(const domain_t<R>& lhs, const domain_t<R>& rhs, R r)
template<Relation R, BareRegular T, BareRegular U>
requires BareSameAs<T, U> && BareSameAs<T, domain_t<R>>
decltype(auto) min(T&& lhs, U&& rhs, R r)
{
return r(rhs, lhs) ? rhs : lhs;
return r(rhs, lhs) ? std::forward<U>(rhs) : std::forward<T>(lhs);
}
template<Regular T>
const T& min(const T& lhs, const T& rhs)
template<BareRegular T, BareRegular U>
requires BareSameAs<T, U>
decltype(auto) min(T&& lhs, U&& rhs)
{
return based::min(lhs, rhs, std::less<T>());
return based::min(
std::forward<T>(lhs), std::forward<U>(rhs), std::less<bare_t<T>>());
}
// return first min element

diff --git a/include/based/type_traits.hpp b/include/based/type_traits.hpp

@@ -24,14 +24,23 @@ concept Integer = requires(T n) {

};
template<typename T>
using bare_t = std::remove_cvref_t<T>;
template<typename T>
concept Regular = std::regular<T>;
template<typename T>
concept BareRegular = std::regular<bare_t<T>>;
template<typename T>
concept RegularIterator = std::regular<typename T::value_type>;
template<typename T, typename U>
concept SameAs = std::is_same_v<T, U> && std::is_same_v<U, T>;
template<typename T, typename U>
concept BareSameAs = SameAs<bare_t<T>, bare_t<U>>;
template<typename T>
concept Input =
std::is_same_v<T,

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt

@@ -7,11 +7,6 @@ include(../cmake/folders.cmake)

# ---- Dependencies ----
if(PROJECT_IS_TOP_LEVEL)
find_package(based REQUIRED)
enable_testing()
endif()
find_package(Catch2 REQUIRED)
include(Catch)

diff --git a/test/source/min_test.cpp b/test/source/min_test.cpp

@@ -2,52 +2,134 @@

#include "based/algorithm.hpp"
TEST_CASE("min(literal, literal)", "[based/algorithm/min]")
TEST_CASE("min(literal, literal) = left", "[based/algorithm/min]")
{
REQUIRE(std::same_as<int, decltype(based::min(3, 4))>);
REQUIRE(std::same_as<int&&, decltype(based::min(3, 4))>);
REQUIRE(based::min(3, 4) == 3);
}
TEST_CASE("min(value, literal)", "[based/algorithm/min]")
TEST_CASE("min(literal, literal) = right", "[based/algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int&&, decltype(based::min(4, 3))>);
REQUIRE(based::min(4, 3) == 3);
}
TEST_CASE("min(value, literal) = left", "[based/algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(a, 4))>);
REQUIRE(based::min(a, 4) == 3);
}
TEST_CASE("min(literal, value)", "[based/algorithm/min]")
TEST_CASE("min(value, literal) = right", "[based/algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(a, 3))>);
REQUIRE(based::min(a, 3) == 3);
}
TEST_CASE("min(literal, value) = left", "[based/algorithm/min]")
{
int b = 4; // NOLINT misc-const-correctness
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(3, b))>);
REQUIRE(based::min(3, b) == 3);
}
TEST_CASE("min(value, value)", "[based/algorithm/min]")
TEST_CASE("min(literal, value) = right", "[based/algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<int, decltype(based::min(4, b))>);
REQUIRE(based::min(4, b) == 3);
}
TEST_CASE("min(value, value) = left", "[based/algorithm/min]")
{
int a = 3;
int b = 4;
REQUIRE(std::same_as<int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, value) = right", "[based/algorithm/min]")
{
int a = 4;
int b = 3;
REQUIRE(std::same_as<int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, literal)", "[based/algorithm/min]")
TEST_CASE("min(const value, literal) = left", "[based/algorithm/min]")
{
const int a = 3;
REQUIRE(std::same_as<int, decltype(based::min(a, 4))>);
REQUIRE(based::min(a, 4) == 3);
}
TEST_CASE("min(literal, const value)", "[based/algorithm/min]")
TEST_CASE("min(const value, literal) = right", "[based/algorithm/min]")
{
const int a = 4;
REQUIRE(std::same_as<int, decltype(based::min(a, 3))>);
REQUIRE(based::min(a, 3) == 3);
}
TEST_CASE("min(literal, const value) = left", "[based/algorithm/min]")
{
const int b = 4;
REQUIRE(std::same_as<int, decltype(based::min(3, b))>);
REQUIRE(based::min(3, b) == 3);
}
TEST_CASE("min(const value, const value)", "[based/algorithm/min]")
TEST_CASE("min(literal, const value) = right", "[based/algorithm/min]")
{
const int b = 3;
REQUIRE(std::same_as<int, decltype(based::min(4, b))>);
REQUIRE(based::min(4, b) == 3);
}
TEST_CASE("min(const value, const value) = left", "[based/algorithm/min]")
{
const int a = 3;
const int b = 4;
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, const value) = right", "[based/algorithm/min]")
{
const int a = 4;
const int b = 3;
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, const value) = left", "[based/algorithm/min]")
{
int a = 3; // NOLINT misc-const-correctness
const int b = 4;
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(value, const value) = right", "[based/algorithm/min]")
{
int a = 4; // NOLINT misc-const-correctness
const int b = 3;
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, value) = left", "[based/algorithm/min]")
{
const int a = 3;
int b = 4; // NOLINT misc-const-correctness
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}
TEST_CASE("min(const value, value) = right", "[based/algorithm/min]")
{
const int a = 4;
int b = 3; // NOLINT misc-const-correctness
REQUIRE(std::same_as<const int&, decltype(based::min(a, b))>);
REQUIRE(based::min(a, b) == 3);
}