Make scoped enums output streamable.

base/logging.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_LOGGING_H_
 #define BASE_LOGGING_H_
 
 #include <cassert>
 #include <string>
 #include <cstring>
 #include <sstream>
+#include <type_traits>

[dcheng, 2015/11/13 03:30:23]

Pretty sure this isn't allowed yet.

 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/debug/debugger.h"
 #include "build/build_config.h"
 
 //
 // Optional message capabilities
 // -----------------------------
 // Assertion failed messages and fatal errors are displayed in a dialog box
@@ skipping 484 matching lines @@
   switch (0) case 0: default:                                                  \
   if (logging::CheckOpResult true_if_passed =                                  \
       logging::Check##name##Impl((val1), (val2),                               \
                                  #val1 " " #op " " #val2))                     \
    ;                                                                           \
   else                                                                         \
     logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()).stream()
 
 #endif
 
+namespace internal {
+// Type trait helper to detect scoped enums.
+template <typename T>
+using is_scoped_enum =
+    std::integral_constant<bool,
+                           std::is_enum<T>::value &&
+                               !std::is_convertible<T, int>::value>;
+}  // namespace internal
+
 // Build the error message string.  This is separate from the "Impl"
 // function template because it is not performance critical and so can
 // be out of line, while the "Impl" code should be inline.  Caller
 // takes ownership of the returned string.
-template<class t1, class t2>
-std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
+template <class T1,
+          class T2,
+          typename std::enable_if<!internal::is_scoped_enum<T1>::value &&
+                                  !internal::is_scoped_enum<T2>::value>::type* =
+              nullptr>
+std::string* MakeCheckOpString(const T1& v1, const T2& v2, const char* names) {
   std::ostringstream ss;
   ss << names << " (" << v1 << " vs. " << v2 << ")";
   std::string* msg = new std::string(ss.str());
   return msg;
 }
 
+// Template specialization for scoped enums. Only allows comparisons between
+// values from the same scoped enum.
+template <class T,
+          typename std::enable_if<internal::is_scoped_enum<T>::value>::type* =
+              nullptr>
+std::string* MakeCheckOpString(const T& v1, const T& v2, const char* names) {
+  using EnumIntegralType = typename std::underlying_type<T>::type;
+  std::ostringstream ss;
+  ss << names << " (" << static_cast<EnumIntegralType>(v1) << " vs. "
+     << static_cast<EnumIntegralType>(v2) << ")";
+  std::string* msg = new std::string(ss.str());
+  return msg;
+}
+
 // Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
 // in logging.cc.
 extern template BASE_EXPORT std::string* MakeCheckOpString<int, int>(
     const int&, const int&, const char* names);
 extern template BASE_EXPORT
 std::string* MakeCheckOpString<unsigned long, unsigned long>(
     const unsigned long&, const unsigned long&, const char* names);
 extern template BASE_EXPORT
 std::string* MakeCheckOpString<unsigned long, unsigned int>(
     const unsigned long&, const unsigned int&, const char* names);
@@ skipping 424 matching lines @@
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static bool logged_once = false;\
   LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG;\
   logged_once = true;\
 } while(0);\
 EAT_STREAM_PARAMETERS
 #endif
 
 #endif  // BASE_LOGGING_H_