feat userver: add non-throwing version of 'utils::FromString' to be used in performance-critical places

Relates: <https://nda.ya.ru/t/Dx1JoAAr7M6sew>
commit_hash:35d6a489bf27ea029ee691651b82802ed8c3d8db

Author: pananton

universal/include/userver/utils/from_string.hpp

@@ -9,22 +9,60 @@
 #include <charconv>
 #include <cstdint>
 #include <cstdlib>
-#include <limits>
 #include <string>
 #include <string_view>
 #include <type_traits>
-#include <typeindex>
 #include <typeinfo>
 
+#include <userver/utils/expected.hpp>
 #include <userver/utils/zstring_view.hpp>
 
 USERVER_NAMESPACE_BEGIN
 
 namespace utils {
 
+/// @brief Conversion error code.
+enum class FromStringErrorCode {
+    /// @brief String contains leading whitespace characters.
+    kLeadingSpaces = 1,
+
+    /// @brief String contains invalid (non-digit) characters at the end.
+    kTrailingJunk = 2,
+
+    /// @brief String does not contain a number.
+    kNoNumber = 3,
+
+    /// @brief Conversion result is out of the valid range of the specified type.
+    kOverflow = 4
+};
+
+/// @brief Converts @a code to string representation.
+constexpr inline std::string_view ToString(FromStringErrorCode code) noexcept {
+    switch (code) {
+        case FromStringErrorCode::kLeadingSpaces:
+            return "leading spaces are not allowed";
+        case FromStringErrorCode::kTrailingJunk:
+            return "extra junk at the end of the string is not allowed";
+        case FromStringErrorCode::kNoNumber:
+            return "no number found";
+        case FromStringErrorCode::kOverflow:
+            return "overflow";
+        default:
+            return "unknown";
+    }
+}
+
+/// @brief Function `utils::FromString` exception type.
 class FromStringException : public std::runtime_error {
 public:
-    using std::runtime_error::runtime_error;
+    /// @brief Creates exception for @a code .
+    FromStringException(FromStringErrorCode code, const std::string& what);
+
+    /// @brief Returns conversion error code.
+    FromStringErrorCode GetCode() const noexcept { return code_; }
+
+private:
+    FromStringErrorCode code_;
 };
 
 namespace impl {
@@ -48,24 +86,25 @@ template <class T>
 inline constexpr bool kIsFromCharsConvertible = IsFromCharsConvertible<T>::value;
 
 [[noreturn]] void ThrowFromStringException(
-    std::string_view message,
+    FromStringErrorCode code,
     std::string_view input,
-    std::type_index result_type
+    const std::type_info& result_type
 );
 
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T> FromString(utils::zstring_view str) {
+std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, expected<T, FromStringErrorCode>>
+FromString(utils::zstring_view str) noexcept {
     static_assert(!std::is_const_v<T> && !std::is_volatile_v<T>);
     static_assert(!std::is_reference_v<T>);
 
     if (str.empty()) {
-        impl::ThrowFromStringException("empty string", str, typeid(T));
+        return unexpected{FromStringErrorCode::kNoNumber};
     }
     if (std::isspace(str.front())) {
-        impl::ThrowFromStringException("leading spaces are not allowed", str, typeid(T));
+        return unexpected{FromStringErrorCode::kLeadingSpaces};
     }
     if (str.size() > 2 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
-        impl::ThrowFromStringException("extra junk at the end of the string is not allowed", str, typeid(T));
+        return unexpected{FromStringErrorCode::kTrailingJunk};
     }
 
     errno = 0;
@@ -82,36 +121,35 @@ std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T>
     }();
 
     if (errno == ERANGE && !(result < 1 && result > 0.0)) {
-        impl::ThrowFromStringException("overflow", str, typeid(T));
+        return unexpected{FromStringErrorCode::kOverflow};
     }
 
     if (end == str.c_str()) {
-        impl::ThrowFromStringException("no number found", str, typeid(T));
+        return unexpected{FromStringErrorCode::kNoNumber};
     }
 
     if (end != str.data() + str.size()) {
-        if (std::isspace(*end)) {
-            impl::ThrowFromStringException("trailing spaces are not allowed", str, typeid(T));
-        } else {
-            impl::ThrowFromStringException("extra junk at the end of the string is not allowed", str, typeid(T));
-        }
+        return unexpected{FromStringErrorCode::kTrailingJunk};
     }
 
     return result;
 }
 
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T> FromString(const std::string& str) {
+std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, expected<T, FromStringErrorCode>>
+FromString(const std::string& str) noexcept {
     return impl::FromString<T>(utils::zstring_view{str});
 }
 
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T> FromString(const char* str) {
+std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, expected<T, FromStringErrorCode>>
+FromString(const char* str) noexcept {
     return impl::FromString<T>(utils::zstring_view{str});
 }
 
 template <typename T>
-std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T> FromString(std::string_view str) {
+std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, expected<T, FromStringErrorCode>>
+FromString(std::string_view str) noexcept {
     static constexpr std::size_t kSmallBufferSize = 32;
 
     if (str.size() >= kSmallBufferSize) {
@@ -127,22 +165,23 @@ std::enable_if_t<std::is_floating_point_v<T> && !kIsFromCharsConvertible<T>, T>
 }
 
 template <typename T>
-std::enable_if_t<kIsFromCharsConvertible<T>, T> FromString(std::string_view str) {
+std::enable_if_t<kIsFromCharsConvertible<T>, expected<T, FromStringErrorCode>> FromString(std::string_view str
+) noexcept {
     static_assert(!std::is_const_v<T> && !std::is_volatile_v<T>);
     static_assert(!std::is_reference_v<T>);
 
     if (str.empty()) {
-        impl::ThrowFromStringException("empty string", str, typeid(T));
+        return unexpected{FromStringErrorCode::kNoNumber};
     }
     if (std::isspace(str[0])) {
-        impl::ThrowFromStringException("leading spaces are not allowed", str, typeid(T));
+        return unexpected{FromStringErrorCode::kLeadingSpaces};
     }
 
     std::size_t offset = 0;
 
     // to allow leading plus
     if (str.size() > 1 && str[0] == '+' && str[1] == '-') {
-        impl::ThrowFromStringException("no number found", str, typeid(T));
+        return unexpected{FromStringErrorCode::kNoNumber};
     }
     if (str[0] == '+') {
         offset = 1;
@@ -157,22 +196,18 @@ std::enable_if_t<kIsFromCharsConvertible<T>, T> FromString(std::string_view str)
     const auto [end, error_code] = std::from_chars(str.data() + offset, str.data() + str.size(), result);
 
     if (error_code == std::errc::result_out_of_range) {
-        impl::ThrowFromStringException("overflow", str, typeid(T));
+        return unexpected{FromStringErrorCode::kOverflow};
     }
     if (error_code == std::errc::invalid_argument) {
-        impl::ThrowFromStringException("no number found", str, typeid(T));
+        return unexpected{FromStringErrorCode::kNoNumber};
     }
 
     if (std::is_unsigned_v<T> && str[0] == '-' && result != 0) {
-        impl::ThrowFromStringException("overflow", str, typeid(T));
+        return unexpected{FromStringErrorCode::kOverflow};
     }
 
     if (end != str.data() + str.size()) {
-        if (std::isspace(*end)) {
-            impl::ThrowFromStringException("trailing spaces are not allowed", str, typeid(T));
-        } else {
-            impl::ThrowFromStringException("extra junk at the end of the string is not allowed", str, typeid(T));
-        }
+        return unexpected{FromStringErrorCode::kTrailingJunk};
     }
 
     return result;
@@ -199,6 +234,31 @@ template <
     typename StringType,
     typename = std::enable_if_t<std::is_convertible_v<StringType, std::string_view>>>
 T FromString(const StringType& str) {
+    const auto result = impl::FromString<T>(str);
+
+    if (result) {
+        return result.value();
+    } else {
+        impl::ThrowFromStringException(result.error(), str, typeid(T));
+    }
+}
+
+/// @brief Extract the number contained in the string. No space characters or
+/// other extra characters allowed. Supported types:
+///
+/// - Integer types. Leading plus or minus is allowed. The number is always
+///   base-10.
+/// - Floating-point types. The accepted number format is identical to
+///   `std::strtod`.
+///
+/// @tparam T The type of the number to be parsed
+/// @param str The string that contains the number
+/// @return `utils::expected` with the conversion result or error code
+template <
+    typename T,
+    typename StringType,
+    typename = std::enable_if_t<std::is_convertible_v<StringType, std::string_view>>>
+expected<T, FromStringErrorCode> FromStringNoThrow(const StringType& str) noexcept {
     return impl::FromString<T>(str);
 }
 

universal/src/utils/from_string.cpp

@@ -12,21 +12,25 @@ namespace utils {
 
 namespace impl {
 
-[[noreturn]] void ThrowFromStringException(
-    std::string_view message,
-    std::string_view input,
-    std::type_index result_type
-) {
-    throw FromStringException(fmt::format(
-        R"(utils::FromString error: "{}" while converting "{}" to {})",
-        message,
-        input,
-        compiler::GetTypeName(result_type)
-    ));
+void ThrowFromStringException(FromStringErrorCode code, std::string_view input, const std::type_info& result_type) {
+    throw FromStringException(
+        code,
+        fmt::format(
+            R"(utils::FromString error: "{}" while converting "{}" to {})",
+            ToString(code),
+            input,
+            compiler::GetTypeName(result_type)
+        )
+    );
 }
 
 }  // namespace impl
 
+FromStringException::FromStringException(FromStringErrorCode code, const std::string& what)
+    : std::runtime_error(what),
+      code_(code)
+{}
+
 std::int64_t FromHexString(std::string_view str) {
     std::int64_t result{};
     const auto* str_begin = str.data();

universal/src/utils/from_string_test.cpp

@@ -30,19 +30,28 @@ std::string ToString(T value) {
     }
 }
 
+template <typename T>
+std::string GetDiagnosticString(std::string_view input) {
+    return fmt::format("type = {}, input = {}", compiler::GetTypeName<T>(), input);
+}
+
 template <typename T>
 auto TestInvalid(const std::string& input) {
-    ASSERT_THROW(utils::FromString<T>(input), utils::FromStringException)
-        << "type = " << compiler::GetTypeName<T>() << ", input = \"" << input << "\"";
+    ASSERT_FALSE(utils::FromStringNoThrow<T>(input)) << GetDiagnosticString<T>(input);
+    ASSERT_THROW(utils::FromString<T>(input), utils::FromStringException) << GetDiagnosticString<T>(input);
 }
 
 template <typename StringType, typename T>
 auto CheckConverts(StringType input, T expected_result) {
     T actual_result{};
-    ASSERT_NO_THROW(actual_result = utils::FromString<T>(input))
-        << "type = " << compiler::GetTypeName<T>() << ", input = \"" << input << "\"";
-    ASSERT_EQ(actual_result, expected_result)
-        << "type = " << compiler::GetTypeName<T>() << ", input = \"" << input << "\"";
+
+    ASSERT_NO_THROW(actual_result = utils::FromStringNoThrow<T>(input).value()) << GetDiagnosticString<T>(input);
+    ASSERT_EQ(actual_result, expected_result) << GetDiagnosticString<T>(input);
+
+    actual_result = T{};
+
+    ASSERT_NO_THROW(actual_result = utils::FromString<T>(input)) << GetDiagnosticString<T>(input);
+    ASSERT_EQ(actual_result, expected_result) << GetDiagnosticString<T>(input);
 }
 
 template <typename T>