bigint with ec

Author: danielaparker

include/jsoncons/reflect/json_conv_traits.hpp

@@ -1442,11 +1442,12 @@ has_can_convert = ext_traits::is_detected<traits_can_convert_t, Json, T>;
             switch (j.type())
             {
                 case json_type::string_value:
-                    if (!jsoncons::utility::is_base10(j.as_string_view().data(), j.as_string_view().length()))
-                    {
-                        return result_type(jsoncons::unexpect, conv_errc::not_bigint);
-                    }
-                    return result_type(basic_bigint<Allocator>::parse(j.as_string_view().data(), j.as_string_view().length()));
+                {
+                    auto sv = j.as_string_view();
+                    std::error_code ec;
+                    auto val = basic_bigint<Allocator>::parse(sv.data(), sv.length(), ec);
+                    return ec? result_type(jsoncons::unexpect, conv_errc::not_bigint) : result_type(std::move(val));
+                }
                 case json_type::half_value:
                 case json_type::double_value:
                 {
@@ -1727,7 +1728,9 @@ namespace variant_detail
                     case semantic_tag::epoch_milli:
                     {
                         auto sv = j.as_string_view();
-                        bigint n = bigint::parse(sv.data(), sv.length());
+                        std::error_code ec;
+                        auto n = bigint::parse(sv.data(), sv.length(), ec);
+                        if (ec) {return result_type(jsoncons::unexpect, conv_errc::not_epoch);}
                         if (n != 0)
                         {
                             n = n / millis_in_second;
@@ -1737,7 +1740,9 @@ namespace variant_detail
                     case semantic_tag::epoch_nano:
                     {
                         auto sv = j.as_string_view();
-                        bigint n = bigint::parse(sv.data(), sv.length());
+                        std::error_code ec;
+                        auto n = bigint::parse(sv.data(), sv.length(), ec);
+                        if (ec) {return result_type(jsoncons::unexpect, conv_errc::not_epoch);}
                         if (n != 0)
                         {
                             n = n / nanos_in_second;
@@ -1839,7 +1844,10 @@ namespace variant_detail
                         {
                             return result_type(unexpect, conv_errc::not_epoch);
                         }
-                        bigint n = bigint::parse((*res).data(), (*res).length());
+                        auto sv = *res;
+                        std::error_code ec;
+                        auto n = bigint::parse(sv.data(), sv.length(), ec);
+                        if (ec) {return result_type(jsoncons::unexpect, conv_errc::not_epoch);}
                         if (n != 0)
                         {
                             n = n / nanos_in_milli;

include/jsoncons/utility/bigint.hpp

@@ -17,6 +17,7 @@
 #include <limits> // std::numeric_limits
 #include <memory> // std::allocator
 #include <string> // std::string
+#include <system_error>
 #include <type_traits> // std::enable_if
 #include <vector> // std::vector
 
@@ -381,6 +382,12 @@ class basic_bigint : protected detail::basic_bigint_base<Allocator>
         return parse(s, std::char_traits<CharT>::length(s));
     }
 
+    template <typename CharT>
+    static basic_bigint<Allocator> parse(const CharT* s, std::error_code& ec)
+    {
+        return parse(s, std::char_traits<CharT>::length(s), ec);
+    }
+
     template <typename CharT>
     static basic_bigint<Allocator> parse(const CharT* data, size_type length)
     {
@@ -418,6 +425,45 @@ class basic_bigint : protected detail::basic_bigint_base<Allocator>
         return v;
     }
 
+    template <typename CharT>
+    static basic_bigint<Allocator> parse(const CharT* data, size_type length, std::error_code& ec)
+    {
+        ec.clear();
+        bool neg;
+        if (*data == '-')
+        {
+            neg = true;
+            data++;
+            --length;
+        }
+        else
+        {
+            neg = false;
+        }
+
+        basic_bigint<Allocator> v = 0;
+        for (size_type i = 0; i < length; i++)
+        {
+            CharT c = data[i];
+            switch (c)
+            {
+                case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8': case '9':
+                    v = (v * 10u) + (uint64_t)(c - '0');
+                    break;
+                default:
+                    ec = std::make_error_code(std::errc::invalid_argument);
+                    return basic_bigint<Allocator>{};
+            }
+        }
+
+        if (neg)
+        {
+            v.common_stor_.is_negative_ = true;
+        }
+
+        return v;
+    }
+
     template <typename CharT>
     static basic_bigint<Allocator> parse_radix(const CharT* data, size_type length, uint8_t radix)
     {