From e26188145238572580b9af18fbde4b824b341046 Mon Sep 17 00:00:00 2001
From: Stephan Bergmann <sbergman@redhat.com>
Date: Tue, 29 Sep 2015 14:19:47 +0200
Subject: Avoid unhelpful -Wunused-variable

...at least from "g++ (GCC) 5.1.1 20150618 (Red Hat 5.1.1-4)" with
--disable-debug, when a namespace-scope const variable with a "complex"
initializer declared in an include file remains unused.

Avoid that warning via SAL_CONSTEXPR, which in turn requires large parts of
o3tl::is_typed_flags to be SAL_CONSTEXPR, which in turn requires a new
HAVE_CXX14_CONSTEXPR to allow assert in constexpr functions, which in turn
requires using -std=c++14 instead of -std=c++11 where available, which in turn
(a) requires to /not/ use -std=c++14 if it would run into a bug between Clang
and libstdc++ discussed at <https://llvm.org/bugs/show_bug.cgi?id=24115>
"llvm-nm fails to build with gcc 5.1's libstdc++" (and which hits us in
sfx2/source/control/thumbnailview.cxx), and (b) requires a new
HAVE_CXX14_SIZED_DEALLOCATION to work around GCC 5.1 -Werror=sized-deallocation
(where Clang >= 3.7 only supports C++14 sized deallocation when explictly
enabled via -fsized-deallocation, btw).

This effectively reverts ff6462e6307e6924dc6c8178043ae9032f4b4152 "avoid unused
variable warning:" again.

Change-Id: I424e3561452a3e6d8c8a9604d6c737cab49840c4
Reviewed-on: https://gerrit.libreoffice.org/18918
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
Tested-by: Stephan Bergmann <sbergman@redhat.com>
---
 include/o3tl/typed_flags_set.hxx | 73 +++++++++++++++++++++++++++++-----------
 1 file changed, 53 insertions(+), 20 deletions(-)

(limited to 'include/o3tl')

diff --git a/include/o3tl/typed_flags_set.hxx b/include/o3tl/typed_flags_set.hxx
index 4755c09fb536..9b8cb817ee02 100644
--- a/include/o3tl/typed_flags_set.hxx
+++ b/include/o3tl/typed_flags_set.hxx
@@ -25,18 +25,21 @@
 #include <cassert>
 #include <type_traits>
 
+#include <config_global.h>
+#include <sal/types.h>
+
 namespace o3tl {
 
 namespace detail {
 
-template<typename T> inline
+template<typename T> inline SAL_CONSTEXPR
 typename std::enable_if<std::is_signed<T>::value, bool>::type isNonNegative(
     T value)
 {
     return value >= 0;
 }
 
-template<typename T> inline
+template<typename T> inline SAL_CONSTEXPR
 typename std::enable_if<std::is_unsigned<T>::value, bool>::type isNonNegative(T)
 {
     return true;
@@ -70,19 +73,23 @@ struct is_typed_flags {
     public:
         typedef is_typed_flags Unwrapped;
 
-        explicit Wrap(typename std::underlying_type<E>::type value):
+        explicit SAL_CONSTEXPR Wrap(
+            typename std::underlying_type<E>::type value):
             value_(value)
         {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
             assert(detail::isNonNegative(value));
             assert((value & ~M) == 0);
+#endif
         }
 
-        operator E() { return static_cast<E>(value_); }
+        SAL_CONSTEXPR operator E() const { return static_cast<E>(value_); }
 
-        explicit operator typename std::underlying_type<E>::type()
+        explicit SAL_CONSTEXPR operator typename std::underlying_type<E>::type()
+            const
         { return value_; }
 
-        explicit operator bool() { return value_ != 0; }
+        explicit SAL_CONSTEXPR operator bool() const { return value_ != 0; }
 
     private:
         typename std::underlying_type<E>::type value_;
@@ -94,17 +101,19 @@ struct is_typed_flags {
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ~(E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ~(E rhs) {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         o3tl::typed_flags<E>::mask
         & ~static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ~(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ~(
     typename o3tl::typed_flags<E>::Wrap rhs)
 {
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
@@ -113,44 +122,53 @@ inline typename o3tl::typed_flags<E>::Wrap operator ~(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
+    E lhs, E rhs)
+{
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator ^(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator ^(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         ^ static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
+inline SAL_CONSTEXPR
+typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
     W lhs, W rhs)
 {
     return static_cast<W>(
@@ -163,44 +181,53 @@ inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator ^(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
+    E lhs, E rhs)
+{
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator &(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator &(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         & static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
+inline SAL_CONSTEXPR
+typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
     W lhs, W rhs)
 {
     return static_cast<W>(
@@ -213,44 +240,50 @@ inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator &(
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(E lhs, E rhs) {
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(E lhs, E rhs) {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(
     E lhs, typename o3tl::typed_flags<E>::Wrap rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(lhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename E>
-inline typename o3tl::typed_flags<E>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<E>::Wrap operator |(
     typename o3tl::typed_flags<E>::Wrap lhs, E rhs)
 {
+#if !HAVE_CXX11_CONSTEXPR || HAVE_CXX14_CONSTEXPR
     assert(
         o3tl::detail::isNonNegative(
             static_cast<typename std::underlying_type<E>::type>(rhs)));
+#endif
     return static_cast<typename o3tl::typed_flags<E>::Wrap>(
         static_cast<typename std::underlying_type<E>::type>(lhs)
         | static_cast<typename std::underlying_type<E>::type>(rhs));
 }
 
 template<typename W>
-inline typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator |(
+inline SAL_CONSTEXPR typename o3tl::typed_flags<typename W::Unwrapped::Self>::Wrap operator |(
     W lhs, W rhs)
 {
     return static_cast<W>(
-- 
cgit v1.2.3