Improving flat containers interface.

base/template_util.h

 // Copyright (c) 2011 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_TEMPLATE_UTIL_H_
 #define BASE_TEMPLATE_UTIL_H_
 
 #include <stddef.h>
 #include <iosfwd>
 #include <type_traits>
@@ skipping 18 matching lines @@
 // - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
 // TODO(danakj): Remove this when android builders are all using a newer version
 // of gcc, or the android ndk is updated to a newer libc++ that works with older
 // gcc versions.
 #if !defined(__clang__) && defined(_LIBCPP_VERSION)
 #define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
 #endif
 
 namespace base {
 
+// C++14 ---------------------------------------------------------------------

[danakj, 2017/06/23 21:10:26]

I would honestly prefer to not add things here when you can already do it with
the STL as we have it, and would have code use enable_if::type directly instead.

[brettw, 2017/06/23 21:19:45]

I think all this is needed is for TransparentCompare. Is that correct? What does
TransparectCompare look like if we don't add this stuff?

[vmpstr, 2017/06/23 21:45:14]

I agree. I'd rather not start adding things from C++14 onward if they are just
syntactic sugar. Eventually we'll move to C++14 proper and be able to use those
then. It's hard enough to keep remembering when to type std:: and when to type
base:: outside of //base. When C++14 arrives, and we remove these, then the code
outside doesn't have to change to compile but could optionally be updated for
std::enable_if_t and the like. 

[dyaroshev, 2017/06/26 11:47:29]

This is why we can't have nice things)

Ok, I found another implementation of void_t in the codebase and used it for
Transparent Check.

[vmpstr, 2017/06/26 15:35:53]

Indeed

+// These can be replaced with the ones from the standard once we have C++14.
+
+// std::enable_if_t: http://en.cppreference.com/w/cpp/types/enable_if
+template <bool condition, typename T = void>
+using enable_if_t = typename std::enable_if<condition, T>::type;
+
+// std::conditional_t: http://en.cppreference.com/w/cpp/types/conditional
+template <bool condition, typename T, typename U>
+using conditional_t = typename std::conditional<condition, T, U>::type;
+
+// C++17 ----------------------------------------------------------------------
+// These can be replaced with the ones from the standard once we have C++17.

[vmpstr, 2017/06/23 21:45:14]

I'll admit I'm not too familiar with the detection idiom that you have here.
I'll read up more on it, but is based on the SupportsOstreamOperator changes
below, it seems that this is already doable succinctly with the current version
of C++. Is that not true? (I mean to say we only need to know about transparency
of comparators, and not a general detection logic, right?)

Similarly to above, I'd prefer to have fewer future language version implemented
in base, especially from std::experimental since that's definitely subject to
change. 

[dyaroshev, 2017/06/26 11:47:29]

Done.

+
+// std::void_t: http://en.cppreference.com/w/cpp/types/void_t
+// Needed for the detection idiom.
+template <typename...>
+using void_t = void;
+
+// std::nonesuch: http://en.cppreference.com/w/cpp/experimental/nonesuch
+// Needed for the detection idiom.
+struct nonesuch {
+  nonesuch() = delete;
+  ~nonesuch() = delete;
+  nonesuch(nonesuch const&) = delete;
+  void operator=(nonesuch const&) = delete;
+};
+
+// Implementation of the detection idiom from cppreference:
+// http://en.cppreference.com/w/cpp/experimental/is_detected
+namespace internal {
+
+template <typename Default,
+          typename AlwaysVoid,
+          template <typename...> class Op,
+          typename... Args>
+struct detector {
+  using value_t = std::false_type;
+  using type = Default;
+};
+
+template <typename Default, template <typename...> class Op, typename... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...> {
+  using value_t = std::true_type;
+  using type = Op<Args...>;
+};
+
+}  // namespace internal
+
+// std::is_detected: http://en.cppreference.com/w/cpp/experimental/is_detected
+template <template <typename...> class Op, typename... Args>
+using is_detected =
+    typename internal::detector<nonesuch, void, Op, Args...>::value_t;

[vmpstr, 2017/06/23 21:45:14]

AFAICT, we're not using detector::type, just the value_t, so I think we could at
least clean this up by eliminating nonesuch and type parameters. We only need
void_t since we need to determine whether Op<Args...> is a valid type. Is that
true?

I understand that it's parity with c++17, but all of this is experimental.

[dyaroshev, 2017/06/26 11:47:29]

Removed altogether.

+
+// std::is_detected_v, implemented as a constexpr function instead of a variable
+// template, since we don't have those.
+// http://en.cppreference.com/w/cpp/experimental/is_detected
+template <template <typename...> class Op, typename... Args>
+constexpr bool is_detected_c() {
+  return is_detected<Op, Args...>::value;

[vmpstr, 2017/06/23 21:45:14]

Can you comment that ::value is on std::true_type/std::false_type, it takes a
bit of cognitive processing to figure out what's coming from where

[dyaroshev, 2017/06/26 11:47:29]

Not applicable.

+}
+
+// ----------------------------------------------------------------------------
+
 template <class T> struct is_non_const_reference : std::false_type {};
 template <class T> struct is_non_const_reference<T&> : std::true_type {};
 template <class T> struct is_non_const_reference<const T&> : std::false_type {};
 
 namespace internal {
 
-// Uses expression SFINAE to detect whether using operator<< would work.
-template <typename T, typename = void>
-struct SupportsOstreamOperator : std::false_type {};
 template <typename T>
-struct SupportsOstreamOperator<T,
-                               decltype(void(std::declval<std::ostream&>()
-                                             << std::declval<T>()))>
-    : std::true_type {};
+using HasOstreamOperator =
+    decltype(std::declval<std::ostream&>() << std::declval<T>());
+
+template <typename T>
+using SupportsOstreamOperator = base::is_detected<HasOstreamOperator, T>;
 
 }  // namespace internal
 
 // is_trivially_copyable is especially hard to get right.
 // - Older versions of libstdc++ will fail to have it like they do for other
 //   type traits. This has become a subset of the second point, but used to be
 //   handled independently.
 // - An experimental release of gcc includes most of type_traits but misses
 //   is_trivially_copyable, so we still have to avoid using libstdc++ in this
 //   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
@@ skipping 31 matching lines @@
 template <class T>
 using is_trivially_copyable = std::is_trivially_copyable<T>;
 #endif
 
 }  // namespace base
 
 #undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
 #undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
 
 #endif  // BASE_TEMPLATE_UTIL_H_