From 9a4cff038bc523184be4dc3e7fc1585992713e83 Mon Sep 17 00:00:00 2001 From: Glen Fernandes Date: Sun, 12 Apr 2020 12:39:58 -0400 Subject: [PATCH 1/3] Move constexpr operators test to separate test --- test/Jamfile.v2 | 1 + test/operators_constexpr_test.cpp | 59 +++++++++++++++++++++++++++++++ test/operators_test.cpp | 38 ++++---------------- 3 files changed, 66 insertions(+), 32 deletions(-) create mode 100644 test/operators_constexpr_test.cpp diff --git a/test/Jamfile.v2 b/test/Jamfile.v2 index 739edc0..55fdd44 100644 --- a/test/Jamfile.v2 +++ b/test/Jamfile.v2 @@ -21,6 +21,7 @@ run compressed_pair_final_test.cpp ; run iterators_test.cpp ; run operators_test.cpp ; +compile operators_constexpr_test.cpp ; compile result_of_test.cpp ; diff --git a/test/operators_constexpr_test.cpp b/test/operators_constexpr_test.cpp new file mode 100644 index 0000000..8ea3aff --- /dev/null +++ b/test/operators_constexpr_test.cpp @@ -0,0 +1,59 @@ +/* +Copyright 2020 Glen Joseph Fernandes +(glenjofe@gmail.com) + +Distributed under the Boost Software License, Version 1.0. +(http://www.boost.org/LICENSE_1_0.txt) +*/ + +#include +#if !defined(BOOST_NO_CXX11_CONSTEXPR) && \ + (!defined(BOOST_MSVC) || (BOOST_MSVC >= 1922)) +#include +#include + +namespace { + +class Value + : boost::operators { +public: + BOOST_OPS_CONSTEXPR explicit Value(int v) + : v_(v) { } + + BOOST_OPS_CONSTEXPR bool + operator<(const Value& x) const { + return v_ < x.v_; + } + + BOOST_OPS_CONSTEXPR bool + operator==(const Value& x) const { + return v_ == x.v_; + } + +private: + int v_; +}; + +} // namespace + +BOOST_STATIC_ASSERT(!static_cast(Value(1) == Value(2))); +BOOST_STATIC_ASSERT(Value(1) != Value(2)); +BOOST_STATIC_ASSERT(Value(1) < Value(2)); +BOOST_STATIC_ASSERT(Value(1) <= Value(2)); +BOOST_STATIC_ASSERT(!static_cast(Value(1) > Value(2))); +BOOST_STATIC_ASSERT(!static_cast(Value(1) >= Value(2))); + +BOOST_STATIC_ASSERT(!static_cast(Value(2) == Value(1))); +BOOST_STATIC_ASSERT(Value(2) != Value(1)); +BOOST_STATIC_ASSERT(!static_cast(Value(2) < Value(1))); +BOOST_STATIC_ASSERT(!static_cast(Value(2) <= Value(1))); +BOOST_STATIC_ASSERT(Value(2) > Value(1)); +BOOST_STATIC_ASSERT(Value(2) >= Value(1)); + +BOOST_STATIC_ASSERT(Value(1) == Value(1)); +BOOST_STATIC_ASSERT(!static_cast(Value(1) != Value(1))); +BOOST_STATIC_ASSERT(!static_cast(Value(1) < Value(1))); +BOOST_STATIC_ASSERT(Value(1) <= Value(1)); +BOOST_STATIC_ASSERT(!static_cast(Value(1) > Value(1))); +BOOST_STATIC_ASSERT(Value(1) >= Value(1)); +#endif diff --git a/test/operators_test.cpp b/test/operators_test.cpp index a98d6f6..c1edf8f 100644 --- a/test/operators_test.cpp +++ b/test/operators_test.cpp @@ -50,9 +50,9 @@ namespace void operator!() const; public: - BOOST_OPS_CONSTEXPR convertible_to_bool( const bool value ) : _value( value ) {} + convertible_to_bool( const bool value ) : _value( value ) {} - BOOST_OPS_CONSTEXPR operator unspecified_bool_type() const + operator unspecified_bool_type() const { return _value ? &convertible_to_bool::_value : 0; } }; @@ -64,12 +64,12 @@ namespace , boost::shiftable > { public: - BOOST_OPS_CONSTEXPR explicit Wrapped1( T v = T() ) : _value(v) {} - BOOST_OPS_CONSTEXPR T value() const { return _value; } + explicit Wrapped1( T v = T() ) : _value(v) {} + T value() const { return _value; } - BOOST_OPS_CONSTEXPR convertible_to_bool operator<(const Wrapped1& x) const + convertible_to_bool operator<(const Wrapped1& x) const { return _value < x._value; } - BOOST_OPS_CONSTEXPR convertible_to_bool operator==(const Wrapped1& x) const + convertible_to_bool operator==(const Wrapped1& x) const { return _value == x._value; } Wrapped1& operator+=(const Wrapped1& x) @@ -932,31 +932,5 @@ main() cout << "Performed tests on MyLongInt objects.\n"; -// Where C++11 constexpr is available, compile-time test some of the operators that are able to use it to propagate constexpr -#ifndef BOOST_NO_CXX11_CONSTEXPR -#if !defined(BOOST_MSVC) || (_MSC_VER >= 1922) - static_assert( ! static_cast( MyInt{ 1 } == MyInt{ 2 } ), "" ); - static_assert( MyInt{ 1 } != MyInt{ 2 }, "" ); - static_assert( MyInt{ 1 } < MyInt{ 2 }, "" ); - static_assert( MyInt{ 1 } <= MyInt{ 2 }, "" ); - static_assert( ! static_cast( MyInt{ 1 } > MyInt{ 2 } ), "" ); - static_assert( ! static_cast( MyInt{ 1 } >= MyInt{ 2 } ), "" ); - - static_assert( ! static_cast( MyInt{ 2 } == MyInt{ 1 } ), "" ); - static_assert( MyInt{ 2 } != MyInt{ 1 }, "" ); - static_assert( ! static_cast( MyInt{ 2 } < MyInt{ 1 } ), "" ); - static_assert( ! static_cast( MyInt{ 2 } <= MyInt{ 1 } ), "" ); - static_assert( MyInt{ 2 } > MyInt{ 1 }, "" ); - static_assert( MyInt{ 2 } >= MyInt{ 1 }, "" ); - - static_assert( MyInt{ 1 } == MyInt{ 1 }, "" ); - static_assert( ! static_cast( MyInt{ 1 } != MyInt{ 1 } ), "" ); - static_assert( ! static_cast( MyInt{ 1 } < MyInt{ 1 } ), "" ); - static_assert( MyInt{ 1 } <= MyInt{ 1 }, "" ); - static_assert( ! static_cast( MyInt{ 1 } > MyInt{ 1 } ), "" ); - static_assert( MyInt{ 1 } >= MyInt{ 1 }, "" ); -#endif -#endif - return boost::report_errors(); } From 5da340a2a41a2bf79dda27634b6a69dcc4dfa4c9 Mon Sep 17 00:00:00 2001 From: Glen Fernandes Date: Sun, 12 Apr 2020 12:55:21 -0400 Subject: [PATCH 2/3] Rename BOOST_OPS_CONSTEXPR to BOOST_OPERATORS_CONSTEXPR --- include/boost/operators.hpp | 56 +++++++++++++++---------------- test/operators_constexpr_test.cpp | 6 ++-- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/include/boost/operators.hpp b/include/boost/operators.hpp index aca5ea8..6b3b028 100644 --- a/include/boost/operators.hpp +++ b/include/boost/operators.hpp @@ -109,15 +109,15 @@ # pragma warning( disable : 4284 ) // complaint about return type of #endif // operator-> not begin a UDT -// Define BOOST_OPS_CONSTEXPR to be like BOOST_CONSTEXPR but empty under MSVC < v19.22 +// Define BOOST_OPERATORS_CONSTEXPR to be like BOOST_CONSTEXPR but empty under MSVC < v19.22 #ifdef BOOST_MSVC #if BOOST_MSVC_FULL_VER >= 192200000 -#define BOOST_OPS_CONSTEXPR constexpr +#define BOOST_OPERATORS_CONSTEXPR constexpr #else -#define BOOST_OPS_CONSTEXPR +#define BOOST_OPERATORS_CONSTEXPR #endif #else -#define BOOST_OPS_CONSTEXPR BOOST_CONSTEXPR +#define BOOST_OPERATORS_CONSTEXPR BOOST_CONSTEXPR #endif // In this section we supply the xxxx1 and xxxx2 forms of the operator @@ -143,34 +143,34 @@ template class empty_base {}; template > struct less_than_comparable2 : B { - friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const U& y) { return !static_cast(x > y); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const U& y) { return !static_cast(x < y); } - friend BOOST_OPS_CONSTEXPR bool operator>(const U& x, const T& y) { return y < x; } - friend BOOST_OPS_CONSTEXPR bool operator<(const U& x, const T& y) { return y > x; } - friend BOOST_OPS_CONSTEXPR bool operator<=(const U& x, const T& y) { return !static_cast(y < x); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const U& x, const T& y) { return !static_cast(y > x); } + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const T& x, const U& y) { return !static_cast(x > y); } + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const T& x, const U& y) { return !static_cast(x < y); } + friend BOOST_OPERATORS_CONSTEXPR bool operator>(const U& x, const T& y) { return y < x; } + friend BOOST_OPERATORS_CONSTEXPR bool operator<(const U& x, const T& y) { return y > x; } + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const U& x, const T& y) { return !static_cast(y < x); } + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const U& x, const T& y) { return !static_cast(y > x); } }; template > struct less_than_comparable1 : B { - friend BOOST_OPS_CONSTEXPR bool operator>(const T& x, const T& y) { return y < x; } - friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const T& y) { return !static_cast(y < x); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const T& y) { return !static_cast(x < y); } + friend BOOST_OPERATORS_CONSTEXPR bool operator>(const T& x, const T& y) { return y < x; } + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const T& x, const T& y) { return !static_cast(y < x); } + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const T& x, const T& y) { return !static_cast(x < y); } }; template > struct equality_comparable2 : B { - friend BOOST_OPS_CONSTEXPR bool operator==(const U& y, const T& x) { return x == y; } - friend BOOST_OPS_CONSTEXPR bool operator!=(const U& y, const T& x) { return !static_cast(x == y); } - friend BOOST_OPS_CONSTEXPR bool operator!=(const T& y, const U& x) { return !static_cast(y == x); } + friend BOOST_OPERATORS_CONSTEXPR bool operator==(const U& y, const T& x) { return x == y; } + friend BOOST_OPERATORS_CONSTEXPR bool operator!=(const U& y, const T& x) { return !static_cast(x == y); } + friend BOOST_OPERATORS_CONSTEXPR bool operator!=(const T& y, const U& x) { return !static_cast(y == x); } }; template > struct equality_comparable1 : B { - friend BOOST_OPS_CONSTEXPR bool operator!=(const T& x, const T& y) { return !static_cast(x == y); } + friend BOOST_OPERATORS_CONSTEXPR bool operator!=(const T& x, const T& y) { return !static_cast(x == y); } }; // A macro which produces "name_2left" from "name". @@ -373,7 +373,7 @@ BOOST_BINARY_OPERATOR( right_shiftable, >> ) template > struct equivalent2 : B { - friend BOOST_OPS_CONSTEXPR bool operator==(const T& x, const U& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator==(const T& x, const U& y) { return !static_cast(x < y) && !static_cast(x > y); } @@ -382,7 +382,7 @@ struct equivalent2 : B template > struct equivalent1 : B { - friend BOOST_OPS_CONSTEXPR bool operator==(const T&x, const T&y) + friend BOOST_OPERATORS_CONSTEXPR bool operator==(const T&x, const T&y) { return !static_cast(x < y) && !static_cast(y < x); } @@ -391,28 +391,28 @@ struct equivalent1 : B template > struct partially_ordered2 : B { - friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const U& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const T& x, const U& y) { return static_cast(x < y) || static_cast(x == y); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const U& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const T& x, const U& y) { return static_cast(x > y) || static_cast(x == y); } - friend BOOST_OPS_CONSTEXPR bool operator>(const U& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator>(const U& x, const T& y) { return y < x; } - friend BOOST_OPS_CONSTEXPR bool operator<(const U& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator<(const U& x, const T& y) { return y > x; } - friend BOOST_OPS_CONSTEXPR bool operator<=(const U& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const U& x, const T& y) { return static_cast(y > x) || static_cast(y == x); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const U& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const U& x, const T& y) { return static_cast(y < x) || static_cast(y == x); } }; template > struct partially_ordered1 : B { - friend BOOST_OPS_CONSTEXPR bool operator>(const T& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator>(const T& x, const T& y) { return y < x; } - friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator<=(const T& x, const T& y) { return static_cast(x < y) || static_cast(x == y); } - friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const T& y) + friend BOOST_OPERATORS_CONSTEXPR bool operator>=(const T& x, const T& y) { return static_cast(y < x) || static_cast(x == y); } }; diff --git a/test/operators_constexpr_test.cpp b/test/operators_constexpr_test.cpp index 8ea3aff..02d3186 100644 --- a/test/operators_constexpr_test.cpp +++ b/test/operators_constexpr_test.cpp @@ -17,15 +17,15 @@ namespace { class Value : boost::operators { public: - BOOST_OPS_CONSTEXPR explicit Value(int v) + BOOST_OPERATORS_CONSTEXPR explicit Value(int v) : v_(v) { } - BOOST_OPS_CONSTEXPR bool + BOOST_OPERATORS_CONSTEXPR bool operator<(const Value& x) const { return v_ < x.v_; } - BOOST_OPS_CONSTEXPR bool + BOOST_OPERATORS_CONSTEXPR bool operator==(const Value& x) const { return v_ == x.v_; } From 64fffa0f9771094244a894c0e986f78a408f1b1b Mon Sep 17 00:00:00 2001 From: Glen Fernandes Date: Sun, 12 Apr 2020 13:00:59 -0400 Subject: [PATCH 3/3] Simplify BOOST_OPERATORS_CONSTEXPR definition --- include/boost/operators.hpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/include/boost/operators.hpp b/include/boost/operators.hpp index 6b3b028..7dce7df 100644 --- a/include/boost/operators.hpp +++ b/include/boost/operators.hpp @@ -110,12 +110,8 @@ #endif // operator-> not begin a UDT // Define BOOST_OPERATORS_CONSTEXPR to be like BOOST_CONSTEXPR but empty under MSVC < v19.22 -#ifdef BOOST_MSVC -#if BOOST_MSVC_FULL_VER >= 192200000 -#define BOOST_OPERATORS_CONSTEXPR constexpr -#else +#if BOOST_WORKAROUND(BOOST_MSVC, < 1922) #define BOOST_OPERATORS_CONSTEXPR -#endif #else #define BOOST_OPERATORS_CONSTEXPR BOOST_CONSTEXPR #endif