SafeSPrintf: use C++ variadic template

base/strings/safe_sprintf.h

 // Copyright 2013 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_STRINGS_SAFE_SPRINTF_H_
 #define BASE_STRINGS_SAFE_SPRINTF_H_
 
 #include "build/build_config.h"
 
 #include <stddef.h>
@@ skipping 200 matching lines @@
 #if !defined(NDEBUG)
 // In debug builds, allow unit tests to artificially lower the kSSizeMax
 // constant that is used as a hard upper-bound for all buffers. In normal
 // use, this constant should always be std::numeric_limits<ssize_t>::max().
 BASE_EXPORT void SetSafeSPrintfSSizeMaxForTest(size_t max);
 BASE_EXPORT size_t GetSafeSPrintfSSizeMaxForTest();
 #endif
 
 }  // namespace internal
 
-// TODO(markus): C++11 has a much more concise and readable solution for
-//   expressing what we are doing here.
-
-template<class T0, class T1, class T2, class T3, class T4,
-         class T5, class T6, class T7, class T8, class T9>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                     T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
+template<typename... Args>
+ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args... args) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
+  const internal::Arg arg_array[] = { args... };
+  return internal::SafeSNPrintf(buf, N, fmt, arg_array, sizeof...(args));
 }
 
-template<size_t N,
-         class T0, class T1, class T2, class T3, class T4,
-         class T5, class T6, class T7, class T8, class T9>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                    T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) {
+template<size_t N, typename... Args>
+ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, Args... args) {
   // Use Arg() object to record type information and then copy arguments to an
   // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3, class T4,
-         class T5, class T6, class T7, class T8>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                     T5 arg5, T6 arg6, T7 arg7, T8 arg8) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N,
-         class T0, class T1, class T2, class T3, class T4, class T5,
-         class T6, class T7, class T8>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                    T5 arg5, T6 arg6, T7 arg7, T8 arg8) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5,
-         class T6, class T7>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                     T5 arg5, T6 arg6, T7 arg7) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N,
-         class T0, class T1, class T2, class T3, class T4, class T5,
-         class T6, class T7>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                    T5 arg5, T6 arg6, T7 arg7) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5,
-         class T6>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4,
-                     T5 arg5, T6 arg6) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N,
-         class T0, class T1, class T2, class T3, class T4, class T5,
-         class T6>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5,
-                    T6 arg6) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = {
-    arg0, arg1, arg2, arg3, arg4, arg5, arg6
-  };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3, class T4, class T5>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3, arg4, arg5 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N,
-         class T0, class T1, class T2, class T3, class T4, class T5>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3, arg4, arg5 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3, class T4>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3, arg4 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, class T0, class T1, class T2, class T3, class T4>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, T0 arg0, T1 arg1,
-                    T2 arg2, T3 arg3, T4 arg4) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3, arg4 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2, class T3>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2, T3 arg3) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, class T0, class T1, class T2, class T3>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt,
-                    T0 arg0, T1 arg1, T2 arg2, T3 arg3) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2, arg3 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1, class T2>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt,
-                     T0 arg0, T1 arg1, T2 arg2) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, class T0, class T1, class T2>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, T0 arg0, T1 arg1,
-                    T2 arg2) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1, arg2 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0, class T1>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, T0 arg0, T1 arg1) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, class T0, class T1>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, T0 arg0, T1 arg1) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0, arg1 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<class T0>
-ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, T0 arg0) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
-}
-
-template<size_t N, class T0>
-ssize_t SafeSPrintf(char (&buf)[N], const char* fmt, T0 arg0) {
-  // Use Arg() object to record type information and then copy arguments to an
-  // array to make it easier to iterate over them.
-  const internal::Arg arg_array[] = { arg0 };
-  return internal::SafeSNPrintf(buf, N, fmt, arg_array, arraysize(arg_array));
+  const internal::Arg arg_array[] = { args... };
+  return internal::SafeSNPrintf(buf, N, fmt, arg_array, sizeof...(args));
 }
 
 // Fast-path when we don't actually need to substitute any arguments.
 BASE_EXPORT ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt);
 template<size_t N>
 inline ssize_t SafeSPrintf(char (&buf)[N], const char* fmt) {
   return SafeSNPrintf(buf, N, fmt);
 }
 
 }  // namespace strings
 }  // namespace base
 
 #endif  // BASE_STRINGS_SAFE_SPRINTF_H_