decstr_to_integer -> dec_to_integer

danielaparker · danielaparker · commit 156d2efacb77 · 2025-05-16T13:12:56.000-04:00
diff --git a/include/jsoncons/json_parser.hpp b/include/jsoncons/json_parser.hpp
@@ -2432,7 +2432,7 @@ class basic_json_parser : public ser_context
     void end_negative_value(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);
         if (result)
         {
             visitor.int64_value(val, semantic_tag::none, *this, ec);
@@ -2449,7 +2449,7 @@ class basic_json_parser : public ser_context
     void end_positive_value(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
         uint64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);
         if (result)
         {
             visitor.uint64_value(val, semantic_tag::none, *this, ec);
diff --git a/include/jsoncons/json_type_traits.hpp b/include/jsoncons/json_type_traits.hpp
@@ -1656,7 +1656,7 @@ namespace variant_detail
                     {
                         auto sv = j.as_string_view();
                         Rep n{0};
-                        auto result = jsoncons::utility::decstr_to_integer(sv.data(), sv.size(), n);
+                        auto result = jsoncons::utility::dec_to_integer(sv.data(), sv.size(), n);
                         if (!result)
                         {
                             return duration_type();
diff --git a/include/jsoncons/reflect/json_conv_traits.hpp b/include/jsoncons/reflect/json_conv_traits.hpp
@@ -1688,7 +1688,7 @@ namespace variant_detail
                     {
                         auto sv = j.as_string_view();
                         Rep n{0};
-                        auto result = jsoncons::utility::decstr_to_integer(sv.data(), sv.size(), n);
+                        auto result = jsoncons::utility::dec_to_integer(sv.data(), sv.size(), n);
                         if (!result)
                         {
                             return duration_type();
diff --git a/include/jsoncons/utility/read_number.hpp b/include/jsoncons/utility/read_number.hpp
@@ -262,7 +262,7 @@ bool is_base16(const CharT* s, std::size_t length)
     
 template <typename T,typename CharT>
 typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && !ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type
-decstr_to_integer(const CharT* s, std::size_t length, T& value)
+dec_to_integer(const CharT* s, std::size_t length, T& value)
 {
     if (length == 0)
     {
@@ -324,7 +324,7 @@ decstr_to_integer(const CharT* s, std::size_t length, T& value)
 
 template <typename T,typename CharT>
 typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type
-decstr_to_integer(const CharT* s, std::size_t length, T& value)
+dec_to_integer(const CharT* s, std::size_t length, T& value)
 {
     if (length == 0)
     {
@@ -338,7 +338,7 @@ decstr_to_integer(const CharT* s, std::size_t length, T& value)
     using U = typename ext_traits::make_unsigned<T>::type;
 
     U num;
-    auto ru = decstr_to_integer(s, length, num);
+    auto ru = dec_to_integer(s, length, num);
     if (ru.ec != std::errc())
     {
         return to_number_result<CharT>(ru.ptr, ru.ec);
@@ -611,11 +611,11 @@ to_integer(const CharT* s, T& n)
     return to_integer<T,CharT>(s, std::char_traits<CharT>::length(s), n);
 }
 
-// hexstr_to_integer
+// hex_to_integer
 
 template <typename T,typename CharT>
 typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type
-hexstr_to_integer(const CharT* s, std::size_t length, T& n)
+hex_to_integer(const CharT* s, std::size_t length, T& n)
 {
     static_assert(ext_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
     JSONCONS_ASSERT(length > 0);
@@ -699,7 +699,7 @@ hexstr_to_integer(const CharT* s, std::size_t length, T& n)
 
 template <typename T,typename CharT>
 typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && !ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type
-hexstr_to_integer(const CharT* s, std::size_t length, T& n)
+hex_to_integer(const CharT* s, std::size_t length, T& n)
 {
     static_assert(ext_traits::integer_limits<T>::is_specialized, "Integer type not specialized");
     JSONCONS_ASSERT(length > 0);
diff --git a/include/jsoncons/utility/uri.hpp b/include/jsoncons/utility/uri.hpp
@@ -710,7 +710,7 @@ namespace jsoncons {
                     auto hex = encoded.substr(i + 1, 2);
 
                     uint8_t n;
-                    jsoncons::utility::hexstr_to_integer<uint8_t>(hex.data(), hex.size(), n);
+                    jsoncons::utility::hex_to_integer<uint8_t>(hex.data(), hex.size(), n);
                     decoded.push_back((char)n);
                     i += 3;
                 }
diff --git a/include/jsoncons_ext/cbor/cbor_encoder.hpp b/include/jsoncons_ext/cbor/cbor_encoder.hpp
@@ -871,7 +871,7 @@ class basic_cbor_encoder final : public basic_json_visitor<char>
         if (exponent.length() > 0)
         {
             int64_t val{ 0 };
-            auto r = jsoncons::utility::hexstr_to_integer(exponent.data(), exponent.length(), val);
+            auto r = jsoncons::utility::hex_to_integer(exponent.data(), exponent.length(), val);
             if (!r)
             {
                 ec = r.error_code();
@@ -883,7 +883,7 @@ class basic_cbor_encoder final : public basic_json_visitor<char>
         if (JSONCONS_UNLIKELY(ec)) return;
 
         int64_t val{ 0 };
-        auto r = jsoncons::utility::hexstr_to_integer(s.data(),s.length(), val);
+        auto r = jsoncons::utility::hex_to_integer(s.data(),s.length(), val);
         if (r)
         {
             visit_int64(val, semantic_tag::none, context, ec);
diff --git a/include/jsoncons_ext/csv/csv_parser.hpp b/include/jsoncons_ext/csv/csv_parser.hpp
@@ -2261,7 +2261,7 @@ class basic_csv_parser : public ser_context
                 if (is_negative)
                 {
                     int64_t val{ 0 };
-                    auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);
+                    auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);
                     if (result)
                     {
                         visitor.int64_value(val, semantic_tag::none, *this, ec);
@@ -2276,7 +2276,7 @@ class basic_csv_parser : public ser_context
                 else
                 {
                     uint64_t val{ 0 };
-                    auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);
+                    auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);
                     if (result)
                     {
                         visitor.uint64_value(val, semantic_tag::none, *this, ec);
diff --git a/include/jsoncons_ext/jsonpath/jsonpath_selector.hpp b/include/jsoncons_ext/jsonpath/jsonpath_selector.hpp
@@ -269,7 +269,7 @@ namespace detail {
             else if (current.is_array())
             {
                 int64_t n{0};
-                auto r = jsoncons::utility::decstr_to_integer(identifier_.data(), identifier_.size(), n);
+                auto r = jsoncons::utility::dec_to_integer(identifier_.data(), identifier_.size(), n);
                 if (r)
                 {
                     auto index = (n >= 0) ? static_cast<std::size_t>(n) : static_cast<std::size_t>(static_cast<int64_t>(current.size()) + n);
@@ -322,7 +322,7 @@ namespace detail {
             if (current.is_array())
             {
                 int64_t n{0};
-                auto r = jsoncons::utility::decstr_to_integer(identifier_.data(), identifier_.size(), n);
+                auto r = jsoncons::utility::dec_to_integer(identifier_.data(), identifier_.size(), n);
                 if (r)
                 {
                     auto index = (n >= 0) ? static_cast<std::size_t>(n) : static_cast<std::size_t>(static_cast<int64_t>(current.size()) + n);
diff --git a/include/jsoncons_ext/jsonpointer/jsonpointer.hpp b/include/jsoncons_ext/jsonpointer/jsonpointer.hpp
@@ -405,7 +405,7 @@ namespace jsonpointer {
                 return current;
             }
             std::size_t index{0};
-            auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+            auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
             if (!result)
             {
                 ec = jsonpointer_errc::invalid_index;
@@ -446,7 +446,7 @@ namespace jsonpointer {
                 return current;
             }
             std::size_t index{0};
-            auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+            auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
             if (!result)
             {
                 ec = jsonpointer_errc::invalid_index;
@@ -690,7 +690,7 @@ namespace jsonpointer {
             else
             {
                 std::size_t index{0};
-                auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+                auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
                 if (!result)
                 {
                     ec = jsonpointer_errc::invalid_index;
@@ -826,7 +826,7 @@ namespace jsonpointer {
             else
             {
                 std::size_t index{0};
-                auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+                auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
                 if (!result)
                 {
                     ec = jsonpointer_errc::invalid_index;
@@ -965,7 +965,7 @@ namespace jsonpointer {
             else
             {
                 std::size_t index{0};
-                auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+                auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
                 if (!result)
                 {
                     ec = jsonpointer_errc::invalid_index;
@@ -1069,7 +1069,7 @@ namespace jsonpointer {
             else
             {
                 std::size_t index{};
-                auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);
+                auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);
                 if (!result)
                 {
                     ec = jsonpointer_errc::invalid_index;
@@ -1290,7 +1290,7 @@ namespace jsonpointer {
         for (const auto& item : value.object_range())
         {
             std::size_t n;
-            auto r = jsoncons::utility::decstr_to_integer(item.key().data(),item.key().size(), n);
+            auto r = jsoncons::utility::dec_to_integer(item.key().data(),item.key().size(), n);
             if (!r || (index++ != n))
             {
                 safe = false;
@@ -1344,7 +1344,7 @@ namespace jsonpointer {
             {
                 auto s = *it;
                 std::size_t n{0};
-                auto r = jsoncons::utility::decstr_to_integer(s.data(), s.size(), n);
+                auto r = jsoncons::utility::dec_to_integer(s.data(), s.size(), n);
                 if (r.ec == std::errc() && (index++ == n))
                 {
                     if (!part->is_array())
diff --git a/test/corelib/src/json_as_tests.cpp b/test/corelib/src/json_as_tests.cpp
@@ -109,7 +109,7 @@ TEST_CASE("json::as<__int128>()")
     std::string s1 = "-18446744073709551617";
 
     __int128 n;
-    auto result = jsoncons::utility::decstr_to_integer(s1.data(),s1.size(), n);
+    auto result = jsoncons::utility::dec_to_integer(s1.data(),s1.size(), n);
     REQUIRE(result.ec == std::errc());
 
     jsoncons::json doc(s1);
@@ -131,7 +131,7 @@ TEST_CASE("json::as<unsigned __int128>()")
 
     unsigned __int128 n;
 
-    auto result = jsoncons::utility::decstr_to_integer(s1.data(),s1.size(), n);
+    auto result = jsoncons::utility::dec_to_integer(s1.data(),s1.size(), n);
     REQUIRE(result.ec == std::errc());
 
     jsoncons::json doc(s1);
diff --git a/test/corelib/src/utility/read_number_tests.cpp b/test/corelib/src/utility/read_number_tests.cpp
@@ -68,64 +68,64 @@ TEST_CASE("jsoncons::utility::to_integer tests")
     }
 }
 
-TEST_CASE("utility::decstr_to_integer tests")
+TEST_CASE("utility::dec_to_integer tests")
 {
     SECTION("")
     {
         std::string s = "-";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE_FALSE(result);
         CHECK(result.ec == std::errc::invalid_argument);
     }
     SECTION("-")
     {
         std::string s = "-";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE_FALSE(result);
         CHECK(result.ec == std::errc::invalid_argument);
     }
     SECTION("max uint64_t")
     {
         std::string s = std::to_string((std::numeric_limits<uint64_t>::max)());
         uint64_t value{ 0 };
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), value);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), value);
         REQUIRE(result);
         CHECK(value == (std::numeric_limits<uint64_t>::max)());
         s.push_back('0');
-        auto result2 = jsoncons::utility::decstr_to_integer(s.data(), s.length(), value);
+        auto result2 = jsoncons::utility::dec_to_integer(s.data(), s.length(), value);
         REQUIRE_FALSE(result2);
     }
     SECTION("min int64_t")
     {
         std::string s = "-9223372036854775808";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE(result);
         CHECK(val == (std::numeric_limits<int64_t>::min)());
     }
     SECTION("max int64_t")
     {
         std::string s = "9223372036854775807";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE(result);
         CHECK(val == (std::numeric_limits<int64_t>::max)());
     }
     SECTION("min int64_t - 1")
     {
         std::string s = "-9223372036854775809";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE_FALSE(result);
         CHECK(result.ec == std::errc::result_out_of_range);
     }
     SECTION("max int64_t + 1")
     {
         std::string s = "9223372036854775808";
         int64_t val;
-        auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);
+        auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);
         REQUIRE_FALSE(result);
         CHECK(result.ec == std::errc::result_out_of_range);
     }

Original file line number	Diff line number	Diff line change
`@@ -2432,7 +2432,7 @@ class basic_json_parser : public ser_context`
`2432`	`2432`	`void end_negative_value(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`2433`	`2433`	`{`
`2434`	`2434`	`int64_t val;`
`2435`		`- auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);`
	`2435`	`+ auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);`
`2436`	`2436`	`if (result)`
`2437`	`2437`	`{`
`2438`	`2438`	`visitor.int64_value(val, semantic_tag::none, *this, ec);`
`@@ -2449,7 +2449,7 @@ class basic_json_parser : public ser_context`
`2449`	`2449`	`void end_positive_value(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`2450`	`2450`	`{`
`2451`	`2451`	`uint64_t val;`
`2452`		`- auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);`
	`2452`	`+ auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);`
`2453`	`2453`	`if (result)`
`2454`	`2454`	`{`
`2455`	`2455`	`visitor.uint64_value(val, semantic_tag::none, *this, ec);`
Original file line number	Diff line number	Diff line change
`@@ -1656,7 +1656,7 @@ namespace variant_detail`
`1656`	`1656`	`{`
`1657`	`1657`	`auto sv = j.as_string_view();`
`1658`	`1658`	`Rep n{0};`
`1659`		`- auto result = jsoncons::utility::decstr_to_integer(sv.data(), sv.size(), n);`
	`1659`	`+ auto result = jsoncons::utility::dec_to_integer(sv.data(), sv.size(), n);`
`1660`	`1660`	`if (!result)`
`1661`	`1661`	`{`
`1662`	`1662`	`return duration_type();`
Original file line number	Diff line number	Diff line change
`@@ -1688,7 +1688,7 @@ namespace variant_detail`
`1688`	`1688`	`{`
`1689`	`1689`	`auto sv = j.as_string_view();`
`1690`	`1690`	`Rep n{0};`
`1691`		`- auto result = jsoncons::utility::decstr_to_integer(sv.data(), sv.size(), n);`
	`1691`	`+ auto result = jsoncons::utility::dec_to_integer(sv.data(), sv.size(), n);`
`1692`	`1692`	`if (!result)`
`1693`	`1693`	`{`
`1694`	`1694`	`return duration_type();`
Original file line number	Diff line number	Diff line change
`@@ -262,7 +262,7 @@ bool is_base16(const CharT* s, std::size_t length)`
`262`	`262`
`263`	`263`	`template <typename T,typename CharT>`
`264`	`264`	`typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && !ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type`
`265`		`-decstr_to_integer(const CharT* s, std::size_t length, T& value)`
	`265`	`+dec_to_integer(const CharT* s, std::size_t length, T& value)`
`266`	`266`	`{`
`267`	`267`	`if (length == 0)`
`268`	`268`	`{`
`@@ -324,7 +324,7 @@ decstr_to_integer(const CharT* s, std::size_t length, T& value)`
`324`	`324`
`325`	`325`	`template <typename T,typename CharT>`
`326`	`326`	`typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type`
`327`		`-decstr_to_integer(const CharT* s, std::size_t length, T& value)`
	`327`	`+dec_to_integer(const CharT* s, std::size_t length, T& value)`
`328`	`328`	`{`
`329`	`329`	`if (length == 0)`
`330`	`330`	`{`
`@@ -338,7 +338,7 @@ decstr_to_integer(const CharT* s, std::size_t length, T& value)`
`338`	`338`	`using U = typename ext_traits::make_unsigned<T>::type;`
`339`	`339`
`340`	`340`	`U num;`
`341`		`- auto ru = decstr_to_integer(s, length, num);`
	`341`	`+ auto ru = dec_to_integer(s, length, num);`
`342`	`342`	`if (ru.ec != std::errc())`
`343`	`343`	`{`
`344`	`344`	`return to_number_result<CharT>(ru.ptr, ru.ec);`
`@@ -611,11 +611,11 @@ to_integer(const CharT* s, T& n)`
`611`	`611`	`return to_integer<T,CharT>(s, std::char_traits<CharT>::length(s), n);`
`612`	`612`	`}`
`613`	`613`
`614`		`-// hexstr_to_integer`
	`614`	`+// hex_to_integer`
`615`	`615`
`616`	`616`	`template <typename T,typename CharT>`
`617`	`617`	`typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type`
`618`		`-hexstr_to_integer(const CharT* s, std::size_t length, T& n)`
	`618`	`+hex_to_integer(const CharT* s, std::size_t length, T& n)`
`619`	`619`	`{`
`620`	`620`	`static_assert(ext_traits::integer_limits<T>::is_specialized, "Integer type not specialized");`
`621`	`621`	`JSONCONS_ASSERT(length > 0);`
`@@ -699,7 +699,7 @@ hexstr_to_integer(const CharT* s, std::size_t length, T& n)`
`699`	`699`
`700`	`700`	`template <typename T,typename CharT>`
`701`	`701`	`typename std::enable_if<ext_traits::integer_limits<T>::is_specialized && !ext_traits::integer_limits<T>::is_signed,to_number_result<CharT>>::type`
`702`		`-hexstr_to_integer(const CharT* s, std::size_t length, T& n)`
	`702`	`+hex_to_integer(const CharT* s, std::size_t length, T& n)`
`703`	`703`	`{`
`704`	`704`	`static_assert(ext_traits::integer_limits<T>::is_specialized, "Integer type not specialized");`
`705`	`705`	`JSONCONS_ASSERT(length > 0);`
Original file line number	Diff line number	Diff line change
`@@ -710,7 +710,7 @@ namespace jsoncons {`
`710`	`710`	`auto hex = encoded.substr(i + 1, 2);`
`711`	`711`
`712`	`712`	`uint8_t n;`
`713`		`- jsoncons::utility::hexstr_to_integer<uint8_t>(hex.data(), hex.size(), n);`
	`713`	`+ jsoncons::utility::hex_to_integer<uint8_t>(hex.data(), hex.size(), n);`
`714`	`714`	`decoded.push_back((char)n);`
`715`	`715`	`i += 3;`
`716`	`716`	`}`
Original file line number	Diff line number	Diff line change
`@@ -871,7 +871,7 @@ class basic_cbor_encoder final : public basic_json_visitor<char>`
`871`	`871`	`if (exponent.length() > 0)`
`872`	`872`	`{`
`873`	`873`	`int64_t val{ 0 };`
`874`		`- auto r = jsoncons::utility::hexstr_to_integer(exponent.data(), exponent.length(), val);`
	`874`	`+ auto r = jsoncons::utility::hex_to_integer(exponent.data(), exponent.length(), val);`
`875`	`875`	`if (!r)`
`876`	`876`	`{`
`877`	`877`	`ec = r.error_code();`
`@@ -883,7 +883,7 @@ class basic_cbor_encoder final : public basic_json_visitor<char>`
`883`	`883`	`if (JSONCONS_UNLIKELY(ec)) return;`
`884`	`884`
`885`	`885`	`int64_t val{ 0 };`
`886`		`- auto r = jsoncons::utility::hexstr_to_integer(s.data(),s.length(), val);`
	`886`	`+ auto r = jsoncons::utility::hex_to_integer(s.data(),s.length(), val);`
`887`	`887`	`if (r)`
`888`	`888`	`{`
`889`	`889`	`visit_int64(val, semantic_tag::none, context, ec);`
Original file line number	Diff line number	Diff line change
`@@ -2261,7 +2261,7 @@ class basic_csv_parser : public ser_context`
`2261`	`2261`	`if (is_negative)`
`2262`	`2262`	`{`
`2263`	`2263`	`int64_t val{ 0 };`
`2264`		`- auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);`
	`2264`	`+ auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);`
`2265`	`2265`	`if (result)`
`2266`	`2266`	`{`
`2267`	`2267`	`visitor.int64_value(val, semantic_tag::none, *this, ec);`
`@@ -2276,7 +2276,7 @@ class basic_csv_parser : public ser_context`
`2276`	`2276`	`else`
`2277`	`2277`	`{`
`2278`	`2278`	`uint64_t val{ 0 };`
`2279`		`- auto result = jsoncons::utility::decstr_to_integer(buffer_.data(), buffer_.length(), val);`
	`2279`	`+ auto result = jsoncons::utility::dec_to_integer(buffer_.data(), buffer_.length(), val);`
`2280`	`2280`	`if (result)`
`2281`	`2281`	`{`
`2282`	`2282`	`visitor.uint64_value(val, semantic_tag::none, *this, ec);`
Original file line number	Diff line number	Diff line change
`@@ -269,7 +269,7 @@ namespace detail {`
`269`	`269`	`else if (current.is_array())`
`270`	`270`	`{`
`271`	`271`	`int64_t n{0};`
`272`		`- auto r = jsoncons::utility::decstr_to_integer(identifier_.data(), identifier_.size(), n);`
	`272`	`+ auto r = jsoncons::utility::dec_to_integer(identifier_.data(), identifier_.size(), n);`
`273`	`273`	`if (r)`
`274`	`274`	`{`
`275`	`275`	`auto index = (n >= 0) ? static_cast<std::size_t>(n) : static_cast<std::size_t>(static_cast<int64_t>(current.size()) + n);`
`@@ -322,7 +322,7 @@ namespace detail {`
`322`	`322`	`if (current.is_array())`
`323`	`323`	`{`
`324`	`324`	`int64_t n{0};`
`325`		`- auto r = jsoncons::utility::decstr_to_integer(identifier_.data(), identifier_.size(), n);`
	`325`	`+ auto r = jsoncons::utility::dec_to_integer(identifier_.data(), identifier_.size(), n);`
`326`	`326`	`if (r)`
`327`	`327`	`{`
`328`	`328`	`auto index = (n >= 0) ? static_cast<std::size_t>(n) : static_cast<std::size_t>(static_cast<int64_t>(current.size()) + n);`
Original file line number	Diff line number	Diff line change
`@@ -405,7 +405,7 @@ namespace jsonpointer {`
`405`	`405`	`return current;`
`406`	`406`	`}`
`407`	`407`	`std::size_t index{0};`
`408`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`408`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`409`	`409`	`if (!result)`
`410`	`410`	`{`
`411`	`411`	`ec = jsonpointer_errc::invalid_index;`
`@@ -446,7 +446,7 @@ namespace jsonpointer {`
`446`	`446`	`return current;`
`447`	`447`	`}`
`448`	`448`	`std::size_t index{0};`
`449`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`449`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`450`	`450`	`if (!result)`
`451`	`451`	`{`
`452`	`452`	`ec = jsonpointer_errc::invalid_index;`
`@@ -690,7 +690,7 @@ namespace jsonpointer {`
`690`	`690`	`else`
`691`	`691`	`{`
`692`	`692`	`std::size_t index{0};`
`693`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`693`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`694`	`694`	`if (!result)`
`695`	`695`	`{`
`696`	`696`	`ec = jsonpointer_errc::invalid_index;`
`@@ -826,7 +826,7 @@ namespace jsonpointer {`
`826`	`826`	`else`
`827`	`827`	`{`
`828`	`828`	`std::size_t index{0};`
`829`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`829`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`830`	`830`	`if (!result)`
`831`	`831`	`{`
`832`	`832`	`ec = jsonpointer_errc::invalid_index;`
`@@ -965,7 +965,7 @@ namespace jsonpointer {`
`965`	`965`	`else`
`966`	`966`	`{`
`967`	`967`	`std::size_t index{0};`
`968`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`968`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`969`	`969`	`if (!result)`
`970`	`970`	`{`
`971`	`971`	`ec = jsonpointer_errc::invalid_index;`
`@@ -1069,7 +1069,7 @@ namespace jsonpointer {`
`1069`	`1069`	`else`
`1070`	`1070`	`{`
`1071`	`1071`	`std::size_t index{};`
`1072`		`- auto result = jsoncons::utility::decstr_to_integer(buffer.data(), buffer.length(), index);`
	`1072`	`+ auto result = jsoncons::utility::dec_to_integer(buffer.data(), buffer.length(), index);`
`1073`	`1073`	`if (!result)`
`1074`	`1074`	`{`
`1075`	`1075`	`ec = jsonpointer_errc::invalid_index;`
`@@ -1290,7 +1290,7 @@ namespace jsonpointer {`
`1290`	`1290`	`for (const auto& item : value.object_range())`
`1291`	`1291`	`{`
`1292`	`1292`	`std::size_t n;`
`1293`		`- auto r = jsoncons::utility::decstr_to_integer(item.key().data(),item.key().size(), n);`
	`1293`	`+ auto r = jsoncons::utility::dec_to_integer(item.key().data(),item.key().size(), n);`
`1294`	`1294`	`if (!r \|\| (index++ != n))`
`1295`	`1295`	`{`
`1296`	`1296`	`safe = false;`
`@@ -1344,7 +1344,7 @@ namespace jsonpointer {`
`1344`	`1344`	`{`
`1345`	`1345`	`auto s = *it;`
`1346`	`1346`	`std::size_t n{0};`
`1347`		`- auto r = jsoncons::utility::decstr_to_integer(s.data(), s.size(), n);`
	`1347`	`+ auto r = jsoncons::utility::dec_to_integer(s.data(), s.size(), n);`
`1348`	`1348`	`if (r.ec == std::errc() && (index++ == n))`
`1349`	`1349`	`{`
`1350`	`1350`	`if (!part->is_array())`
Original file line number	Diff line number	Diff line change
`@@ -68,64 +68,64 @@ TEST_CASE("jsoncons::utility::to_integer tests")`
`68`	`68`	`}`
`69`	`69`	`}`
`70`	`70`
`71`		`-TEST_CASE("utility::decstr_to_integer tests")`
	`71`	`+TEST_CASE("utility::dec_to_integer tests")`
`72`	`72`	`{`
`73`	`73`	`SECTION("")`
`74`	`74`	`{`
`75`	`75`	`std::string s = "-";`
`76`	`76`	`int64_t val;`
`77`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`77`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`78`	`78`	`REQUIRE_FALSE(result);`
`79`	`79`	`CHECK(result.ec == std::errc::invalid_argument);`
`80`	`80`	`}`
`81`	`81`	`SECTION("-")`
`82`	`82`	`{`
`83`	`83`	`std::string s = "-";`
`84`	`84`	`int64_t val;`
`85`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`85`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`86`	`86`	`REQUIRE_FALSE(result);`
`87`	`87`	`CHECK(result.ec == std::errc::invalid_argument);`
`88`	`88`	`}`
`89`	`89`	`SECTION("max uint64_t")`
`90`	`90`	`{`
`91`	`91`	`std::string s = std::to_string((std::numeric_limits<uint64_t>::max)());`
`92`	`92`	`uint64_t value{ 0 };`
`93`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), value);`
	`93`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), value);`
`94`	`94`	`REQUIRE(result);`
`95`	`95`	`CHECK(value == (std::numeric_limits<uint64_t>::max)());`
`96`	`96`	`s.push_back('0');`
`97`		`- auto result2 = jsoncons::utility::decstr_to_integer(s.data(), s.length(), value);`
	`97`	`+ auto result2 = jsoncons::utility::dec_to_integer(s.data(), s.length(), value);`
`98`	`98`	`REQUIRE_FALSE(result2);`
`99`	`99`	`}`
`100`	`100`	`SECTION("min int64_t")`
`101`	`101`	`{`
`102`	`102`	`std::string s = "-9223372036854775808";`
`103`	`103`	`int64_t val;`
`104`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`104`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`105`	`105`	`REQUIRE(result);`
`106`	`106`	`CHECK(val == (std::numeric_limits<int64_t>::min)());`
`107`	`107`	`}`
`108`	`108`	`SECTION("max int64_t")`
`109`	`109`	`{`
`110`	`110`	`std::string s = "9223372036854775807";`
`111`	`111`	`int64_t val;`
`112`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`112`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`113`	`113`	`REQUIRE(result);`
`114`	`114`	`CHECK(val == (std::numeric_limits<int64_t>::max)());`
`115`	`115`	`}`
`116`	`116`	`SECTION("min int64_t - 1")`
`117`	`117`	`{`
`118`	`118`	`std::string s = "-9223372036854775809";`
`119`	`119`	`int64_t val;`
`120`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`120`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`121`	`121`	`REQUIRE_FALSE(result);`
`122`	`122`	`CHECK(result.ec == std::errc::result_out_of_range);`
`123`	`123`	`}`
`124`	`124`	`SECTION("max int64_t + 1")`
`125`	`125`	`{`
`126`	`126`	`std::string s = "9223372036854775808";`
`127`	`127`	`int64_t val;`
`128`		`- auto result = jsoncons::utility::decstr_to_integer(s.data(), s.length(), val);`
	`128`	`+ auto result = jsoncons::utility::dec_to_integer(s.data(), s.length(), val);`
`129`	`129`	`REQUIRE_FALSE(result);`
`130`	`130`	`CHECK(result.ec == std::errc::result_out_of_range);`
`131`	`131`	`}`