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 24 matching lines @@
 #endif
 
 namespace base {
 
 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 {
 
+template <typename...>
+struct make_void {
+  using type = void;
+};
+
+// A clone of C++17 std::void_t.
+// Unlike the original version, we need |make_void| as a helper struct to avoid
+// a C++14 defect.
+// ref: http://en.cppreference.com/w/cpp/types/void_t
+// ref: http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
+template <typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
 // 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 {};
 
 }  // namespace internal
@@ skipping 34 matching lines @@
 #else
   static constexpr bool value =
       __has_trivial_copy(T) && __has_trivial_destructor(T);
 #endif
 };
 #else
 template <class T>
 using is_trivially_copyable = std::is_trivially_copyable<T>;
 #endif
 
+// std::less<> from C++14.
+struct less {
+  template <typename T, typename U>
+  constexpr auto operator()(T&& lhs, U&& rhs) const
+      -> decltype(std::forward<T>(lhs) < std::forward<U>(rhs)) {
+    return std::forward<T>(lhs) < std::forward<U>(rhs);
+  }
+
+  // You can find more information about transparent comparisons here:
+  // http://en.cppreference.com/w/cpp/utility/functional/less_void
+  using is_transparent = int;
+};
+
 }  // namespace base
 
 #undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
 #undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
 
 #endif  // BASE_TEMPLATE_UTIL_H_