Added integer parsing functions in base/string_to_number.h

webrtc/base/string_to_number.h

Index: webrtc/base/string_to_number.h
diff --git a/webrtc/base/string_to_number.h b/webrtc/base/string_to_number.h
new file mode 100644
index 0000000000000000000000000000000000000000..d43c7e66cd296a0cf60abf5caf321f66b465afb7
--- /dev/null
+++ b/webrtc/base/string_to_number.h
@@ -0,0 +1,101 @@
+/*
+ *  Copyright 2017 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_BASE_STRING_TO_NUMBER_H_
+#define WEBRTC_BASE_STRING_TO_NUMBER_H_
+
+#include <string>
+#include <limits>
+
+#include "webrtc/base/optional.h"
+
+namespace rtc {
+
+// This file declares a family of functions to parse integers from strings.
+// The standard C library functions either fail to indicate errors (atoi, etc.)
+// or are a hassle to work with (strtol, sscanf, etc.). The standard C++ library
+// functions (std::stoi, etc.) indicate errors by throwing exceptions, which
+// are disabled in WebRTC.
+//
+// Integers are parsed using one of the following functions:
+//   rtc::Optional<int-type> StringToNumber(const char* str, int base = 10);
+//   rtc::Optional<int-type> StringToNumber(const std::string& str,
+//                                          int base = 10);
+//
+// These functions parse a value from the beginning of a string into one of the
+// fundamental integer types, or returns an empty Optional if parsing
+// failed. Values outside of the range supported by the type will be
+// rejected. The strings must begin with a digit or a minus sign. No leading
+// space nor trailing contents are allowed.
+// By setting base to 0, one of octal, decimal or hexadecimal will be
+// detected from the string's prefix (0, nothing or 0x, respectively).
+// If non-zero, base can be set to a value between 2 and 36 inclusively.
+//
+// If desired, this interface could be extended with support for floating-point
+// types.
+
+namespace string_to_number_internal {
+// These must be (unsigned) long long, to match the signature of strto(u)ll.

[kwiberg-webrtc, 2017/04/05 09:01:15]

I suppose you *could* use [u]intmax_t, and just static_assert that their ranges
are at least as large as that of [unsigned] long long (they're supposed to be),
but it seems much simpler to use the actual correct types like you do here, and
suppressing the lint warnings.

(Why does lint not like long long, by the way?)

[ossu, 2017/04/05 10:15:36]

Lint doesn't like any of the non stdint types, except for int and char, I think.
Essentially, if you want to size your integers, it wants you to use the types
with explicit sizes, to avoid errors.

[kwiberg-webrtc, 2017/04/05 10:55:38]

Acknowledged.

+using unsigned_type = unsigned long long;  // NOLINT(runtime/int)
+using signed_type = long long;  // NOLINT(runtime/int)
+
+rtc::Optional<signed_type> ParseSigned(const char* str, int base);
+rtc::Optional<unsigned_type> ParseUnsigned(const char* str, int base);

[kwiberg-webrtc, 2017/04/05 09:01:15]

Consider letting these take min and max arguments. That way, the logic that
tests if the parsed number is in range of the type could move out of the inlined
templated functions.

[ossu, 2017/04/05 10:15:36]

The templated function would still do the type conversion, so I think it's
clearer to have the check there.

[kwiberg-webrtc, 2017/04/05 10:55:38]

But more code to inline. But fair enough, either way works.

+}  // namespace string_to_number_internal
+
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,
+                        rtc::Optional<T>>::type
+StringToNumber(const char* str, int base = 10) {
+  using string_to_number_internal::signed_type;
+  static_assert(
+      std::numeric_limits<T>::max() <=
+              std::numeric_limits<signed_type>::max() &&
+          std::numeric_limits<T>::lowest() >=
+              std::numeric_limits<signed_type>::lowest(),
+      "StringToNumber only supports signed integers as large as long long int");
+  rtc::Optional<signed_type> value =
+      string_to_number_internal::ParseSigned(str, base);
+  if (value && *value >= std::numeric_limits<T>::min() &&

[kwiberg-webrtc, 2017/04/05 09:01:15]

::lowest()? Doesn't matter for integers, but nice to be consistent.

[ossu, 2017/04/05 10:15:36]

Will do!

+      *value <= std::numeric_limits<T>::max()) {
+    return rtc::Optional<T>(static_cast<T>(*value));

[kwiberg-webrtc, 2017/04/05 09:01:15]

dchecked_cast? It exists now!

[ossu, 2017/04/05 10:15:36]

I've _just_ checked the ranges. I'm not going to do it again!

[kwiberg-webrtc, 2017/04/05 10:55:38]

Well, that's what dchecked_cast means: "I promise that this cast will not fail
to preserve the value in the new type". It won't actually check that you're
telling the truth (except in debug builds).

+  }
+  return rtc::Optional<T>();
+}
+
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value &&
+                            std::is_unsigned<T>::value,
+                        rtc::Optional<T>>::type
+StringToNumber(const char* str, int base = 10) {
+  using string_to_number_internal::unsigned_type;
+  static_assert(std::numeric_limits<T>::max() <=
+                    std::numeric_limits<unsigned_type>::max(),
+                "StringToNumber only supports unsigned integers as large as "
+                "unsigned long long int");
+  rtc::Optional<unsigned_type> value =
+      string_to_number_internal::ParseUnsigned(str, base);
+  if (value && *value <= std::numeric_limits<T>::max()) {
+    return rtc::Optional<T>(static_cast<T>(*value));

[kwiberg-webrtc, 2017/04/05 09:01:15]

dchecked_cast?

[ossu, 2017/04/05 10:15:36]

See above. :)

+  }
+  return rtc::Optional<T>();
+}
+
+// The std::string overloads only exists if there is a matching const char*
+// version.
+template <typename T>
+auto StringToNumber(const std::string& str, int base = 10)
+    -> decltype(StringToNumber<T>(str.c_str(), base)) {
+  return StringToNumber<T>(str.c_str(), base);
+}
+
+}  // namespace rtc
+
+#endif  // WEBRTC_BASE_STRING_TO_NUMBER_H_