Use std::from_chars.

3 files changed, 0 insertions, 294 deletions

diff --git a/src/base/CMakeLists.txt b/src/base/CMakeLists.txt
index 7e7b0127..685ceb8c 100644
--- a/src/base/CMakeLists.txt
+++ b/src/base/CMakeLists.txt
@@ -5,7 +5,6 @@ add_library(CruBase
 	Format.cpp
 	PropertyTree.cpp
 	String.cpp
-	StringToNumberConverter.cpp
 	StringUtil.cpp
 	SubProcess.cpp
 	io/AutoReadStream.cpp
@@ -85,5 +84,3 @@ else()
 		CRU_PLATFORM_UNIX
 	)
 endif()
-
-target_link_libraries(CruBase PUBLIC double-conversion)
diff --git a/src/base/String.cpp b/src/base/String.cpp
index c90b9a71..c96b898d 100644
--- a/src/base/String.cpp
+++ b/src/base/String.cpp
@@ -2,14 +2,9 @@
 
 #include "cru/base/Buffer.h"
 #include "cru/base/Exception.h"
-#include "cru/base/StringToNumberConverter.h"
 #include "cru/base/StringUtil.h"
 
-#include <double-conversion/double-conversion.h>
-#include <double-conversion/string-to-double.h>
-
 #include <algorithm>
-#include <cmath>
 #include <cstring>
 #include <functional>
 
@@ -344,34 +339,6 @@ Range String::RangeFromCodePointToCodeUnit(Range code_point_range) const {
   return View().RangeFromCodePointToCodeUnit(code_point_range);
 }
 
-int String::ParseToInt(Index* processed_characters_count,
-                       StringToNumberFlag flags, int base) const {
-  return View().ParseToInt(processed_characters_count, flags, base);
-}
-
-long long String::ParseToLongLong(Index* processed_characters_count,
-                                  StringToNumberFlag flags, int base) const {
-  return View().ParseToLongLong(processed_characters_count, flags, base);
-}
-
-float String::ParseToFloat(Index* processed_characters_count,
-                           StringToNumberFlag flags) const {
-  return View().ParseToFloat(processed_characters_count, flags);
-}
-
-double String::ParseToDouble(Index* processed_characters_count,
-                             StringToNumberFlag flags) const {
-  return View().ParseToDouble(processed_characters_count, flags);
-}
-
-std::vector<float> String::ParseToFloatList(value_type separator) const {
-  return View().ParseToFloatList(separator);
-}
-
-std::vector<double> String::ParseToDoubleList(value_type separator) const {
-  return View().ParseToDoubleList(separator);
-}
-
 std::ostream& operator<<(std::ostream& os, const String& value) {
   os << value.ToUtf8();
   return os;
@@ -583,94 +550,6 @@ Buffer StringView::ToUtf8Buffer(bool end_zero) const {
   return buffer;
 }
 
-int StringView::ParseToInt(Index* processed_characters_count,
-                           StringToNumberFlag flags, int base) const {
-  return ParseToInteger<int>(processed_characters_count, flags, base);
-}
-
-long long StringView::ParseToLongLong(Index* processed_characters_count,
-                                      StringToNumberFlag flags,
-                                      int base) const {
-  return ParseToInteger<long long>(processed_characters_count, flags, base);
-}
-
-static int MapStringToDoubleFlags(StringToNumberFlag flags) {
-  int f = double_conversion::StringToDoubleConverter::ALLOW_CASE_INSENSIBILITY;
-  if (flags & StringToNumberFlags::kAllowLeadingSpaces) {
-    f |= double_conversion::StringToDoubleConverter::ALLOW_LEADING_SPACES;
-  }
-  if (flags & StringToNumberFlags::kAllowTrailingSpaces) {
-    f |= double_conversion::StringToDoubleConverter::ALLOW_TRAILING_SPACES;
-  }
-  if (flags & StringToNumberFlags::kAllowTrailingJunk) {
-    f |= double_conversion::StringToDoubleConverter::ALLOW_TRAILING_JUNK;
-  }
-  return f;
-}
-
-static double_conversion::StringToDoubleConverter CreateStringToDoubleConverter(
-    StringToNumberFlag flags) {
-  return {MapStringToDoubleFlags(flags), 0.0, NAN, "inf", "nan"};
-}
-
-float StringView::ParseToFloat(Index* processed_characters_count,
-                               StringToNumberFlag flags) const {
-  int pcc;
-  auto result = CreateStringToDoubleConverter(flags).StringToFloat(
-      reinterpret_cast<const uc16*>(ptr_), static_cast<int>(size_), &pcc);
-  if (processed_characters_count != nullptr) {
-    *processed_characters_count = pcc;
-  }
-
-  if (flags & StringToNumberFlags::kThrowOnError && std::isnan(result)) {
-    throw Exception("Result of string to float conversion is NaN");
-  }
-
-  return result;
-}
-
-double StringView::ParseToDouble(Index* processed_characters_count,
-                                 StringToNumberFlag flags) const {
-  int pcc;
-  auto result = CreateStringToDoubleConverter(flags).StringToDouble(
-      reinterpret_cast<const uc16*>(ptr_), static_cast<int>(size_), &pcc);
-  if (processed_characters_count != nullptr) {
-    *processed_characters_count = pcc;
-  }
-
-  if (flags & StringToNumberFlags::kThrowOnError && std::isnan(result)) {
-    throw Exception("Result of string to double conversion is NaN");
-  }
-
-  return result;
-}
-
-std::vector<float> StringView::ParseToFloatList(value_type separator) const {
-  std::vector<float> result;
-  auto list = Split(separator, true);
-  for (auto& item : list) {
-    auto value = item.ParseToFloat();
-    if (std::isnan(value)) {
-      throw Exception("Invalid double value.");
-    }
-    result.push_back(value);
-  }
-  return result;
-}
-
-std::vector<double> StringView::ParseToDoubleList(value_type separator) const {
-  std::vector<double> result;
-  auto list = Split(separator, true);
-  for (auto& item : list) {
-    auto value = item.ParseToDouble();
-    if (std::isnan(value)) {
-      throw Exception("Invalid double value.");
-    }
-    result.push_back(value);
-  }
-  return result;
-}
-
 String ToLower(StringView s) {
   String result;
   for (auto c : s) result.push_back(ToLower(c));
diff --git a/src/base/StringToNumberConverter.cpp b/src/base/StringToNumberConverter.cpp
deleted file mode 100644
index f7516630..00000000
--- a/src/base/StringToNumberConverter.cpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#include "cru/base/StringToNumberConverter.h"
-#include "cru/base/Exception.h"
-
-namespace cru {
-bool StringToIntegerConverter::CheckParams() const {
-  return base == 0 || base >= 2 & base <= 36;
-}
-
-static bool IsSpace(char c) {
-  return c == ' ' || c == '\t' || c == '\n' || c == '\r';
-}
-
-StringToIntegerResult StringToIntegerConverter::Parse(
-    const char* const str, const Index size,
-    Index* processed_characters_count) const {
-  if (str == nullptr) throw std::invalid_argument("Invalid str.");
-  if (size < 0) throw std::invalid_argument("Invalid size.");
-  if (!CheckParams()) throw std::invalid_argument("Invalid parsing flags.");
-
-  const bool throw_on_error = flags.Has(StringToNumberFlags::kThrowOnError);
-
-  auto const end = str + size;
-
-  auto current = str;
-
-  if (flags & StringToNumberFlags::kAllowLeadingSpaces) {
-    while (current != end && IsSpace(*current)) {
-      current++;
-    }
-  }
-
-  if (current == end) {
-    if (processed_characters_count) {
-      *processed_characters_count = 0;
-    }
-    if (throw_on_error) {
-      throw Exception("Empty string (after reading leading spaces).");
-    } else {
-      return {false, 0};
-    }
-  }
-
-  bool negate = false;
-
-  if (*current == '-') {
-    ++current;
-    negate = true;
-  } else if (*current == '+') {
-    ++current;
-  }
-
-  if (current == end) {
-    if (processed_characters_count) {
-      *processed_characters_count = 0;
-    }
-    if (throw_on_error) {
-      throw Exception("Empty string (after reading sign).");
-    } else {
-      return {false, 0};
-    }
-  }
-
-  int real_base = base;
-
-  if (real_base == 0) {
-    if (*current == '0') {
-      ++current;
-      if (current == end) {
-        if (processed_characters_count) {
-          *processed_characters_count = current - str;
-        }
-        return {negate, 0};
-      } else if (*current == 'x' || *current == 'X') {
-        ++current;
-        real_base = 16;
-      } else if (*current == 'b' || *current == 'B') {
-        ++current;
-        real_base = 2;
-      } else {
-        real_base = 8;
-      }
-    } else {
-      real_base = 10;
-    }
-  }
-
-  if (current == end) {
-    if (processed_characters_count) {
-      *processed_characters_count = 0;
-    }
-    if (throw_on_error) {
-      throw Exception("Empty string (after reading head base indicator).");
-    } else {
-      return {false, 0};
-    }
-  }
-
-  const bool allow_leading_zero =
-      flags.Has(StringToNumberFlags::kAllowLeadingZeroForInteger);
-
-  while (current != end && *current == '0') {
-    current++;
-  }
-
-  if (current == end) {
-    if (processed_characters_count) {
-      *processed_characters_count = current - str;
-    }
-    return {negate, 0};
-  }
-
-  const bool allow_trailing_junk =
-      flags.Has(StringToNumberFlags::kAllowTrailingJunk);
-  const bool allow_trailing_spaces =
-      flags.Has(StringToNumberFlags::kAllowTrailingSpaces);
-
-  unsigned long long result = 0;
-
-  while (current != end) {
-    const char c = *current;
-    if (c >= '0' && c <= (real_base > 10 ? '9' : real_base + '0' - 1)) {
-      result = result * real_base + c - '0';
-      current++;
-    } else if (real_base > 10 && c >= 'a' && c <= (real_base + 'a' - 10 - 1)) {
-      result = result * real_base + c - 'a' + 10;
-      current++;
-    } else if (real_base > 10 && c >= 'A' && c <= (real_base + 'A' - 10 - 1)) {
-      result = result * real_base + c - 'A' + 10;
-      current++;
-    } else if (allow_trailing_junk) {
-      break;
-    } else if (allow_trailing_spaces && IsSpace(c)) {
-      break;
-    } else {
-      if (processed_characters_count) {
-        *processed_characters_count = 0;
-      }
-      if (throw_on_error) {
-        throw Exception(std::string("Read invalid character '") + c + "'.");
-      } else {
-        return {false, 0};
-      }
-    }
-  }
-
-  if (allow_trailing_spaces) {
-    while (current != end && IsSpace(*current)) {
-      current++;
-    }
-
-    if (current != end) {
-      if (processed_characters_count) {
-        *processed_characters_count = 0;
-      }
-      if (throw_on_error) {
-        throw Exception("There is trailing junk.");
-      } else {
-        return {false, 0};
-      }
-    }
-  }
-
-  if (processed_characters_count) {
-    *processed_characters_count = current - str;
-  }
-
-  return {negate, result};
-}
-
-}  // namespace cru