boost_mirror/utility
1
0
Fork 0
mirror of https://github.com/boostorg/utility.git synced 2025-05-09 02:44:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Completely remove constexpr for MSVC

Browse Source
This commit is contained in:
Tony Lewis 2018-12-24 07:02:31 +00:00
parent 91ebdcd1dd
commit 6b62dcc504
3 changed files with 87 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
include/boost/operators.hpp
View File

@ -109,6 +109,13 @@
# pragma warning( disable : 4284 ) // complaint about return type of # pragma warning( disable : 4284 ) // complaint about return type of
#endif // operator-> not begin a UDT #endif // operator-> not begin a UDT
// Define BOOST_OPS_CONSTEXPR to be like BOOST_CONSTEXPR but empty under MSVC
#ifdef BOOST_MSVC
#define BOOST_OPS_CONSTEXPR
#else
#define BOOST_OPS_CONSTEXPR BOOST_CONSTEXPR
#endif
// In this section we supply the xxxx1 and xxxx2 forms of the operator // In this section we supply the xxxx1 and xxxx2 forms of the operator
// templates, which are explicitly targeted at the 1-type-argument and // templates, which are explicitly targeted at the 1-type-argument and
// 2-type-argument operator forms, respectively. // 2-type-argument operator forms, respectively.
@ -132,34 +139,34 @@ template <typename T> class empty_base {};
template <class T, class U, class B = operators_detail::empty_base<T> > template <class T, class U, class B = operators_detail::empty_base<T> >
struct less_than_comparable2 : B struct less_than_comparable2 : B
{ {
friend BOOST_CONSTEXPR bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); } friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
friend BOOST_CONSTEXPR bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); } friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
friend BOOST_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_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_CONSTEXPR bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); } friend BOOST_OPS_CONSTEXPR bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
friend BOOST_CONSTEXPR bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); } friend BOOST_OPS_CONSTEXPR bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
}; };
template <class T, class B = operators_detail::empty_base<T> > template <class T, class B = operators_detail::empty_base<T> >
struct less_than_comparable1 : B struct less_than_comparable1 : B
{ {
friend BOOST_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 y < x; }
friend BOOST_CONSTEXPR bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); } friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
friend BOOST_CONSTEXPR bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); } friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
}; };
template <class T, class U, class B = operators_detail::empty_base<T> > template <class T, class U, class B = operators_detail::empty_base<T> >
struct equality_comparable2 : B struct equality_comparable2 : B
{ {
friend BOOST_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 x == y; }
friend BOOST_CONSTEXPR bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); } friend BOOST_OPS_CONSTEXPR bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
friend BOOST_CONSTEXPR bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); } friend BOOST_OPS_CONSTEXPR bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
}; };
template <class T, class B = operators_detail::empty_base<T> > template <class T, class B = operators_detail::empty_base<T> >
struct equality_comparable1 : B struct equality_comparable1 : B
{ {
friend BOOST_CONSTEXPR bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); } friend BOOST_OPS_CONSTEXPR bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
}; };
// A macro which produces "name_2left" from "name". // A macro which produces "name_2left" from "name".
@ -220,38 +227,38 @@ struct NAME##1 : B \
// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide // BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
// optimization opportunities to the compiler :) // optimization opportunities to the compiler :)
#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \ #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
template <class T, class U, class B = operators_detail::empty_base<T> > \ template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \ struct NAME##2 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
friend BOOST_CONSTEXPR T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
}; \ }; \
\ \
template <class T, class B = operators_detail::empty_base<T> > \ template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \ struct NAME##1 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
}; };
#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \ #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
template <class T, class U, class B = operators_detail::empty_base<T> > \ template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \ struct NAME##2 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \ }; \
\ \
template <class T, class U, class B = operators_detail::empty_base<T> > \ template <class T, class U, class B = operators_detail::empty_base<T> > \
struct BOOST_OPERATOR2_LEFT(NAME) : B \ struct BOOST_OPERATOR2_LEFT(NAME) : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( const U& lhs, const T& rhs ) \ friend BOOST_OPS_CONSTEXPR T operator OP( const U& lhs, const T& rhs ) \
{ return T( lhs ) OP##= rhs; } \ { return T( lhs ) OP##= rhs; } \
}; \ }; \
\ \
template <class T, class B = operators_detail::empty_base<T> > \ template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \ struct NAME##1 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
}; };
#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@ -343,13 +350,13 @@ struct NAME##1 : B \
template <class T, class U, class B = operators_detail::empty_base<T> > \ template <class T, class U, class B = operators_detail::empty_base<T> > \
struct NAME##2 : B \ struct NAME##2 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
}; \ }; \
\ \
template <class T, class B = operators_detail::empty_base<T> > \ template <class T, class B = operators_detail::empty_base<T> > \
struct NAME##1 : B \ struct NAME##1 : B \
{ \ { \
friend BOOST_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ friend BOOST_OPS_CONSTEXPR T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
}; };
#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
@ -362,7 +369,7 @@ BOOST_BINARY_OPERATOR( right_shiftable, >> )
template <class T, class U, class B = operators_detail::empty_base<T> > template <class T, class U, class B = operators_detail::empty_base<T> >
struct equivalent2 : B struct equivalent2 : B
{ {
friend BOOST_CONSTEXPR bool operator==(const T& x, const U& y) friend BOOST_OPS_CONSTEXPR bool operator==(const T& x, const U& y)
{ {
return !static_cast<bool>(x < y) && !static_cast<bool>(x > y); return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
} }
@ -371,7 +378,7 @@ struct equivalent2 : B
template <class T, class B = operators_detail::empty_base<T> > template <class T, class B = operators_detail::empty_base<T> >
struct equivalent1 : B struct equivalent1 : B
{ {
friend BOOST_CONSTEXPR bool operator==(const T&x, const T&y) friend BOOST_OPS_CONSTEXPR bool operator==(const T&x, const T&y)
{ {
return !static_cast<bool>(x < y) && !static_cast<bool>(y < x); return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
} }
@ -380,28 +387,28 @@ struct equivalent1 : B
template <class T, class U, class B = operators_detail::empty_base<T> > template <class T, class U, class B = operators_detail::empty_base<T> >
struct partially_ordered2 : B struct partially_ordered2 : B
{ {
friend BOOST_CONSTEXPR bool operator<=(const T& x, const U& y) friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const U& y)
{ return static_cast<bool>(x < y) || static_cast<bool>(x == y); } { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
friend BOOST_CONSTEXPR bool operator>=(const T& x, const U& y) friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const U& y)
{ return static_cast<bool>(x > y) || static_cast<bool>(x == y); } { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
friend BOOST_CONSTEXPR bool operator>(const U& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator>(const U& x, const T& y)
{ return y < x; } { return y < x; }
friend BOOST_CONSTEXPR bool operator<(const U& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator<(const U& x, const T& y)
{ return y > x; } { return y > x; }
friend BOOST_CONSTEXPR bool operator<=(const U& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator<=(const U& x, const T& y)
{ return static_cast<bool>(y > x) || static_cast<bool>(y == x); } { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
friend BOOST_CONSTEXPR bool operator>=(const U& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator>=(const U& x, const T& y)
{ return static_cast<bool>(y < x) || static_cast<bool>(y == x); } { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
}; };
template <class T, class B = operators_detail::empty_base<T> > template <class T, class B = operators_detail::empty_base<T> >
struct partially_ordered1 : B struct partially_ordered1 : B
{ {
friend BOOST_CONSTEXPR bool operator>(const T& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator>(const T& x, const T& y)
{ return y < x; } { return y < x; }
friend BOOST_CONSTEXPR bool operator<=(const T& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator<=(const T& x, const T& y)
{ return static_cast<bool>(x < y) || static_cast<bool>(x == y); } { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
friend BOOST_CONSTEXPR bool operator>=(const T& x, const T& y) friend BOOST_OPS_CONSTEXPR bool operator>=(const T& x, const T& y)
{ return static_cast<bool>(y < x) || static_cast<bool>(x == y); } { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
}; };

24
operators.htm
View File

@ -499,7 +499,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Return convertible to <code>bool</code>. See the <a href= Return convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -518,7 +519,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Returns convertible to <code>bool</code>. See the <a href= Returns convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -531,7 +533,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
<td><code>t == t1</code>.<br> <td><code>t == t1</code>.<br>
Return convertible to <code>bool</code>.</td> Return convertible to <code>bool</code>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -546,7 +549,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
<td><code>t == u</code>.<br> <td><code>t == u</code>.<br>
Return convertible to <code>bool</code>.</td> Return convertible to <code>bool</code>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -892,7 +896,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Return convertible to <code>bool</code>. See the <a href= Return convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -905,7 +910,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Returns convertible to <code>bool</code>. See the <a href= Returns convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -921,7 +927,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Returns convertible to <code>bool</code>. See the <a href= Returns convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
<tr> <tr>
@ -941,7 +948,8 @@ const point&lt;float&gt; pi_over_4_normalized = pi_over_4 / length(pi_over_4);
Returns convertible to <code>bool</code>. See the <a href= Returns convertible to <code>bool</code>. See the <a href=
"#ordering">Ordering Note</a>.</td> "#ordering">Ordering Note</a>.</td>
<td>Since <code>C++11</code></td> <td>Since <code>C++11</code><br>
<span style="font-size:small;">(except <a href="https://developercommunity.visualstudio.com/content/problem/414193/rejects-valid-constexpr-marked-friend-function-def.html">MSVC</a>)</span></td>
</tr> </tr>
</table> </table>

14
test/operators_test.cpp
View File

@ -50,9 +50,9 @@ namespace
void operator!() const; void operator!() const;
public: public:
BOOST_CONSTEXPR convertible_to_bool( const bool value ) : _value( value ) {} BOOST_OPS_CONSTEXPR convertible_to_bool( const bool value ) : _value( value ) {}
BOOST_CONSTEXPR operator unspecified_bool_type() const BOOST_OPS_CONSTEXPR operator unspecified_bool_type() const
{ return _value ? &convertible_to_bool::_value : 0; } { return _value ? &convertible_to_bool::_value : 0; }
}; };
@ -64,12 +64,12 @@ namespace
, boost::shiftable<Wrapped1<T> > , boost::shiftable<Wrapped1<T> >
{ {
public: public:
BOOST_CONSTEXPR explicit Wrapped1( T v = T() ) : _value(v) {} BOOST_OPS_CONSTEXPR explicit Wrapped1( T v = T() ) : _value(v) {}
BOOST_CONSTEXPR T value() const { return _value; } BOOST_OPS_CONSTEXPR T value() const { return _value; }
BOOST_CONSTEXPR convertible_to_bool operator<(const Wrapped1& x) const BOOST_OPS_CONSTEXPR convertible_to_bool operator<(const Wrapped1& x) const
{ return _value < x._value; } { return _value < x._value; }
BOOST_CONSTEXPR convertible_to_bool operator==(const Wrapped1& x) const BOOST_OPS_CONSTEXPR convertible_to_bool operator==(const Wrapped1& x) const
{ return _value == x._value; } { return _value == x._value; }
Wrapped1& operator+=(const Wrapped1& x) Wrapped1& operator+=(const Wrapped1& x)
@ -934,6 +934,7 @@ main()
// Where C++11 constexpr is available, compile-time test some of the operators that are able to use it to propagate constexpr // 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 #ifndef BOOST_NO_CXX11_CONSTEXPR
#ifndef BOOST_MSVC
static_assert( ! static_cast<bool>( MyInt{ 1 } == MyInt{ 2 } ), "" ); static_assert( ! static_cast<bool>( MyInt{ 1 } == MyInt{ 2 } ), "" );
static_assert( MyInt{ 1 } != MyInt{ 2 }, "" ); static_assert( MyInt{ 1 } != MyInt{ 2 }, "" );
static_assert( MyInt{ 1 } < MyInt{ 2 }, "" ); static_assert( MyInt{ 1 } < MyInt{ 2 }, "" );
@ -954,6 +955,7 @@ main()
static_assert( MyInt{ 1 } <= MyInt{ 1 }, "" ); static_assert( MyInt{ 1 } <= MyInt{ 1 }, "" );
static_assert( ! static_cast<bool>( MyInt{ 1 } > MyInt{ 1 } ), "" ); static_assert( ! static_cast<bool>( MyInt{ 1 } > MyInt{ 1 } ), "" );
static_assert( MyInt{ 1 } >= MyInt{ 1 }, "" ); static_assert( MyInt{ 1 } >= MyInt{ 1 }, "" );
#endif
#endif #endif
return boost::report_errors(); return boost::report_errors();