Add skeleton circular queue file.

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 <iterator>
 #include <type_traits>
 #include <utility>
 
 #include "build/build_config.h"
 
 // Some versions of libstdc++ have partial support for type_traits, but misses
 // a smaller subset while removing some of the older non-standard stuff. Assume
 // that all versions below 5.0 fall in this category, along with one 5.0
 // experimental release. Test for this by consulting compiler major version,
 // the only reliable option available, so theoretically this could fail should
@@ skipping 13 matching lines @@
 #if !defined(__clang__) && defined(_LIBCPP_VERSION)
 #define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
 #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 {};
 
+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;
+
 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 {};
 
+// Used to detech whether the given type is an iterator.  This is normally used
+// with std::enable_if to provide disambiguation for functions that take
+// templatzed iterators as input.
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
+
+template <typename T>
+struct is_iterator<T,
+                   void_t<typename std::iterator_traits<T>::iterator_category>>
+    : std::true_type {};
+
 }  // 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.
 // - When compiling libc++ from before r239653, with a gcc compiler, the
@@ skipping 44 matching lines @@
   // 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_