msgpack_cursor

danielaparker · danielaparker · commit 849e89c7b36b · 2025-03-11T17:00:28.000-04:00
diff --git a/include/jsoncons_ext/msgpack/msgpack_cursor.hpp b/include/jsoncons_ext/msgpack/msgpack_cursor.hpp
@@ -55,6 +55,7 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser
           cursor_visitor_(accept_all),
           cursor_handler_adaptor_(cursor_visitor_, alloc)
     {
+        parser_.cursor_mode(true);
         if (!done())
         {
             next();
@@ -94,6 +95,7 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser
          cursor_handler_adaptor_(cursor_visitor_, alloc),
          eof_(false)
     {
+        parser_.cursor_mode(true);
         if (!done())
         {
             next(ec);
@@ -178,9 +180,23 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser
     void read_to(basic_json_visitor<char_type>& visitor,
                 std::error_code& ec) override
     {
-        if (cursor_visitor_.dump(visitor, *this, ec))
+        if (is_begin_container(current().event_type()))
         {
-            read_next(visitor, ec);
+            parser_.cursor_mode(false);
+            parser_.mark_level(parser_.level());
+            if (cursor_visitor_.event().send_json_event(visitor, *this, ec))
+            {
+                read_next(visitor, ec);
+            }
+            parser_.cursor_mode(true);
+            parser_.mark_level(0);
+        }
+        else
+        {
+            if (cursor_visitor_.event().send_json_event(visitor, *this, ec))
+            {
+                read_next(visitor, ec);
+            }
         }
     }
 
diff --git a/include/jsoncons_ext/msgpack/msgpack_parser.hpp b/include/jsoncons_ext/msgpack/msgpack_parser.hpp
@@ -64,14 +64,17 @@ class basic_msgpack_parser : public ser_context
 
     static constexpr int64_t nanos_in_second = 1000000000;
 
-    Source source_;
-    msgpack_decode_options options_;
     bool more_{true};
     bool done_{false};
+    int nesting_depth_{0};
+    bool cursor_mode_{false};
+    int mark_level_{0};
+
+    Source source_;
+    msgpack_decode_options options_;
     std::basic_string<char,std::char_traits<char>,char_allocator_type> text_buffer_;
     std::vector<uint8_t,byte_allocator_type> bytes_buffer_;
     std::vector<parse_state,parse_state_allocator_type> state_stack_;
-    int nesting_depth_{0};
 
 public:
     template <typename Sourceable>
@@ -110,6 +113,26 @@ class basic_msgpack_parser : public ser_context
         reset();
     }
 
+    void cursor_mode(bool value)
+    {
+        cursor_mode_ = value;
+    }
+
+    int level() const
+    {
+        return static_cast<int>(state_stack_.size());
+    }
+
+    int mark_level() const 
+    {
+        return mark_level_;
+    }
+
+    void mark_level(int value)
+    {
+        mark_level_ = value;
+    }
+
     bool done() const
     {
         return done_;
@@ -227,7 +250,8 @@ class basic_msgpack_parser : public ser_context
             if (type <= 0x7f) 
             {
                 // positive fixint
-                more_ = visitor.uint64_value(type, semantic_tag::none, *this, ec);
+                visitor.uint64_value(type, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
             else if (type <= 0x8f) 
             {
@@ -258,31 +282,36 @@ class basic_msgpack_parser : public ser_context
                     more_ = false;
                     return;
                 }
-                more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
+                visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
         }
         else if (type >= 0xe0) 
         {
             // negative fixint
-            more_ = visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
+            visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);
+            more_ = !cursor_mode_;
         }
         else
         {
             switch (type)
             {
                 case jsoncons::msgpack::msgpack_type::nil_type: 
                 {
-                    more_ = visitor.null_value(semantic_tag::none, *this, ec);
+                    visitor.null_value(semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
                 case jsoncons::msgpack::msgpack_type::true_type:
                 {
-                    more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);
+                    visitor.bool_value(true, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
                 case jsoncons::msgpack::msgpack_type::false_type:
                 {
-                    more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
+                    visitor.bool_value(false, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
                 case jsoncons::msgpack::msgpack_type::float32_type: 
@@ -295,7 +324,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     float val = binary::big_to_native<float>(buf, sizeof(buf));
-                    more_ = visitor.double_value(val, semantic_tag::none, *this, ec);
+                    visitor.double_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -309,7 +339,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     double val = binary::big_to_native<double>(buf, sizeof(buf));
-                    more_ = visitor.double_value(val, semantic_tag::none, *this, ec);
+                    visitor.double_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -322,7 +353,8 @@ class basic_msgpack_parser : public ser_context
                         more_ = false;
                         return;
                     }
-                    more_ = visitor.uint64_value(b, semantic_tag::none, *this, ec);
+                    visitor.uint64_value(b, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -336,7 +368,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));
-                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -350,7 +383,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));
-                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -364,7 +398,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));
-                    more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    visitor.uint64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -378,7 +413,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));
-                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -392,7 +428,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));
-                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -406,7 +443,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));
-                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -420,7 +458,8 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
                     int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));
-                    more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    visitor.int64_value(val, semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -449,7 +488,8 @@ class basic_msgpack_parser : public ser_context
                         more_ = false;
                         return;
                     }
-                    more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
+                    visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
 
@@ -470,10 +510,11 @@ class basic_msgpack_parser : public ser_context
                         return;
                     }
 
-                    more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
+                    visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
                                                       semantic_tag::none, 
                                                       *this,
                                                       ec);
+                    more_ = !cursor_mode_;
                     break;
                 }
                 case jsoncons::msgpack::msgpack_type::fixext1_type: 
@@ -519,7 +560,8 @@ class basic_msgpack_parser : public ser_context
                             return;
                         }
                         uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));
-                        more_ = visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
+                        visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);
+                        more_ = !cursor_mode_;
                     }
                     else if (is_timestamp && len == 8)
                     {
@@ -539,7 +581,8 @@ class basic_msgpack_parser : public ser_context
                         nano += nsec;
                         text_buffer_.clear();
                         nano.write_string(text_buffer_);
-                        more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
+                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
+                        more_ = !cursor_mode_;
                         if (!more_) return;
                     }
                     else if (is_timestamp && len == 12)
@@ -577,7 +620,8 @@ class basic_msgpack_parser : public ser_context
 
                         text_buffer_.clear();
                         nano.write_string(text_buffer_);
-                        more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
+                        visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);
+                        more_ = !cursor_mode_;
                         if (!more_) return;
                     }
                     else
@@ -590,10 +634,11 @@ class basic_msgpack_parser : public ser_context
                             return;
                         }
 
-                        more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
+                        visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()), 
                                                           static_cast<uint8_t>(ext_type), 
                                                           *this,
                                                           ec);
+                        more_ = !cursor_mode_;
                     }
                     break;
                 }
@@ -636,14 +681,16 @@ class basic_msgpack_parser : public ser_context
             return;
         }
         state_stack_.emplace_back(parse_mode::array,length);
-        more_ = visitor.begin_array(length, semantic_tag::none, *this, ec);
+        visitor.begin_array(length, semantic_tag::none, *this, ec);
+        more_ = !cursor_mode_;
     }
 
     void end_array(item_event_visitor& visitor, std::error_code& ec)
     {
         --nesting_depth_;
 
-        more_ = visitor.end_array(*this, ec);
+        visitor.end_array(*this, ec);
+        more_ = !cursor_mode_;
         state_stack_.pop_back();
     }
 
@@ -661,13 +708,15 @@ class basic_msgpack_parser : public ser_context
             return;
         }
         state_stack_.emplace_back(parse_mode::map_key,length);
-        more_ = visitor.begin_object(length, semantic_tag::none, *this, ec);
+        visitor.begin_object(length, semantic_tag::none, *this, ec);
+        more_ = !cursor_mode_;
     }
 
     void end_object(item_event_visitor& visitor, std::error_code& ec)
     {
         --nesting_depth_;
-        more_ = visitor.end_object(*this, ec);
+        visitor.end_object(*this, ec);
+        more_ = !cursor_mode_;
         state_stack_.pop_back();
     }
 
diff --git a/include/jsoncons_ext/ubjson/ubjson_parser.hpp b/include/jsoncons_ext/ubjson/ubjson_parser.hpp
@@ -60,14 +60,14 @@ class basic_ubjson_parser : public ser_context
 
     bool more_{true};
     bool done_{false};
+    int nesting_depth_{0};
     bool cursor_mode_{false};
     int mark_level_{0};
 
     Source source_;
     ubjson_decode_options options_;
     std::basic_string<char,std::char_traits<char>,char_allocator_type> text_buffer_;
     std::vector<parse_state,parse_state_allocator_type> state_stack_;
-    int nesting_depth_{0};
 public:
     template <typename Sourceable>
         basic_ubjson_parser(Sourceable&& source,

Original file line number	Diff line number	Diff line change
`@@ -55,6 +55,7 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser`
`55`	`55`	`cursor_visitor_(accept_all),`
`56`	`56`	`cursor_handler_adaptor_(cursor_visitor_, alloc)`
`57`	`57`	`{`
	`58`	`+ parser_.cursor_mode(true);`
`58`	`59`	`if (!done())`
`59`	`60`	`{`
`60`	`61`	`next();`
`@@ -94,6 +95,7 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser`
`94`	`95`	`cursor_handler_adaptor_(cursor_visitor_, alloc),`
`95`	`96`	`eof_(false)`
`96`	`97`	`{`
	`98`	`+ parser_.cursor_mode(true);`
`97`	`99`	`if (!done())`
`98`	`100`	`{`
`99`	`101`	`next(ec);`
`@@ -178,9 +180,23 @@ class basic_msgpack_cursor : public basic_staj_cursor<char>, private virtual ser`
`178`	`180`	`void read_to(basic_json_visitor<char_type>& visitor,`
`179`	`181`	`std::error_code& ec) override`
`180`	`182`	`{`
`181`		`- if (cursor_visitor_.dump(visitor, *this, ec))`
	`183`	`+ if (is_begin_container(current().event_type()))`
`182`	`184`	`{`
`183`		`- read_next(visitor, ec);`
	`185`	`+ parser_.cursor_mode(false);`
	`186`	`+ parser_.mark_level(parser_.level());`
	`187`	`+ if (cursor_visitor_.event().send_json_event(visitor, *this, ec))`
	`188`	`+ {`
	`189`	`+ read_next(visitor, ec);`
	`190`	`+ }`
	`191`	`+ parser_.cursor_mode(true);`
	`192`	`+ parser_.mark_level(0);`
	`193`	`+ }`
	`194`	`+ else`
	`195`	`+ {`
	`196`	`+ if (cursor_visitor_.event().send_json_event(visitor, *this, ec))`
	`197`	`+ {`
	`198`	`+ read_next(visitor, ec);`
	`199`	`+ }`
`184`	`200`	`}`
`185`	`201`	`}`
`186`	`202`
Original file line number	Diff line number	Diff line change
`@@ -64,14 +64,17 @@ class basic_msgpack_parser : public ser_context`
`64`	`64`
`65`	`65`	`static constexpr int64_t nanos_in_second = 1000000000;`
`66`	`66`
`67`		`- Source source_;`
`68`		`- msgpack_decode_options options_;`
`69`	`67`	`bool more_{true};`
`70`	`68`	`bool done_{false};`
	`69`	`+ int nesting_depth_{0};`
	`70`	`+ bool cursor_mode_{false};`
	`71`	`+ int mark_level_{0};`
	`72`	`+`
	`73`	`+ Source source_;`
	`74`	`+ msgpack_decode_options options_;`
`71`	`75`	`std::basic_string<char,std::char_traits<char>,char_allocator_type> text_buffer_;`
`72`	`76`	`std::vector<uint8_t,byte_allocator_type> bytes_buffer_;`
`73`	`77`	`std::vector<parse_state,parse_state_allocator_type> state_stack_;`
`74`		`- int nesting_depth_{0};`
`75`	`78`
`76`	`79`	`public:`
`77`	`80`	`template <typename Sourceable>`
`@@ -110,6 +113,26 @@ class basic_msgpack_parser : public ser_context`
`110`	`113`	`reset();`
`111`	`114`	`}`
`112`	`115`
	`116`	`+ void cursor_mode(bool value)`
	`117`	`+ {`
	`118`	`+ cursor_mode_ = value;`
	`119`	`+ }`
	`120`	`+`
	`121`	`+ int level() const`
	`122`	`+ {`
	`123`	`+ return static_cast<int>(state_stack_.size());`
	`124`	`+ }`
	`125`	`+`
	`126`	`+ int mark_level() const`
	`127`	`+ {`
	`128`	`+ return mark_level_;`
	`129`	`+ }`
	`130`	`+`
	`131`	`+ void mark_level(int value)`
	`132`	`+ {`
	`133`	`+ mark_level_ = value;`
	`134`	`+ }`
	`135`	`+`
`113`	`136`	`bool done() const`
`114`	`137`	`{`
`115`	`138`	`return done_;`
`@@ -227,7 +250,8 @@ class basic_msgpack_parser : public ser_context`
`227`	`250`	`if (type <= 0x7f)`
`228`	`251`	`{`
`229`	`252`	`// positive fixint`
`230`		`- more_ = visitor.uint64_value(type, semantic_tag::none, *this, ec);`
	`253`	`+ visitor.uint64_value(type, semantic_tag::none, *this, ec);`
	`254`	`+ more_ = !cursor_mode_;`
`231`	`255`	`}`
`232`	`256`	`else if (type <= 0x8f)`
`233`	`257`	`{`
`@@ -258,31 +282,36 @@ class basic_msgpack_parser : public ser_context`
`258`	`282`	`more_ = false;`
`259`	`283`	`return;`
`260`	`284`	`}`
`261`		`- more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);`
	`285`	`+ visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);`
	`286`	`+ more_ = !cursor_mode_;`
`262`	`287`	`}`
`263`	`288`	`}`
`264`	`289`	`else if (type >= 0xe0)`
`265`	`290`	`{`
`266`	`291`	`// negative fixint`
`267`		`- more_ = visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);`
	`292`	`+ visitor.int64_value(static_cast<int8_t>(type), semantic_tag::none, *this, ec);`
	`293`	`+ more_ = !cursor_mode_;`
`268`	`294`	`}`
`269`	`295`	`else`
`270`	`296`	`{`
`271`	`297`	`switch (type)`
`272`	`298`	`{`
`273`	`299`	`case jsoncons::msgpack::msgpack_type::nil_type:`
`274`	`300`	`{`
`275`		`- more_ = visitor.null_value(semantic_tag::none, *this, ec);`
	`301`	`+ visitor.null_value(semantic_tag::none, *this, ec);`
	`302`	`+ more_ = !cursor_mode_;`
`276`	`303`	`break;`
`277`	`304`	`}`
`278`	`305`	`case jsoncons::msgpack::msgpack_type::true_type:`
`279`	`306`	`{`
`280`		`- more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);`
	`307`	`+ visitor.bool_value(true, semantic_tag::none, *this, ec);`
	`308`	`+ more_ = !cursor_mode_;`
`281`	`309`	`break;`
`282`	`310`	`}`
`283`	`311`	`case jsoncons::msgpack::msgpack_type::false_type:`
`284`	`312`	`{`
`285`		`- more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);`
	`313`	`+ visitor.bool_value(false, semantic_tag::none, *this, ec);`
	`314`	`+ more_ = !cursor_mode_;`
`286`	`315`	`break;`
`287`	`316`	`}`
`288`	`317`	`case jsoncons::msgpack::msgpack_type::float32_type:`
`@@ -295,7 +324,8 @@ class basic_msgpack_parser : public ser_context`
`295`	`324`	`return;`
`296`	`325`	`}`
`297`	`326`	`float val = binary::big_to_native<float>(buf, sizeof(buf));`
`298`		`- more_ = visitor.double_value(val, semantic_tag::none, *this, ec);`
	`327`	`+ visitor.double_value(val, semantic_tag::none, *this, ec);`
	`328`	`+ more_ = !cursor_mode_;`
`299`	`329`	`break;`
`300`	`330`	`}`
`301`	`331`
`@@ -309,7 +339,8 @@ class basic_msgpack_parser : public ser_context`
`309`	`339`	`return;`
`310`	`340`	`}`
`311`	`341`	`double val = binary::big_to_native<double>(buf, sizeof(buf));`
`312`		`- more_ = visitor.double_value(val, semantic_tag::none, *this, ec);`
	`342`	`+ visitor.double_value(val, semantic_tag::none, *this, ec);`
	`343`	`+ more_ = !cursor_mode_;`
`313`	`344`	`break;`
`314`	`345`	`}`
`315`	`346`
`@@ -322,7 +353,8 @@ class basic_msgpack_parser : public ser_context`
`322`	`353`	`more_ = false;`
`323`	`354`	`return;`
`324`	`355`	`}`
`325`		`- more_ = visitor.uint64_value(b, semantic_tag::none, *this, ec);`
	`356`	`+ visitor.uint64_value(b, semantic_tag::none, *this, ec);`
	`357`	`+ more_ = !cursor_mode_;`
`326`	`358`	`break;`
`327`	`359`	`}`
`328`	`360`
`@@ -336,7 +368,8 @@ class basic_msgpack_parser : public ser_context`
`336`	`368`	`return;`
`337`	`369`	`}`
`338`	`370`	`uint16_t val = binary::big_to_native<uint16_t>(buf, sizeof(buf));`
`339`		`- more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`371`	`+ visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`372`	`+ more_ = !cursor_mode_;`
`340`	`373`	`break;`
`341`	`374`	`}`
`342`	`375`
`@@ -350,7 +383,8 @@ class basic_msgpack_parser : public ser_context`
`350`	`383`	`return;`
`351`	`384`	`}`
`352`	`385`	`uint32_t val = binary::big_to_native<uint32_t>(buf, sizeof(buf));`
`353`		`- more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`386`	`+ visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`387`	`+ more_ = !cursor_mode_;`
`354`	`388`	`break;`
`355`	`389`	`}`
`356`	`390`
`@@ -364,7 +398,8 @@ class basic_msgpack_parser : public ser_context`
`364`	`398`	`return;`
`365`	`399`	`}`
`366`	`400`	`uint64_t val = binary::big_to_native<uint64_t>(buf, sizeof(buf));`
`367`		`- more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`401`	`+ visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`402`	`+ more_ = !cursor_mode_;`
`368`	`403`	`break;`
`369`	`404`	`}`
`370`	`405`
`@@ -378,7 +413,8 @@ class basic_msgpack_parser : public ser_context`
`378`	`413`	`return;`
`379`	`414`	`}`
`380`	`415`	`int8_t val = binary::big_to_native<int8_t>(buf, sizeof(buf));`
`381`		`- more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`416`	`+ visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`417`	`+ more_ = !cursor_mode_;`
`382`	`418`	`break;`
`383`	`419`	`}`
`384`	`420`
`@@ -392,7 +428,8 @@ class basic_msgpack_parser : public ser_context`
`392`	`428`	`return;`
`393`	`429`	`}`
`394`	`430`	`int16_t val = binary::big_to_native<int16_t>(buf, sizeof(buf));`
`395`		`- more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`431`	`+ visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`432`	`+ more_ = !cursor_mode_;`
`396`	`433`	`break;`
`397`	`434`	`}`
`398`	`435`
`@@ -406,7 +443,8 @@ class basic_msgpack_parser : public ser_context`
`406`	`443`	`return;`
`407`	`444`	`}`
`408`	`445`	`int32_t val = binary::big_to_native<int32_t>(buf, sizeof(buf));`
`409`		`- more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`446`	`+ visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`447`	`+ more_ = !cursor_mode_;`
`410`	`448`	`break;`
`411`	`449`	`}`
`412`	`450`
`@@ -420,7 +458,8 @@ class basic_msgpack_parser : public ser_context`
`420`	`458`	`return;`
`421`	`459`	`}`
`422`	`460`	`int64_t val = binary::big_to_native<int64_t>(buf, sizeof(buf));`
`423`		`- more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`461`	`+ visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`462`	`+ more_ = !cursor_mode_;`
`424`	`463`	`break;`
`425`	`464`	`}`
`426`	`465`
`@@ -449,7 +488,8 @@ class basic_msgpack_parser : public ser_context`
`449`	`488`	`more_ = false;`
`450`	`489`	`return;`
`451`	`490`	`}`
`452`		`- more_ = visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);`
	`491`	`+ visitor.string_value(jsoncons::basic_string_view<char>(text_buffer_.data(),text_buffer_.length()), semantic_tag::none, *this, ec);`
	`492`	`+ more_ = !cursor_mode_;`
`453`	`493`	`break;`
`454`	`494`	`}`
`455`	`495`
`@@ -470,10 +510,11 @@ class basic_msgpack_parser : public ser_context`
`470`	`510`	`return;`
`471`	`511`	`}`
`472`	`512`
`473`		`- more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()),`
	`513`	`+ visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()),`
`474`	`514`	`semantic_tag::none,`
`475`	`515`	`*this,`
`476`	`516`	`ec);`
	`517`	`+ more_ = !cursor_mode_;`
`477`	`518`	`break;`
`478`	`519`	`}`
`479`	`520`	`case jsoncons::msgpack::msgpack_type::fixext1_type:`
`@@ -519,7 +560,8 @@ class basic_msgpack_parser : public ser_context`
`519`	`560`	`return;`
`520`	`561`	`}`
`521`	`562`	`uint32_t val = binary::big_to_native<uint32_t>(buf32, sizeof(buf32));`
`522`		`- more_ = visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);`
	`563`	`+ visitor.uint64_value(val, semantic_tag::epoch_second, *this, ec);`
	`564`	`+ more_ = !cursor_mode_;`
`523`	`565`	`}`
`524`	`566`	`else if (is_timestamp && len == 8)`
`525`	`567`	`{`
`@@ -539,7 +581,8 @@ class basic_msgpack_parser : public ser_context`
`539`	`581`	`nano += nsec;`
`540`	`582`	`text_buffer_.clear();`
`541`	`583`	`nano.write_string(text_buffer_);`
`542`		`- more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);`
	`584`	`+ visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);`
	`585`	`+ more_ = !cursor_mode_;`
`543`	`586`	`if (!more_) return;`
`544`	`587`	`}`
`545`	`588`	`else if (is_timestamp && len == 12)`
`@@ -577,7 +620,8 @@ class basic_msgpack_parser : public ser_context`
`577`	`620`
`578`	`621`	`text_buffer_.clear();`
`579`	`622`	`nano.write_string(text_buffer_);`
`580`		`- more_ = visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);`
	`623`	`+ visitor.string_value(text_buffer_, semantic_tag::epoch_nano, *this, ec);`
	`624`	`+ more_ = !cursor_mode_;`
`581`	`625`	`if (!more_) return;`
`582`	`626`	`}`
`583`	`627`	`else`
`@@ -590,10 +634,11 @@ class basic_msgpack_parser : public ser_context`
`590`	`634`	`return;`
`591`	`635`	`}`
`592`	`636`
`593`		`- more_ = visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()),`
	`637`	`+ visitor.byte_string_value(byte_string_view(bytes_buffer_.data(),bytes_buffer_.size()),`
`594`	`638`	`static_cast<uint8_t>(ext_type),`
`595`	`639`	`*this,`
`596`	`640`	`ec);`
	`641`	`+ more_ = !cursor_mode_;`
`597`	`642`	`}`
`598`	`643`	`break;`
`599`	`644`	`}`
`@@ -636,14 +681,16 @@ class basic_msgpack_parser : public ser_context`
`636`	`681`	`return;`
`637`	`682`	`}`
`638`	`683`	`state_stack_.emplace_back(parse_mode::array,length);`
`639`		`- more_ = visitor.begin_array(length, semantic_tag::none, *this, ec);`
	`684`	`+ visitor.begin_array(length, semantic_tag::none, *this, ec);`
	`685`	`+ more_ = !cursor_mode_;`
`640`	`686`	`}`
`641`	`687`
`642`	`688`	`void end_array(item_event_visitor& visitor, std::error_code& ec)`
`643`	`689`	`{`
`644`	`690`	`--nesting_depth_;`
`645`	`691`
`646`		`- more_ = visitor.end_array(*this, ec);`
	`692`	`+ visitor.end_array(*this, ec);`
	`693`	`+ more_ = !cursor_mode_;`
`647`	`694`	`state_stack_.pop_back();`
`648`	`695`	`}`
`649`	`696`
`@@ -661,13 +708,15 @@ class basic_msgpack_parser : public ser_context`
`661`	`708`	`return;`
`662`	`709`	`}`
`663`	`710`	`state_stack_.emplace_back(parse_mode::map_key,length);`
`664`		`- more_ = visitor.begin_object(length, semantic_tag::none, *this, ec);`
	`711`	`+ visitor.begin_object(length, semantic_tag::none, *this, ec);`
	`712`	`+ more_ = !cursor_mode_;`
`665`	`713`	`}`
`666`	`714`
`667`	`715`	`void end_object(item_event_visitor& visitor, std::error_code& ec)`
`668`	`716`	`{`
`669`	`717`	`--nesting_depth_;`
`670`		`- more_ = visitor.end_object(*this, ec);`
	`718`	`+ visitor.end_object(*this, ec);`
	`719`	`+ more_ = !cursor_mode_;`
`671`	`720`	`state_stack_.pop_back();`
`672`	`721`	`}`
`673`	`722`