LLVMFuzzerTestOneInput: 13| 4.39k|{ 14| 4.39k| std::string input(reinterpret_cast(data), size); 15| 4.39k| std::istringstream is(input); 16| 4.39k| try { 17| 4.39k| json j2 = bson::decode_bson(is); 18| 4.39k| } 19| 4.39k| catch(const jsoncons::ser_error&) {} 20| | 21| 4.39k| return 0; 22| 4.39k|} _ZNK8jsoncons16allocator_holderINSt3__19allocatorIcEEE13get_allocatorEv: 30| 132k| { 31| 132k| return alloc_; 32| 132k| } _ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2ERKS3_: 25| 10.1k| : alloc_(alloc) 26| 10.1k| {} _ZN8jsoncons16allocator_holderINSt3__19allocatorIcEEEC2Ev: 20| 77.7k| allocator_holder() = default; _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEED2Ev: 2743| 88.8M| { 2744| 88.8M| destroy(); 2745| 88.8M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE7destroyEv: 884| 88.8M| { 885| 88.8M| switch (storage_kind()) 886| 88.8M| { 887| 15.7k| case json_storage_kind::long_str: ------------------ | Branch (887:17): [True: 15.7k, False: 88.8M] ------------------ 888| 15.7k| { 889| 15.7k| if (cast().ptr_ != nullptr) ------------------ | Branch (889:25): [True: 15.7k, False: 0] ------------------ 890| 15.7k| { 891| 15.7k| long_string_storage::heap_string_factory_type::destroy(cast().ptr_); 892| 15.7k| } 893| 15.7k| break; 894| 0| } 895| 15.8k| case json_storage_kind::byte_str: ------------------ | Branch (895:17): [True: 15.8k, False: 88.8M] ------------------ 896| 15.8k| if (cast().ptr_ != nullptr) ------------------ | Branch (896:25): [True: 15.8k, False: 0] ------------------ 897| 15.8k| { 898| 15.8k| byte_string_storage::heap_string_factory_type::destroy(cast().ptr_); 899| 15.8k| } 900| 15.8k| break; 901| 40.7k| case json_storage_kind::array: ------------------ | Branch (901:17): [True: 40.7k, False: 88.8M] ------------------ 902| 40.7k| { 903| 40.7k| if (cast().ptr_ != nullptr) ------------------ | Branch (903:25): [True: 40.7k, False: 0] ------------------ 904| 40.7k| { 905| 40.7k| auto& stor = cast(); 906| 40.7k| typename array_storage::allocator_type alloc{stor.ptr_->get_allocator()}; 907| 40.7k| std::allocator_traits::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_)); 908| 40.7k| std::allocator_traits::deallocate(alloc, stor.ptr_,1); 909| 40.7k| } 910| 40.7k| break; 911| 0| } 912| 36.9k| case json_storage_kind::object: ------------------ | Branch (912:17): [True: 36.9k, False: 88.8M] ------------------ 913| 36.9k| { 914| 36.9k| if (cast().ptr_ != nullptr) ------------------ | Branch (914:25): [True: 36.9k, False: 0] ------------------ 915| 36.9k| { 916| 36.9k| auto& stor = cast(); 917| 36.9k| typename object_storage::allocator_type alloc{stor.ptr_->get_allocator()}; 918| 36.9k| std::allocator_traits::destroy(alloc, ext_traits::to_plain_pointer(stor.ptr_)); 919| 36.9k| std::allocator_traits::deallocate(alloc, stor.ptr_,1); 920| 36.9k| } 921| 36.9k| break; 922| 0| } 923| 88.7M| default: ------------------ | Branch (923:17): [True: 88.7M, False: 109k] ------------------ 924| 88.7M| break; 925| 88.8M| } 926| 88.8M| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12storage_kindEv: 1430| 259M| { 1431| | // It is legal to access 'common_.storage_kind_' even though 1432| | // common_ is not the active member of the union because 'storage_kind_' 1433| | // is a part of the common initial sequence of all union members 1434| | // as defined in 11.4-25 of the Standard. 1435| 259M| return static_cast(common_.storage_kind_); 1436| 259M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_19long_string_storageEEERT_v: 990| 276k| { 991| 276k| return cast(identity()); 992| 276k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19long_string_storageEEE: 1081| 276k| { 1082| 276k| return long_str_; 1083| 276k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_19byte_string_storageEEERT_v: 990| 155k| { 991| 155k| return cast(identity()); 992| 155k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_19byte_string_storageEEE: 1091| 155k| { 1092| 155k| return byte_str_; 1093| 155k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERT_v: 990| 5.56M| { 991| 5.56M| return cast(identity()); 992| 5.56M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE: 1111| 5.56M| { 1112| 5.56M| return array_; 1113| 5.56M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EOS5_: 2275| 67.7M| { 2276| 67.7M| uninitialized_move(std::move(other)); 2277| 67.7M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18uninitialized_moveEOS5_: 1272| 67.7M| { 1273| 67.7M| if (is_trivial_storage(other.storage_kind())) ------------------ | Branch (1273:17): [True: 67.5M, False: 178k] ------------------ 1274| 67.5M| { 1275| 67.5M| std::memcpy(static_cast(this), &other, sizeof(basic_json)); 1276| 67.5M| } 1277| 178k| else 1278| 178k| { 1279| 178k| switch (other.storage_kind()) 1280| 178k| { 1281| 45.4k| case json_storage_kind::long_str: ------------------ | Branch (1281:21): [True: 45.4k, False: 132k] ------------------ 1282| 45.4k| construct(other.cast()); 1283| 45.4k| other.construct(); 1284| 45.4k| break; 1285| 21.1k| case json_storage_kind::byte_str: ------------------ | Branch (1285:21): [True: 21.1k, False: 157k] ------------------ 1286| 21.1k| construct(other.cast()); 1287| 21.1k| other.construct(); 1288| 21.1k| break; 1289| 60.4k| case json_storage_kind::array: ------------------ | Branch (1289:21): [True: 60.4k, False: 117k] ------------------ 1290| 60.4k| construct(other.cast()); 1291| 60.4k| other.construct(); 1292| 60.4k| break; 1293| 51.3k| case json_storage_kind::object: ------------------ | Branch (1293:21): [True: 51.3k, False: 126k] ------------------ 1294| 51.3k| construct(other.cast()); 1295| 51.3k| other.construct(); 1296| 51.3k| break; 1297| 0| default: ------------------ | Branch (1297:21): [True: 0, False: 178k] ------------------ 1298| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1299| 0| break; 1300| 178k| } 1301| 178k| } 1302| 67.7M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRS7_EEEvDpOT0_: 981| 114k| { 982| 114k| ::new (&cast()) StorageType(std::forward(args)...); 983| 114k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19long_string_storageC2ERKS6_: 630| 183k| : storage_kind_(static_cast(json_storage_kind::long_str)), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 631| 183k| { 632| 183k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJEEEvDpOT0_: 981| 178k| { 982| 178k| ::new (&cast()) StorageType(std::forward(args)...); 983| 178k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_12null_storageEEERT_v: 990| 21.4M| { 991| 21.4M| return cast(identity()); 992| 21.4M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12null_storageEEE: 1001| 21.4M| { 1002| 21.4M| return null_; 1003| 21.4M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12null_storageC2ENS_12semantic_tagE: 454| 20.9M| : storage_kind_(static_cast(json_storage_kind::null)), short_str_length_(0), tag_(tag) 455| 20.9M| { 456| 20.9M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19byte_string_storageEJRS7_EEEvDpOT0_: 981| 53.9k| { 982| 53.9k| ::new (&cast()) StorageType(std::forward(args)...); 983| 53.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19byte_string_storageC2ERKS6_: 679| 86.6k| : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 680| 86.6k| { 681| 86.6k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRS7_EEEvDpOT0_: 981| 152k| { 982| 152k| ::new (&cast()) StorageType(std::forward(args)...); 983| 152k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storageC2ERKS6_: 731| 244k| : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 732| 244k| { 733| 244k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14object_storageEJRS7_EEEvDpOT0_: 981| 109k| { 982| 109k| ::new (&cast()) StorageType(std::forward(args)...); 983| 109k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storageC2ERKS6_: 781| 167k| : storage_kind_(other.storage_kind_), short_str_length_(0), tag_(other.tag_), ptr_(other.ptr_) 782| 167k| { 783| 167k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE11array_rangeEv: 4707| 3.42k| { 4708| 3.42k| switch (storage_kind()) 4709| 3.42k| { 4710| 3.42k| case json_storage_kind::array: ------------------ | Branch (4710:17): [True: 3.42k, False: 0] ------------------ 4711| 3.42k| return array_range_type(cast().value().begin(), 4712| 3.42k| cast().value().end()); 4713| 0| case json_storage_kind::json_ref: ------------------ | Branch (4713:17): [True: 0, False: 3.42k] ------------------ 4714| 0| return cast().value().array_range(); 4715| 0| default: ------------------ | Branch (4715:17): [True: 0, False: 3.42k] ------------------ 4716| 0| JSONCONS_THROW(json_runtime_error("Not an array")); ------------------ | | 35| 0| #define JSONCONS_THROW(exception) throw exception ------------------ 4717| 3.42k| } 4718| 3.42k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storage5valueEv: 754| 5.13M| { 755| 5.13M| return *ptr_; 756| 5.13M| } _ZN8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEEC2ERKS9_SF_: 353| 3.42k| : first_(first), last_(last) 354| 3.42k| { 355| 3.42k| } _ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE5beginEv: 358| 3.42k| { 359| 3.42k| return first_; 360| 3.42k| } _ZNK8jsoncons5rangeINSt3__111__wrap_iterIPNS_10basic_jsonIcNS_13sorted_policyENS1_9allocatorIcEEEEEENS2_IPKS7_EEE3endEv: 362| 3.42k| { 363| 3.42k| return last_; 364| 3.42k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE5emptyEv: 3387| 8.84k| { 3388| 8.84k| switch (storage_kind()) 3389| 8.84k| { 3390| 0| case json_storage_kind::byte_str: ------------------ | Branch (3390:17): [True: 0, False: 8.84k] ------------------ 3391| 0| return cast().length() == 0; 3392| 0| break; 3393| 0| case json_storage_kind::short_str: ------------------ | Branch (3393:17): [True: 0, False: 8.84k] ------------------ 3394| 0| return cast().length() == 0; 3395| 0| case json_storage_kind::long_str: ------------------ | Branch (3395:17): [True: 0, False: 8.84k] ------------------ 3396| 0| return cast().length() == 0; 3397| 5.41k| case json_storage_kind::array: ------------------ | Branch (3397:17): [True: 5.41k, False: 3.43k] ------------------ 3398| 5.41k| return cast().value().empty(); 3399| 0| case json_storage_kind::empty_object: ------------------ | Branch (3399:17): [True: 0, False: 8.84k] ------------------ 3400| 0| return true; 3401| 3.43k| case json_storage_kind::object: ------------------ | Branch (3401:17): [True: 3.43k, False: 5.41k] ------------------ 3402| 3.43k| return cast().value().empty(); 3403| 0| case json_storage_kind::json_const_ref: ------------------ | Branch (3403:17): [True: 0, False: 8.84k] ------------------ 3404| 0| return cast().value().empty(); 3405| 0| case json_storage_kind::json_ref: ------------------ | Branch (3405:17): [True: 0, False: 8.84k] ------------------ 3406| 0| return cast().value().empty(); 3407| 0| default: ------------------ | Branch (3407:17): [True: 0, False: 8.84k] ------------------ 3408| 0| return false; 3409| 8.84k| } 3410| 8.84k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13array_storageEEERKT_v: 996| 5.41k| { 997| 5.41k| return cast(identity()); 998| 5.41k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13array_storageEEE: 1116| 5.41k| { 1117| 5.41k| return array_; 1118| 5.41k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storage5valueEv: 759| 5.41k| { 760| 5.41k| return *ptr_; 761| 5.41k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14object_storageEEERKT_v: 996| 3.43k| { 997| 3.43k| return cast(identity()); 998| 3.43k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14object_storageEEE: 1106| 3.43k| { 1107| 3.43k| return object_; 1108| 3.43k| } _ZNK8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storage5valueEv: 805| 3.43k| { 806| 3.43k| JSONCONS_ASSERT(ptr_ != nullptr); ------------------ | | 45| 3.43k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 3.43k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 807| 3.43k| return *ptr_; 808| 3.43k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE5clearEv: 4103| 6.69k| { 4104| 6.69k| switch (storage_kind()) 4105| 6.69k| { 4106| 3.42k| case json_storage_kind::array: ------------------ | Branch (4106:17): [True: 3.42k, False: 3.26k] ------------------ 4107| 3.42k| cast().value().clear(); 4108| 3.42k| break; 4109| 3.26k| case json_storage_kind::object: ------------------ | Branch (4109:17): [True: 3.26k, False: 3.42k] ------------------ 4110| 3.26k| cast().value().clear(); 4111| 3.26k| break; 4112| 0| case json_storage_kind::json_ref: ------------------ | Branch (4112:17): [True: 0, False: 6.69k] ------------------ 4113| 0| cast().value().clear(); 4114| 0| break; 4115| 0| default: ------------------ | Branch (4115:17): [True: 0, False: 6.69k] ------------------ 4116| 0| break; 4117| 6.69k| } 4118| 6.69k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storage5valueEv: 799| 22.8k| { 800| 22.8k| JSONCONS_ASSERT(ptr_ != nullptr); ------------------ | | 45| 22.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 22.8k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 801| 22.8k| return *ptr_; 802| 22.8k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12object_rangeEv: 4673| 3.26k| { 4674| 3.26k| switch (storage_kind()) 4675| 3.26k| { 4676| 0| case json_storage_kind::empty_object: ------------------ | Branch (4676:17): [True: 0, False: 3.26k] ------------------ 4677| 0| return object_range_type(object_iterator(), object_iterator()); 4678| 3.26k| case json_storage_kind::object: ------------------ | Branch (4678:17): [True: 3.26k, False: 0] ------------------ 4679| 3.26k| return object_range_type(object_iterator(cast().value().begin()), 4680| 3.26k| object_iterator(cast().value().end())); 4681| 0| case json_storage_kind::json_ref: ------------------ | Branch (4681:17): [True: 0, False: 3.26k] ------------------ 4682| 0| return cast().value().object_range(); 4683| 0| default: ------------------ | Branch (4683:17): [True: 0, False: 3.26k] ------------------ 4684| 0| JSONCONS_THROW(json_runtime_error("Not an object")); ------------------ | | 35| 0| #define JSONCONS_THROW(exception) throw exception ------------------ 4685| 3.26k| } 4686| 3.26k| } _ZN8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEEC2ERKSI_SP_: 353| 3.26k| : first_(first), last_(last) 354| 3.26k| { 355| 3.26k| } _ZN8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEC2ESG_: 122| 6.53k| explicit random_access_iterator_wrapper(Iterator ptr) : it_(ptr), has_value_(true) 123| 6.53k| { 124| 6.53k| } _ZNK8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEE5beginEv: 358| 3.26k| { 359| 3.26k| return first_; 360| 3.26k| } _ZNK8jsoncons5rangeINS_6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyESA_EEEEEEvEENS2_INS4_IPKSF_EEvEEE3endEv: 362| 3.26k| { 363| 3.26k| return last_; 364| 3.26k| } _ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEneERKSH_: 225| 7.52k| { 226| 7.52k| return !(*this == rhs); 227| 7.52k| } _ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEeqERKSH_: 213| 7.52k| { 214| 7.52k| if (!has_value_ || !rhs.has_value_) ------------------ | Branch (214:21): [True: 0, False: 7.52k] | Branch (214:36): [True: 0, False: 7.52k] ------------------ 215| 0| { 216| 0| return has_value_ == rhs.has_value_ ? true : false; ------------------ | Branch (216:28): [True: 0, False: 0] ------------------ 217| 0| } 218| 7.52k| else 219| 7.52k| { 220| 7.52k| return it_ == rhs.it_; 221| 7.52k| } 222| 7.52k| } _ZNK8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEdeEv: 144| 4.25k| { 145| 4.25k| return *it_; 146| 4.25k| } _ZN8jsoncons6detail30random_access_iterator_wrapperINSt3__111__wrap_iterIPNS_9key_valueINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES9_EEEEEEvEppEv: 154| 4.25k| { 155| 4.25k| ++it_; 156| 4.25k| return *this; 157| 4.25k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14object_storageEEERT_v: 990| 352k| { 991| 352k| return cast(identity()); 992| 352k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14object_storageEEE: 1101| 352k| { 1102| 352k| return object_; 1103| 352k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2Ev: 2243| 4.39k| { 2244| 4.39k| construct(semantic_tag::none); 2245| 4.39k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJNS_12semantic_tagEEEEvDpOT0_: 981| 4.39k| { 982| 4.39k| ::new (&cast()) StorageType(std::forward(args)...); 983| 4.39k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_20empty_object_storageEEERT_v: 990| 8.42k| { 991| 8.42k| return cast(identity()); 992| 8.42k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20empty_object_storageEEE: 1011| 8.42k| { 1012| 8.42k| return empty_object_; 1013| 8.42k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20empty_object_storageC2ENS_12semantic_tagE: 466| 4.39k| : storage_kind_(static_cast(json_storage_kind::empty_object)), short_str_length_(0), tag_(tag) 467| 4.39k| { 468| 4.39k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE7reserveEm: 3446| 6.04k| { 3447| 6.04k| if (n > 0) ------------------ | Branch (3447:17): [True: 6.04k, False: 0] ------------------ 3448| 6.04k| { 3449| 6.04k| switch (storage_kind()) 3450| 6.04k| { 3451| 6.04k| case json_storage_kind::array: ------------------ | Branch (3451:21): [True: 6.04k, False: 0] ------------------ 3452| 6.04k| cast().value().reserve(n); 3453| 6.04k| break; 3454| 0| case json_storage_kind::empty_object: ------------------ | Branch (3454:21): [True: 0, False: 6.04k] ------------------ 3455| 0| create_object_implicitly(); 3456| 0| cast().value().reserve(n); 3457| 0| break; 3458| 0| case json_storage_kind::object: ------------------ | Branch (3458:21): [True: 0, False: 6.04k] ------------------ 3459| 0| cast().value().reserve(n); 3460| 0| break; 3461| 0| case json_storage_kind::json_ref: ------------------ | Branch (3461:21): [True: 0, False: 6.04k] ------------------ 3462| 0| cast().value().reserve(n); 3463| 0| break; 3464| 0| default: ------------------ | Branch (3464:21): [True: 0, False: 6.04k] ------------------ 3465| 0| break; 3466| 6.04k| } 3467| 6.04k| } 3468| 6.04k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_17json_object_arg_tENS_12semantic_tagERKS4_: 2288| 36.9k| { 2289| 36.9k| auto ptr = create_object(alloc); 2290| 36.9k| construct(ptr, tag); 2291| 36.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13create_objectIJEEEPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEERKS4_DpOT_: 962| 36.9k| { 963| 36.9k| using stor_allocator_type = typename object_storage::allocator_type; 964| 36.9k| stor_allocator_type stor_alloc(alloc); 965| 36.9k| auto ptr = std::allocator_traits::allocate(stor_alloc, 1); 966| 36.9k| JSONCONS_TRY ------------------ | | 37| 36.9k| #define JSONCONS_TRY try ------------------ 967| 36.9k| { 968| 36.9k| std::allocator_traits::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 969| 36.9k| std::forward(args)...); 970| 36.9k| } 971| 36.9k| JSONCONS_CATCH(...) 972| 36.9k| { 973| 0| std::allocator_traits::deallocate(stor_alloc, ptr,1); 974| 0| JSONCONS_RETHROW; ------------------ | | 36| 0| #define JSONCONS_RETHROW throw ------------------ 975| 0| } 976| 36.9k| return ptr; 977| 36.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14object_storageEJRPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_: 981| 36.9k| { 982| 36.9k| ::new (&cast()) StorageType(std::forward(args)...); 983| 36.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14object_storageC2EPNS_18sorted_json_objectINS2_12basic_stringIcNS2_11char_traitsIcEES4_EES5_NS2_6vectorEEENS_12semantic_tagE: 776| 36.9k| : storage_kind_(static_cast(json_storage_kind::object)), short_str_length_(0), tag_(tag), ptr_(ptr) 777| 36.9k| { 778| 36.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEaSEOS5_: 1421| 45.5M| { 1422| 45.5M| if (this != &other) ------------------ | Branch (1422:17): [True: 45.5M, False: 0] ------------------ 1423| 45.5M| { 1424| 45.5M| move_assignment(std::move(other)); 1425| 45.5M| } 1426| 45.5M| return *this; 1427| 45.5M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE15move_assignmentEOS5_: 1373| 45.5M| { 1374| 45.5M| if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind())) ------------------ | Branch (1374:17): [True: 45.5M, False: 0] | Branch (1374:55): [True: 45.2M, False: 249k] ------------------ 1375| 45.2M| { 1376| 45.2M| std::memcpy(static_cast(this), &other, sizeof(basic_json)); 1377| 45.2M| } 1378| 249k| else 1379| 249k| { 1380| 249k| swap(other); 1381| 249k| } 1382| 45.5M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9push_backEOS5_: 4649| 5.12M| { 4650| 5.12M| switch (storage_kind()) 4651| 5.12M| { 4652| 5.12M| case json_storage_kind::array: ------------------ | Branch (4652:17): [True: 5.12M, False: 0] ------------------ 4653| 5.12M| cast().value().push_back(std::move(val)); 4654| 5.12M| break; 4655| 0| case json_storage_kind::json_ref: ------------------ | Branch (4655:17): [True: 0, False: 5.12M] ------------------ 4656| 0| cast().value().push_back(std::move(val)); 4657| 0| break; 4658| 0| default: ------------------ | Branch (4658:17): [True: 0, False: 5.12M] ------------------ 4659| 0| JSONCONS_THROW(json_runtime_error("Attempting to insert into a value that is not an array")); ------------------ | | 35| 0| #define JSONCONS_THROW(exception) throw exception ------------------ 4660| 5.12M| } 4661| 5.12M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4swapERS5_: 1902| 251k| { 1903| 251k| if (this == &other) ------------------ | Branch (1903:17): [True: 0, False: 251k] ------------------ 1904| 0| { 1905| 0| return; 1906| 0| } 1907| 251k| if (is_trivial_storage(storage_kind()) && is_trivial_storage(other.storage_kind())) ------------------ | Branch (1907:17): [True: 251k, False: 0] | Branch (1907:55): [True: 0, False: 251k] ------------------ 1908| 0| { 1909| 0| basic_json temp; 1910| 0| std::memcpy(static_cast(&temp), static_cast(&other), sizeof(basic_json)); 1911| 0| std::memcpy(static_cast(&other), static_cast(this), sizeof(basic_json)); 1912| 0| std::memcpy(static_cast(this), static_cast(&temp), sizeof(basic_json)); 1913| 0| } 1914| 251k| else 1915| 251k| { 1916| 251k| switch (storage_kind()) 1917| 251k| { 1918| 217k| case json_storage_kind::null: swap_l(other); break; ------------------ | Branch (1918:21): [True: 217k, False: 34.5k] ------------------ 1919| 2.01k| case json_storage_kind::empty_object : swap_l(other); break; ------------------ | Branch (1919:21): [True: 2.01k, False: 249k] ------------------ 1920| 6.34k| case json_storage_kind::boolean: swap_l(other); break; ------------------ | Branch (1920:21): [True: 6.34k, False: 245k] ------------------ 1921| 7.68k| case json_storage_kind::int64: swap_l(other); break; ------------------ | Branch (1921:21): [True: 7.68k, False: 244k] ------------------ 1922| 3.71k| case json_storage_kind::uint64: swap_l(other); break; ------------------ | Branch (1922:21): [True: 3.71k, False: 248k] ------------------ 1923| 0| case json_storage_kind::half_float: swap_l(other); break; ------------------ | Branch (1923:21): [True: 0, False: 251k] ------------------ 1924| 4.28k| case json_storage_kind::float64: swap_l(other); break; ------------------ | Branch (1924:21): [True: 4.28k, False: 247k] ------------------ 1925| 10.4k| case json_storage_kind::short_str: swap_l(other); break; ------------------ | Branch (1925:21): [True: 10.4k, False: 241k] ------------------ 1926| 0| case json_storage_kind::long_str: swap_l(other); break; ------------------ | Branch (1926:21): [True: 0, False: 251k] ------------------ 1927| 0| case json_storage_kind::byte_str: swap_l(other); break; ------------------ | Branch (1927:21): [True: 0, False: 251k] ------------------ 1928| 0| case json_storage_kind::array: swap_l(other); break; ------------------ | Branch (1928:21): [True: 0, False: 251k] ------------------ 1929| 0| case json_storage_kind::object: swap_l(other); break; ------------------ | Branch (1929:21): [True: 0, False: 251k] ------------------ 1930| 0| case json_storage_kind::json_const_ref: swap_l(other); break; ------------------ | Branch (1930:21): [True: 0, False: 251k] ------------------ 1931| 0| case json_storage_kind::json_ref: swap_l(other); break; ------------------ | Branch (1931:21): [True: 0, False: 251k] ------------------ 1932| 0| default: ------------------ | Branch (1932:21): [True: 0, False: 251k] ------------------ 1933| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1934| 0| break; 1935| 251k| } 1936| 251k| } 1937| 251k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_12null_storageEEEvRS5_: 1156| 217k| { 1157| 217k| switch (other.storage_kind()) 1158| 217k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 217k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 217k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 217k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 217k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 217k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 217k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 217k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 217k] ------------------ 1167| 55.2k| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 55.2k, False: 162k] ------------------ 1168| 28.3k| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 28.3k, False: 188k] ------------------ 1169| 82.7k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 82.7k, False: 134k] ------------------ 1170| 50.9k| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 50.9k, False: 166k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 217k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 217k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 217k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 217k| } 1177| 217k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRS7_EEEvDpOT0_: 981| 217k| { 982| 217k| ::new (&cast()) StorageType(std::forward(args)...); 983| 217k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20empty_object_storageEJRS7_EEEvDpOT0_: 981| 2.01k| { 982| 2.01k| ::new (&cast()) StorageType(std::forward(args)...); 983| 2.01k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_12bool_storageEEERT_v: 990| 69.6k| { 991| 69.6k| return cast(identity()); 992| 69.6k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_12bool_storageEEE: 1021| 69.6k| { 1022| 69.6k| return boolean_; 1023| 69.6k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRS7_EEEvDpOT0_: 981| 6.34k| { 982| 6.34k| ::new (&cast()) StorageType(std::forward(args)...); 983| 6.34k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_13int64_storageEEERT_v: 990| 166k| { 991| 166k| return cast(identity()); 992| 166k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_13int64_storageEEE: 1031| 166k| { 1032| 166k| return int64_; 1033| 166k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRS7_EEEvDpOT0_: 981| 7.68k| { 982| 7.68k| ::new (&cast()) StorageType(std::forward(args)...); 983| 7.68k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14uint64_storageEEERT_v: 990| 22.9k| { 991| 22.9k| return cast(identity()); 992| 22.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14uint64_storageEEE: 1041| 22.9k| { 1042| 22.9k| return uint64_; 1043| 22.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRS7_EEEvDpOT0_: 981| 3.71k| { 982| 3.71k| ::new (&cast()) StorageType(std::forward(args)...); 983| 3.71k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_14double_storageEEERT_v: 990| 21.9k| { 991| 21.9k| return cast(identity()); 992| 21.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_14double_storageEEE: 1061| 21.9k| { 1062| 21.9k| return float64_; 1063| 21.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14double_storageEJRS7_EEEvDpOT0_: 981| 4.28k| { 982| 4.28k| ::new (&cast()) StorageType(std::forward(args)...); 983| 4.28k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castINS5_20short_string_storageEEERT_v: 990| 42.2k| { 991| 42.2k| return cast(identity()); 992| 42.2k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE4castENS5_8identityINS5_20short_string_storageEEE: 1071| 42.2k| { 1072| 42.2k| return short_str_; 1073| 42.2k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20short_string_storageC2ERKS6_: 589| 10.4k| : storage_kind_(other.storage_kind_), short_str_length_(other.short_str_length_), tag_(other.tag_) 590| 10.4k| { 591| 10.4k| std::memcpy(data_,other.data_,other.short_str_length_*sizeof(char_type)); 592| 10.4k| data_[short_str_length_] = 0; 593| 10.4k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRS7_EEEvDpOT0_: 981| 10.4k| { 982| 10.4k| ::new (&cast()) StorageType(std::forward(args)...); 983| 10.4k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19long_string_storageEEEvRS5_: 1142| 55.2k| { 1143| 55.2k| swap_l_r(identity(), identity(), other); 1144| 55.2k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 55.2k| { 1149| 55.2k| TypeR temp{other.cast()}; 1150| 55.2k| other.construct(cast()); 1151| 55.2k| construct(temp); 1152| 55.2k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19byte_string_storageEEEvRS5_: 1142| 28.3k| { 1143| 28.3k| swap_l_r(identity(), identity(), other); 1144| 28.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 28.3k| { 1149| 28.3k| TypeR temp{other.cast()}; 1150| 28.3k| other.construct(cast()); 1151| 28.3k| construct(temp); 1152| 28.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_13array_storageEEEvRS5_: 1142| 82.7k| { 1143| 82.7k| swap_l_r(identity(), identity(), other); 1144| 82.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 82.7k| { 1149| 82.7k| TypeR temp{other.cast()}; 1150| 82.7k| other.construct(cast()); 1151| 82.7k| construct(temp); 1152| 82.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_14object_storageEEEvRS5_: 1142| 50.9k| { 1143| 50.9k| swap_l_r(identity(), identity(), other); 1144| 50.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12null_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 50.9k| { 1149| 50.9k| TypeR temp{other.cast()}; 1150| 50.9k| other.construct(cast()); 1151| 50.9k| construct(temp); 1152| 50.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_20empty_object_storageEEEvRS5_: 1156| 2.01k| { 1157| 2.01k| switch (other.storage_kind()) 1158| 2.01k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 2.01k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 2.01k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 2.01k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 2.01k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 2.01k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 2.01k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 2.01k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 2.01k] ------------------ 1167| 0| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 0, False: 2.01k] ------------------ 1168| 0| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 0, False: 2.01k] ------------------ 1169| 0| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 0, False: 2.01k] ------------------ 1170| 2.01k| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 2.01k, False: 0] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 2.01k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 2.01k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 2.01k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 2.01k| } 1177| 2.01k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_14object_storageEEEvRS5_: 1142| 2.01k| { 1143| 2.01k| swap_l_r(identity(), identity(), other); 1144| 2.01k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20empty_object_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 2.01k| { 1149| 2.01k| TypeR temp{other.cast()}; 1150| 2.01k| other.construct(cast()); 1151| 2.01k| construct(temp); 1152| 2.01k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_12bool_storageEEEvRS5_: 1156| 6.34k| { 1157| 6.34k| switch (other.storage_kind()) 1158| 6.34k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 6.34k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 6.34k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 6.34k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 6.34k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 6.34k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 6.34k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 6.34k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 6.34k] ------------------ 1167| 1.41k| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 1.41k, False: 4.93k] ------------------ 1168| 2.15k| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 2.15k, False: 4.19k] ------------------ 1169| 1.70k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 1.70k, False: 4.64k] ------------------ 1170| 1.07k| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 1.07k, False: 5.26k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 6.34k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 6.34k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 6.34k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 6.34k| } 1177| 6.34k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19long_string_storageEEEvRS5_: 1142| 1.41k| { 1143| 1.41k| swap_l_r(identity(), identity(), other); 1144| 1.41k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.41k| { 1149| 1.41k| TypeR temp{other.cast()}; 1150| 1.41k| other.construct(cast()); 1151| 1.41k| construct(temp); 1152| 1.41k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19byte_string_storageEEEvRS5_: 1142| 2.15k| { 1143| 2.15k| swap_l_r(identity(), identity(), other); 1144| 2.15k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 2.15k| { 1149| 2.15k| TypeR temp{other.cast()}; 1150| 2.15k| other.construct(cast()); 1151| 2.15k| construct(temp); 1152| 2.15k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_13array_storageEEEvRS5_: 1142| 1.70k| { 1143| 1.70k| swap_l_r(identity(), identity(), other); 1144| 1.70k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.70k| { 1149| 1.70k| TypeR temp{other.cast()}; 1150| 1.70k| other.construct(cast()); 1151| 1.70k| construct(temp); 1152| 1.70k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_14object_storageEEEvRS5_: 1142| 1.07k| { 1143| 1.07k| swap_l_r(identity(), identity(), other); 1144| 1.07k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_12bool_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.07k| { 1149| 1.07k| TypeR temp{other.cast()}; 1150| 1.07k| other.construct(cast()); 1151| 1.07k| construct(temp); 1152| 1.07k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_13int64_storageEEEvRS5_: 1156| 7.68k| { 1157| 7.68k| switch (other.storage_kind()) 1158| 7.68k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 7.68k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 7.68k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 7.68k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 7.68k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 7.68k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 7.68k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 7.68k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 7.68k] ------------------ 1167| 1.39k| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 1.39k, False: 6.28k] ------------------ 1168| 275| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 275, False: 7.40k] ------------------ 1169| 4.05k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 4.05k, False: 3.62k] ------------------ 1170| 1.95k| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 1.95k, False: 5.72k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 7.68k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 7.68k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 7.68k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 7.68k| } 1177| 7.68k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19long_string_storageEEEvRS5_: 1142| 1.39k| { 1143| 1.39k| swap_l_r(identity(), identity(), other); 1144| 1.39k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.39k| { 1149| 1.39k| TypeR temp{other.cast()}; 1150| 1.39k| other.construct(cast()); 1151| 1.39k| construct(temp); 1152| 1.39k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19byte_string_storageEEEvRS5_: 1142| 275| { 1143| 275| swap_l_r(identity(), identity(), other); 1144| 275| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 275| { 1149| 275| TypeR temp{other.cast()}; 1150| 275| other.construct(cast()); 1151| 275| construct(temp); 1152| 275| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_13array_storageEEEvRS5_: 1142| 4.05k| { 1143| 4.05k| swap_l_r(identity(), identity(), other); 1144| 4.05k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 4.05k| { 1149| 4.05k| TypeR temp{other.cast()}; 1150| 4.05k| other.construct(cast()); 1151| 4.05k| construct(temp); 1152| 4.05k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_14object_storageEEEvRS5_: 1142| 1.95k| { 1143| 1.95k| swap_l_r(identity(), identity(), other); 1144| 1.95k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_13int64_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.95k| { 1149| 1.95k| TypeR temp{other.cast()}; 1150| 1.95k| other.construct(cast()); 1151| 1.95k| construct(temp); 1152| 1.95k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_14uint64_storageEEEvRS5_: 1156| 3.71k| { 1157| 3.71k| switch (other.storage_kind()) 1158| 3.71k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 3.71k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 3.71k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 3.71k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 3.71k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 3.71k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 3.71k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 3.71k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 3.71k] ------------------ 1167| 1.96k| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 1.96k, False: 1.75k] ------------------ 1168| 224| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 224, False: 3.49k] ------------------ 1169| 1.22k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 1.22k, False: 2.48k] ------------------ 1170| 301| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 301, False: 3.41k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 3.71k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 3.71k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 3.71k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 3.71k| } 1177| 3.71k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19long_string_storageEEEvRS5_: 1142| 1.96k| { 1143| 1.96k| swap_l_r(identity(), identity(), other); 1144| 1.96k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.96k| { 1149| 1.96k| TypeR temp{other.cast()}; 1150| 1.96k| other.construct(cast()); 1151| 1.96k| construct(temp); 1152| 1.96k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19byte_string_storageEEEvRS5_: 1142| 224| { 1143| 224| swap_l_r(identity(), identity(), other); 1144| 224| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 224| { 1149| 224| TypeR temp{other.cast()}; 1150| 224| other.construct(cast()); 1151| 224| construct(temp); 1152| 224| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_13array_storageEEEvRS5_: 1142| 1.22k| { 1143| 1.22k| swap_l_r(identity(), identity(), other); 1144| 1.22k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.22k| { 1149| 1.22k| TypeR temp{other.cast()}; 1150| 1.22k| other.construct(cast()); 1151| 1.22k| construct(temp); 1152| 1.22k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_14object_storageEEEvRS5_: 1142| 301| { 1143| 301| swap_l_r(identity(), identity(), other); 1144| 301| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14uint64_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 301| { 1149| 301| TypeR temp{other.cast()}; 1150| 301| other.construct(cast()); 1151| 301| construct(temp); 1152| 301| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_14double_storageEEEvRS5_: 1156| 4.28k| { 1157| 4.28k| switch (other.storage_kind()) 1158| 4.28k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 4.28k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 4.28k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 4.28k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 4.28k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 4.28k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 4.28k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 4.28k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 4.28k] ------------------ 1167| 686| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 686, False: 3.60k] ------------------ 1168| 1.48k| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 1.48k, False: 2.80k] ------------------ 1169| 1.11k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 1.11k, False: 3.17k] ------------------ 1170| 999| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 999, False: 3.28k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 4.28k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 4.28k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 4.28k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 4.28k| } 1177| 4.28k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_19long_string_storageEEEvRS5_: 1142| 686| { 1143| 686| swap_l_r(identity(), identity(), other); 1144| 686| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 686| { 1149| 686| TypeR temp{other.cast()}; 1150| 686| other.construct(cast()); 1151| 686| construct(temp); 1152| 686| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_19byte_string_storageEEEvRS5_: 1142| 1.48k| { 1143| 1.48k| swap_l_r(identity(), identity(), other); 1144| 1.48k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.48k| { 1149| 1.48k| TypeR temp{other.cast()}; 1150| 1.48k| other.construct(cast()); 1151| 1.48k| construct(temp); 1152| 1.48k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_13array_storageEEEvRS5_: 1142| 1.11k| { 1143| 1.11k| swap_l_r(identity(), identity(), other); 1144| 1.11k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.11k| { 1149| 1.11k| TypeR temp{other.cast()}; 1150| 1.11k| other.construct(cast()); 1151| 1.11k| construct(temp); 1152| 1.11k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_14object_storageEEEvRS5_: 1142| 999| { 1143| 999| swap_l_r(identity(), identity(), other); 1144| 999| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_14double_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 999| { 1149| 999| TypeR temp{other.cast()}; 1150| 999| other.construct(cast()); 1151| 999| construct(temp); 1152| 999| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE6swap_lINS5_20short_string_storageEEEvRS5_: 1156| 10.4k| { 1157| 10.4k| switch (other.storage_kind()) 1158| 10.4k| { 1159| 0| case json_storage_kind::null : swap_l_r(other); break; ------------------ | Branch (1159:17): [True: 0, False: 10.4k] ------------------ 1160| 0| case json_storage_kind::empty_object : swap_l_r(other); break; ------------------ | Branch (1160:17): [True: 0, False: 10.4k] ------------------ 1161| 0| case json_storage_kind::boolean : swap_l_r(other); break; ------------------ | Branch (1161:17): [True: 0, False: 10.4k] ------------------ 1162| 0| case json_storage_kind::int64 : swap_l_r(other); break; ------------------ | Branch (1162:17): [True: 0, False: 10.4k] ------------------ 1163| 0| case json_storage_kind::uint64 : swap_l_r(other); break; ------------------ | Branch (1163:17): [True: 0, False: 10.4k] ------------------ 1164| 0| case json_storage_kind::half_float : swap_l_r(other); break; ------------------ | Branch (1164:17): [True: 0, False: 10.4k] ------------------ 1165| 0| case json_storage_kind::float64 : swap_l_r(other); break; ------------------ | Branch (1165:17): [True: 0, False: 10.4k] ------------------ 1166| 0| case json_storage_kind::short_str : swap_l_r(other); break; ------------------ | Branch (1166:17): [True: 0, False: 10.4k] ------------------ 1167| 8.37k| case json_storage_kind::long_str : swap_l_r(other); break; ------------------ | Branch (1167:17): [True: 8.37k, False: 2.08k] ------------------ 1168| 251| case json_storage_kind::byte_str : swap_l_r(other); break; ------------------ | Branch (1168:17): [True: 251, False: 10.2k] ------------------ 1169| 1.07k| case json_storage_kind::array : swap_l_r(other); break; ------------------ | Branch (1169:17): [True: 1.07k, False: 9.38k] ------------------ 1170| 758| case json_storage_kind::object : swap_l_r(other); break; ------------------ | Branch (1170:17): [True: 758, False: 9.70k] ------------------ 1171| 0| case json_storage_kind::json_const_ref : swap_l_r(other); break; ------------------ | Branch (1171:17): [True: 0, False: 10.4k] ------------------ 1172| 0| case json_storage_kind::json_ref : swap_l_r(other); break; ------------------ | Branch (1172:17): [True: 0, False: 10.4k] ------------------ 1173| 0| default: ------------------ | Branch (1173:17): [True: 0, False: 10.4k] ------------------ 1174| 0| JSONCONS_UNREACHABLE(); ------------------ | | 79| 0|#define JSONCONS_UNREACHABLE() __builtin_unreachable() ------------------ 1175| 0| break; 1176| 10.4k| } 1177| 10.4k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19long_string_storageEEEvRS5_: 1142| 8.37k| { 1143| 8.37k| swap_l_r(identity(), identity(), other); 1144| 8.37k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19long_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 8.37k| { 1149| 8.37k| TypeR temp{other.cast()}; 1150| 8.37k| other.construct(cast()); 1151| 8.37k| construct(temp); 1152| 8.37k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19byte_string_storageEEEvRS5_: 1142| 251| { 1143| 251| swap_l_r(identity(), identity(), other); 1144| 251| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_19byte_string_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 251| { 1149| 251| TypeR temp{other.cast()}; 1150| 251| other.construct(cast()); 1151| 251| construct(temp); 1152| 251| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_13array_storageEEEvRS5_: 1142| 1.07k| { 1143| 1.07k| swap_l_r(identity(), identity(), other); 1144| 1.07k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_13array_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 1.07k| { 1149| 1.07k| TypeR temp{other.cast()}; 1150| 1.07k| other.construct(cast()); 1151| 1.07k| construct(temp); 1152| 1.07k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_14object_storageEEEvRS5_: 1142| 758| { 1143| 758| swap_l_r(identity(), identity(), other); 1144| 758| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE8swap_l_rINS5_20short_string_storageENS5_14object_storageEEEvNS5_8identityIT_EENS9_IT0_EERS5_: 1148| 758| { 1149| 758| TypeR temp{other.cast()}; 1150| 758| other.construct(cast()); 1151| 758| construct(temp); 1152| 758| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ImEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits19is_unsigned_integerIS7_EE5valuelestS7_Lm8EEiE4typeE: 2583| 15.5k| { 2584| 15.5k| construct(val, tag); 2585| 15.5k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14uint64_storageEJRmRNS_12semantic_tagEEEEvDpOT0_: 981| 15.5k| { 982| 15.5k| ::new (&cast()) StorageType(std::forward(args)...); 983| 15.5k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14uint64_storageC2EmNS_12semantic_tagE: 520| 15.5k| : storage_kind_(static_cast(json_storage_kind::uint64)), short_str_length_(0), tag_(tag), 521| 15.5k| val_(val) 522| 15.5k| { 523| 15.5k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2IlEET_NS_12semantic_tagENS2_9enable_ifIXaasr10ext_traits17is_signed_integerIS7_EE5valuelestS7_Lm8EEiE4typeE: 2614| 151k| { 2615| 151k| construct(val, tag); 2616| 151k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13int64_storageEJRlRNS_12semantic_tagEEEEvDpOT0_: 981| 151k| { 982| 151k| ::new (&cast()) StorageType(std::forward(args)...); 983| 151k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13int64_storageC2ElNS_12semantic_tagE: 500| 151k| : storage_kind_(static_cast(json_storage_kind::int64)), short_str_length_(0), tag_(tag), 501| 151k| val_(val) 502| 151k| { 503| 151k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EdNS_12semantic_tagE: 2571| 13.3k| { 2572| 13.3k| construct(val, tag); 2573| 13.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_14double_storageEJRdRNS_12semantic_tagEEEEvDpOT0_: 981| 13.3k| { 982| 13.3k| ::new (&cast()) StorageType(std::forward(args)...); 983| 13.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE14double_storageC2EdNS_12semantic_tagE: 559| 13.3k| : storage_kind_(static_cast(json_storage_kind::float64)), short_str_length_(0), tag_(tag), 560| 13.3k| val_(val) 561| 13.3k| { 562| 13.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_16json_array_arg_tENS_12semantic_tagE: 2369| 40.7k| { 2370| 40.7k| auto ptr = create_array(Allocator()); 2371| 40.7k| construct(ptr, tag); 2372| 40.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12create_arrayIJEEEPNS_10json_arrayIS5_NS2_6vectorEEERKS4_DpOT_: 943| 40.7k| { 944| 40.7k| using stor_allocator_type = typename array_storage::allocator_type; 945| 40.7k| stor_allocator_type stor_alloc(alloc); 946| 40.7k| auto ptr = std::allocator_traits::allocate(stor_alloc, 1); 947| 40.7k| JSONCONS_TRY ------------------ | | 37| 40.7k| #define JSONCONS_TRY try ------------------ 948| 40.7k| { 949| 40.7k| std::allocator_traits::construct(stor_alloc, ext_traits::to_plain_pointer(ptr), 950| 40.7k| std::forward(args)...); 951| 40.7k| } 952| 40.7k| JSONCONS_CATCH(...) 953| 40.7k| { 954| 0| std::allocator_traits::deallocate(stor_alloc, ptr,1); 955| 0| JSONCONS_RETHROW; ------------------ | | 36| 0| #define JSONCONS_RETHROW throw ------------------ 956| 0| } 957| 40.7k| return ptr; 958| 40.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_13array_storageEJRPNS_10json_arrayIS5_NS2_6vectorEEERNS_12semantic_tagEEEEvDpOT0_: 981| 40.7k| { 982| 40.7k| ::new (&cast()) StorageType(std::forward(args)...); 983| 40.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE13array_storageC2EPNS_10json_arrayIS5_NS2_6vectorEEENS_12semantic_tagE: 726| 40.7k| : storage_kind_(static_cast(json_storage_kind::array)), short_str_length_(0), tag_(tag), ptr_(ptr) 727| 40.7k| { 728| 40.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ENS_9null_typeENS_12semantic_tagE: 2660| 20.7M| { 2661| 20.7M| construct(tag); 2662| 20.7M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12null_storageEJRNS_12semantic_tagEEEEvDpOT0_: 981| 20.7M| { 982| 20.7M| ::new (&cast()) StorageType(std::forward(args)...); 983| 20.7M| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EbNS_12semantic_tagE: 2670| 56.9k| { 2671| 56.9k| construct(val,tag); 2672| 56.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_12bool_storageEJRbRNS_12semantic_tagEEEEvDpOT0_: 981| 56.9k| { 982| 56.9k| ::new (&cast()) StorageType(std::forward(args)...); 983| 56.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE12bool_storageC2EbNS_12semantic_tagE: 479| 56.9k| : storage_kind_(static_cast(json_storage_kind::boolean)), short_str_length_(0), tag_(tag), 480| 56.9k| val_(val) 481| 56.9k| { 482| 56.9k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2ERKNS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagE: 2518| 37.0k| : basic_json(s.data(), s.size(), tag, allocator_type()) 2519| 37.0k| { 2520| 37.0k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2EPKcmNS_12semantic_tagERKS4_: 2548| 37.0k| { 2549| 37.0k| if (length <= short_string_storage::max_length) ------------------ | Branch (2549:17): [True: 21.3k, False: 15.7k] ------------------ 2550| 21.3k| { 2551| 21.3k| construct(s, static_cast(length), tag); 2552| 21.3k| } 2553| 15.7k| else 2554| 15.7k| { 2555| 15.7k| auto ptr = create_long_string(alloc, s, length); 2556| 15.7k| construct(ptr, tag); 2557| 15.7k| } 2558| 37.0k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_20short_string_storageEJRPKchRNS_12semantic_tagEEEEvDpOT0_: 981| 21.3k| { 982| 21.3k| ::new (&cast()) StorageType(std::forward(args)...); 983| 21.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE20short_string_storageC2EPKchNS_12semantic_tagE: 581| 21.3k| : storage_kind_(static_cast(json_storage_kind::short_str)), short_str_length_(length), tag_(tag) 582| 21.3k| { 583| 21.3k| JSONCONS_ASSERT(length <= max_length); ------------------ | | 45| 21.3k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 21.3k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 584| 21.3k| std::memcpy(data_,p,length*sizeof(char_type)); 585| 21.3k| data_[length] = 0; 586| 21.3k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18create_long_stringERKS4_PKcm: 929| 15.7k| { 930| 15.7k| using heap_string_factory_type = jsoncons::heap::heap_string_factory; 931| 15.7k| return heap_string_factory_type::create(data, length, null_type(), alloc); 932| 15.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19long_string_storageEJRPNS_4heap11heap_stringIcNS_9null_typeES4_EERNS_12semantic_tagEEEEvDpOT0_: 981| 15.7k| { 982| 15.7k| ::new (&cast()) StorageType(std::forward(args)...); 983| 15.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19long_string_storageC2EPNS_4heap11heap_stringIcNS_9null_typeES4_EENS_12semantic_tagE: 625| 15.7k| : storage_kind_(static_cast(json_storage_kind::long_str)), short_str_length_(0), tag_(tag), ptr_(ptr) 626| 15.7k| { 627| 15.7k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE18create_byte_stringERKS4_PKhmm: 936| 15.8k| { 937| 15.8k| using heap_string_factory_type = jsoncons::heap::heap_string_factory; 938| 15.8k| return heap_string_factory_type::create(data, length, ext_tag, alloc); 939| 15.8k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE19byte_string_storageC2EPNS_4heap11heap_stringIhmS4_EENS_12semantic_tagE: 674| 15.8k| : storage_kind_(static_cast(json_storage_kind::byte_str)), short_str_length_(0), tag_(tag), ptr_(ptr) 675| 15.8k| { 676| 15.8k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEC2INS_16byte_string_viewEEENS_17byte_string_arg_tERKT_mNS2_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS9_EE5valueEiE4typeE: 2711| 15.8k| { 2712| 15.8k| auto bytes = jsoncons::span(reinterpret_cast(source.data()), source.size()); 2713| | 2714| 15.8k| auto ptr = create_byte_string(Allocator(), bytes.data(), bytes.size(), ext_tag); 2715| 15.8k| construct(ptr, semantic_tag::ext); 2716| 15.8k| } _ZN8jsoncons10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEE9constructINS5_19byte_string_storageEJRPNS_4heap11heap_stringIhmS4_EENS_12semantic_tagEEEEvDpOT0_: 981| 15.8k| { 982| 15.8k| ::new (&cast()) StorageType(std::forward(args)...); 983| 15.8k| } _ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEET_PT0_: 239| 15.7k| { 240| 15.7k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 15.7k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 15.7k| } _ZN8jsoncons12launder_castIPcNS_4heap11heap_stringIhmNSt3__19allocatorIcEEEEEET_PT0_: 239| 15.8k| { 240| 15.8k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 15.8k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 15.8k| } _ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE9storage_tEcEET_PT0_: 239| 15.7k| { 240| 15.7k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 15.7k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 15.7k| } _ZN8jsoncons12launder_castIPNS_4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE9storage_tEcEET_PT0_: 239| 15.8k| { 240| 15.8k| #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 241| 15.8k| return std::launder(reinterpret_cast(u)); 242| | #elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) > 800 243| | return __builtin_launder(reinterpret_cast(u)); 244| | #else 245| | return reinterpret_cast(u); 246| | #endif 247| 15.8k| } _ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEC2IJRNS4_10error_codeEmmEEENS0_10unexpect_tEDpOT_: 66| 4.37k| : has_value_(false) 67| 4.37k| { 68| 4.37k| ::new (&error_) E(std::forward(args)...); 69| 4.37k| } _ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEC2EOS7_: 52| 16| : has_value_(true) 53| 16| { 54| 16| construct(std::move(value)); 55| 16| } _ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE9constructEOS7_: 274| 16| { 275| 16| ::new (&value_) T(std::move(value)); 276| 16| has_value_ = true; 277| 16| } _ZNK8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEcvbEv: 146| 4.39k| { 147| 4.39k| return has_value_; 148| 4.39k| } _ZNR8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE5errorEv: 192| 13.1k| { 193| 13.1k| assert(!has_value_); ------------------ | Branch (193:9): [True: 13.1k, False: 0] ------------------ 194| 13.1k| return this->error_; 195| 13.1k| } _ZNR8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEEdeEv: 231| 16| { 232| 16| return this->value_; 233| 16| } _ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEED2Ev: 100| 4.39k| { 101| 4.39k| destroy(); 102| 4.39k| } _ZN8jsoncons6detail8expectedINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS_10read_errorEE7destroyEv: 280| 4.39k| { 281| 4.39k| if (has_value_) ------------------ | Branch (281:13): [True: 16, False: 4.37k] ------------------ 282| 16| { 283| 16| value_.~T(); 284| 16| has_value_ = false; 285| 16| } 286| 4.37k| else 287| 4.37k| { 288| 4.37k| error_.~E(); 289| 4.37k| } 290| 4.39k| } _ZN8jsoncons6detail4spanIKhLm18446744073709551615EEC2EPS2_m: 61| 15.8k| : data_(data), size_(size) 62| 15.8k| { 63| 15.8k| } _ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4dataEv: 111| 15.8k| { 112| 15.8k| return data_; 113| 15.8k| } _ZNK8jsoncons6detail4spanIKhLm18446744073709551615EE4sizeEv: 116| 15.8k| { 117| 15.8k| return size_; 118| 15.8k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEED2Ev: 107| 50.9k| { 108| 50.9k| flatten_and_destroy(); 109| 50.9k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE19flatten_and_destroyEv: 246| 50.9k| { 247| 5.17M| while (!elements_.empty()) ------------------ | Branch (247:20): [True: 5.12M, False: 50.9k] ------------------ 248| 5.12M| { 249| 5.12M| value_type current = std::move(elements_.back()); 250| 5.12M| elements_.pop_back(); 251| 5.12M| switch (current.storage_kind()) 252| 5.12M| { 253| 3.42k| case json_storage_kind::array: ------------------ | Branch (253:21): [True: 3.42k, False: 5.11M] ------------------ 254| 3.42k| { 255| 3.42k| for (auto&& item : current.array_range()) ------------------ | Branch (255:42): [True: 4.38k, False: 3.42k] ------------------ 256| 4.38k| { 257| 4.38k| if ((item.storage_kind() == json_storage_kind::array || item.storage_kind() == json_storage_kind::object) ------------------ | Branch (257:34): [True: 826, False: 3.55k] | Branch (257:85): [True: 609, False: 2.94k] ------------------ 258| 1.43k| && !item.empty()) // non-empty object or array ------------------ | Branch (258:36): [True: 963, False: 472] ------------------ 259| 963| { 260| 963| elements_.push_back(std::move(item)); 261| 963| } 262| 4.38k| } 263| 3.42k| current.clear(); 264| 3.42k| break; 265| 0| } 266| 3.26k| case json_storage_kind::object: ------------------ | Branch (266:21): [True: 3.26k, False: 5.11M] ------------------ 267| 3.26k| { 268| 3.26k| for (auto&& kv : current.object_range()) ------------------ | Branch (268:40): [True: 4.25k, False: 3.26k] ------------------ 269| 4.25k| { 270| 4.25k| if ((kv.value().storage_kind() == json_storage_kind::array || kv.value().storage_kind() == json_storage_kind::object) ------------------ | Branch (270:34): [True: 334, False: 3.92k] | Branch (270:91): [True: 944, False: 2.98k] ------------------ 271| 1.27k| && !kv.value().empty()) // non-empty object or array ------------------ | Branch (271:36): [True: 978, False: 300] ------------------ 272| 978| { 273| 978| elements_.push_back(std::move(kv.value())); 274| 978| } 275| 4.25k| } 276| 3.26k| current.clear(); 277| 3.26k| break; 278| 0| } 279| 5.11M| default: ------------------ | Branch (279:21): [True: 5.11M, False: 6.69k] ------------------ 280| 5.11M| break; 281| 5.12M| } 282| 5.12M| } 283| 50.9k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5beginEv: 220| 3.42k| iterator begin() {return elements_.begin();} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE3endEv: 222| 3.42k| iterator end() {return elements_.end();} _ZNK8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5emptyEv: 127| 5.41k| { 128| 5.41k| return elements_.empty(); 129| 5.41k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE5clearEv: 140| 3.42k| void clear() {elements_.clear();} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2ERKS5_: 51| 10.1k| : allocator_holder(alloc), 52| 10.1k| elements_(value_allocator_type(alloc)) 53| 10.1k| { 54| 10.1k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE12emplace_backIJS6_EEERS6_DpOT_: 215| 3.29k| { 216| 3.29k| elements_.emplace_back(std::forward(args)...); 217| 3.29k| return elements_.back(); 218| 3.29k| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE7reserveEm: 151| 6.04k| void reserve(std::size_t n) {elements_.reserve(n);} _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEE9push_backIS6_S5_EENS3_9enable_ifIXsr3std16allocator_traitsIT0_E15is_always_equalE5valueEvE4typeEOT_: 176| 5.12M| { 177| 5.12M| elements_.emplace_back(std::forward(value)); 178| 5.12M| } _ZN8jsoncons10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS3_6vectorEEC2Ev: 47| 40.7k| { 48| 40.7k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_EC2ERKS5_S9_: 74| 4.39k| : allocator_(alloc), 75| 4.39k| result_(), 76| 4.39k| name_(alloc), 77| 4.39k| item_stack_(alloc), 78| 4.39k| structure_stack_(temp_alloc) 79| 4.39k| { 80| 4.39k| item_stack_.reserve(1000); 81| 4.39k| structure_stack_.reserve(100); 82| 4.39k| structure_stack_.emplace_back(structure_type::root_t, 0); 83| 4.39k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E14structure_infoC2ENS7_14structure_typeEm: 51| 82.1k| : type_(type), container_index_(offset) 52| 82.1k| { 53| 82.1k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E15visit_end_arrayERKNS_11ser_contextERNS3_10error_codeE: 179| 18.1k| { 180| 18.1k| JSONCONS_ASSERT(structure_stack_.size() > 1); ------------------ | | 45| 18.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 18.1k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 181| 18.1k| JSONCONS_ASSERT(structure_stack_.back().type_ == structure_type::array_t); ------------------ | | 45| 18.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 18.1k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 182| 18.1k| const size_t container_index = structure_stack_.back().container_index_; 183| 18.1k| JSONCONS_ASSERT(item_stack_.size() > container_index); ------------------ | | 45| 18.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 18.1k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 184| | 185| 18.1k| auto& container = item_stack_[container_index].value; 186| | 187| 18.1k| const size_t size = item_stack_.size() - (container_index + 1); 188| | //std::cout << "size on item stack: " << size << "\n"; 189| | 190| 18.1k| if (size > 0) ------------------ | Branch (190:13): [True: 6.04k, False: 12.1k] ------------------ 191| 6.04k| { 192| 6.04k| container.reserve(size); 193| 6.04k| auto first = item_stack_.begin() + (container_index+1); 194| 6.04k| auto last = first + size; 195| 5.12M| for (auto it = first; it != last; ++it) ------------------ | Branch (195:35): [True: 5.12M, False: 6.04k] ------------------ 196| 5.12M| { 197| 5.12M| container.push_back(std::move((*it).value)); 198| 5.12M| } 199| 6.04k| item_stack_.erase(first, item_stack_.end()); 200| 6.04k| } 201| | 202| 18.1k| structure_stack_.pop_back(); 203| 18.1k| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (203:13): [True: 0, False: 18.1k] ------------------ 204| 0| { 205| 0| result_.swap(item_stack_.front().value); 206| 0| item_stack_.pop_back(); 207| 0| is_valid_ = true; 208| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 209| 0| } 210| 18.1k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 18.1k|#define JSONCONS_VISITOR_RETURN return true ------------------ 211| 18.1k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 296| 15.5k| { 297| 15.5k| switch (structure_stack_.back().type_) ------------------ | Branch (297:17): [True: 15.5k, False: 0] ------------------ 298| 15.5k| { 299| 12.8k| case structure_type::object_t: ------------------ | Branch (299:13): [True: 12.8k, False: 2.66k] ------------------ 300| 15.5k| case structure_type::array_t: ------------------ | Branch (300:13): [True: 2.66k, False: 12.8k] ------------------ 301| 15.5k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 302| 15.5k| break; 303| 0| case structure_type::root_t: ------------------ | Branch (303:13): [True: 0, False: 15.5k] ------------------ 304| 0| result_ = Json(value,tag); 305| 0| is_valid_ = true; 306| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 307| 15.5k| } 308| 15.5k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.5k|#define JSONCONS_VISITOR_RETURN return true ------------------ 309| 15.5k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 277| 151k| { 278| 151k| switch (structure_stack_.back().type_) ------------------ | Branch (278:17): [True: 151k, False: 0] ------------------ 279| 151k| { 280| 137k| case structure_type::object_t: ------------------ | Branch (280:13): [True: 137k, False: 14.0k] ------------------ 281| 151k| case structure_type::array_t: ------------------ | Branch (281:13): [True: 14.0k, False: 137k] ------------------ 282| 151k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 283| 151k| break; 284| 0| case structure_type::root_t: ------------------ | Branch (284:13): [True: 0, False: 151k] ------------------ 285| 0| result_ = Json(value,tag); 286| 0| is_valid_ = true; 287| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 288| 151k| } 289| 151k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 151k|#define JSONCONS_VISITOR_RETURN return true ------------------ 290| 151k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 334| 13.3k| { 335| 13.3k| switch (structure_stack_.back().type_) ------------------ | Branch (335:17): [True: 13.3k, False: 0] ------------------ 336| 13.3k| { 337| 11.7k| case structure_type::object_t: ------------------ | Branch (337:13): [True: 11.7k, False: 1.60k] ------------------ 338| 13.3k| case structure_type::array_t: ------------------ | Branch (338:13): [True: 1.60k, False: 11.7k] ------------------ 339| 13.3k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 340| 13.3k| break; 341| 0| case structure_type::root_t: ------------------ | Branch (341:13): [True: 0, False: 13.3k] ------------------ 342| 0| result_ = Json(value, tag); 343| 0| is_valid_ = true; 344| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 345| 13.3k| } 346| 13.3k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 13.3k|#define JSONCONS_VISITOR_RETURN return true ------------------ 347| 13.3k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E11visit_flushEv: 122| 16| { 123| 16| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 126| 36.9k| { 127| 36.9k| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (127:13): [True: 4.38k, False: 32.5k] ------------------ 128| 4.38k| { 129| 4.38k| index_ = 0; 130| 4.38k| item_stack_.clear(); 131| 4.38k| is_valid_ = false; 132| 4.38k| } 133| 36.9k| item_stack_.emplace_back(std::move(name_), index_++, json_object_arg, tag); 134| 36.9k| structure_stack_.emplace_back(structure_type::object_t, item_stack_.size()-1); 135| 36.9k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 36.9k|#define JSONCONS_VISITOR_RETURN return true ------------------ 136| 36.9k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E16visit_end_objectERKNS_11ser_contextERNS3_10error_codeE: 139| 24.8k| { 140| 24.8k| JSONCONS_ASSERT(structure_stack_.size() > 0); ------------------ | | 45| 24.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 24.8k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 141| 24.8k| JSONCONS_ASSERT(structure_stack_.back().type_ == structure_type::object_t); ------------------ | | 45| 24.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 24.8k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 142| 24.8k| const size_t structure_index = structure_stack_.back().container_index_; 143| 24.8k| JSONCONS_ASSERT(item_stack_.size() > structure_index); ------------------ | | 45| 24.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 24.8k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 144| 24.8k| const size_t count = item_stack_.size() - (structure_index + 1); 145| 24.8k| auto first = item_stack_.begin() + (structure_index+1); 146| | 147| 24.8k| if (count > 0) ------------------ | Branch (147:13): [True: 13.0k, False: 11.7k] ------------------ 148| 13.0k| { 149| 13.0k| item_stack_[structure_index].value.template cast().value().uninitialized_init( 150| 13.0k| &item_stack_[structure_index+1], count); 151| 13.0k| } 152| | 153| 24.8k| item_stack_.erase(first, item_stack_.end()); 154| 24.8k| structure_stack_.pop_back(); 155| 24.8k| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (155:13): [True: 2.01k, False: 22.7k] ------------------ 156| 2.01k| { 157| 2.01k| result_.swap(item_stack_.front().value); 158| 2.01k| item_stack_.pop_back(); 159| 2.01k| is_valid_ = true; 160| 2.01k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 2.01k|#define JSONCONS_VISITOR_RETURN return true ------------------ 161| 2.01k| } 162| 22.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 22.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 163| 24.8k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 166| 40.7k| { 167| 40.7k| if (structure_stack_.back().type_ == structure_type::root_t) ------------------ | Branch (167:13): [True: 0, False: 40.7k] ------------------ 168| 0| { 169| 0| index_ = 0; 170| 0| item_stack_.clear(); 171| 0| is_valid_ = false; 172| 0| } 173| 40.7k| item_stack_.emplace_back(std::move(name_), index_++, json_array_arg, tag); 174| 40.7k| structure_stack_.emplace_back(structure_type::array_t, item_stack_.size()-1); 175| 40.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 40.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 176| 40.7k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E9visit_keyERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERKNS_11ser_contextERNS3_10error_codeE: 214| 9.98M| { 215| 9.98M| name_ = key_type(name.data(),name.length(),allocator_); 216| 9.98M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 9.98M|#define JSONCONS_VISITOR_RETURN return true ------------------ 217| 9.98M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 366| 20.7M| { 367| 20.7M| switch (structure_stack_.back().type_) ------------------ | Branch (367:17): [True: 20.7M, False: 0] ------------------ 368| 20.7M| { 369| 9.68M| case structure_type::object_t: ------------------ | Branch (369:13): [True: 9.68M, False: 11.1M] ------------------ 370| 20.7M| case structure_type::array_t: ------------------ | Branch (370:13): [True: 11.1M, False: 9.68M] ------------------ 371| 20.7M| item_stack_.emplace_back(std::move(name_), index_++, null_type(), tag); 372| 20.7M| break; 373| 0| case structure_type::root_t: ------------------ | Branch (373:13): [True: 0, False: 20.7M] ------------------ 374| 0| result_ = Json(null_type(), tag); 375| 0| is_valid_ = true; 376| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 20.7M| } 378| 20.7M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 20.7M|#define JSONCONS_VISITOR_RETURN return true ------------------ 379| 20.7M| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 350| 56.9k| { 351| 56.9k| switch (structure_stack_.back().type_) ------------------ | Branch (351:17): [True: 56.9k, False: 0] ------------------ 352| 56.9k| { 353| 40.6k| case structure_type::object_t: ------------------ | Branch (353:13): [True: 40.6k, False: 16.2k] ------------------ 354| 56.9k| case structure_type::array_t: ------------------ | Branch (354:13): [True: 16.2k, False: 40.6k] ------------------ 355| 56.9k| item_stack_.emplace_back(std::move(name_), index_++, value, tag); 356| 56.9k| break; 357| 0| case structure_type::root_t: ------------------ | Branch (357:13): [True: 0, False: 56.9k] ------------------ 358| 0| result_ = Json(value, tag); 359| 0| is_valid_ = true; 360| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 361| 56.9k| } 362| 56.9k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 56.9k|#define JSONCONS_VISITOR_RETURN return true ------------------ 363| 56.9k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E12visit_stringERKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS3_10error_codeE: 220| 37.0k| { 221| 37.0k| switch (structure_stack_.back().type_) ------------------ | Branch (221:17): [True: 37.0k, False: 0] ------------------ 222| 37.0k| { 223| 33.1k| case structure_type::object_t: ------------------ | Branch (223:13): [True: 33.1k, False: 3.95k] ------------------ 224| 37.0k| case structure_type::array_t: ------------------ | Branch (224:13): [True: 3.95k, False: 33.1k] ------------------ 225| 37.0k| item_stack_.emplace_back(std::move(name_), index_++, sv, tag); 226| 37.0k| break; 227| 0| case structure_type::root_t: ------------------ | Branch (227:13): [True: 0, False: 37.0k] ------------------ 228| 0| result_ = Json(sv, tag, allocator_); 229| 0| is_valid_ = true; 230| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 231| 37.0k| } 232| 37.0k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 37.0k|#define JSONCONS_VISITOR_RETURN return true ------------------ 233| 37.0k| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS3_10error_codeE: 258| 15.8k| { 259| 15.8k| switch (structure_stack_.back().type_) ------------------ | Branch (259:17): [True: 15.8k, False: 0] ------------------ 260| 15.8k| { 261| 13.3k| case structure_type::object_t: ------------------ | Branch (261:13): [True: 13.3k, False: 2.54k] ------------------ 262| 15.8k| case structure_type::array_t: ------------------ | Branch (262:13): [True: 2.54k, False: 13.3k] ------------------ 263| 15.8k| item_stack_.emplace_back(std::move(name_), index_++, byte_string_arg, b, ext_tag); 264| 15.8k| break; 265| 0| case structure_type::root_t: ------------------ | Branch (265:13): [True: 0, False: 15.8k] ------------------ 266| 0| result_ = Json(byte_string_arg, b, ext_tag, allocator_); 267| 0| is_valid_ = true; 268| 0| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 0|#define JSONCONS_VISITOR_RETURN return true ------------------ 269| 15.8k| } 270| 15.8k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.8k|#define JSONCONS_VISITOR_RETURN return true ------------------ 271| 15.8k| } _ZNK8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E8is_validEv: 108| 16| { 109| 16| return is_valid_; 110| 16| } _ZN8jsoncons12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES5_E10get_resultEv: 113| 16| { 114| 16| JSONCONS_ASSERT(is_valid_); ------------------ | | 45| 16|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 16] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 115| 16| is_valid_ = false; 116| 16| return std::move(result_); 117| 16| } _ZN8jsoncons14json_exceptionD2Ev: 27| 4.37k| virtual ~json_exception() = default; _ZN8jsoncons9ser_errorC1ENSt3__110error_codeEmm: 194| 4.37k| : ec_(ec), line_(line), column_(column) 195| 4.37k| { 196| 4.37k| err_ = to_what_arg(ec, "", line, column); 197| 4.37k| } _ZN8jsoncons9ser_error11to_what_argENSt3__110error_codeEPKcmm: 233| 4.37k| { 234| 4.37k| std::string what_arg(s); 235| 4.37k| if (!what_arg.empty()) ------------------ | Branch (235:17): [True: 0, False: 4.37k] ------------------ 236| 0| { 237| 0| what_arg.append(": "); 238| 0| } 239| 4.37k| what_arg.append(ec.message()); 240| 4.37k| if (line != 0 && column != 0) ------------------ | Branch (240:17): [True: 0, False: 4.37k] | Branch (240:30): [True: 0, False: 0] ------------------ 241| 0| { 242| 0| what_arg.append(" at line "); 243| 0| what_arg.append(std::to_string(line)); 244| 0| what_arg.append(" and column "); 245| 0| what_arg.append(std::to_string(column)); 246| 0| } 247| 4.37k| else if (column != 0) ------------------ | Branch (247:22): [True: 4.37k, False: 0] ------------------ 248| 4.37k| { 249| 4.37k| what_arg.append(" at position "); 250| 4.37k| what_arg.append(std::to_string(column)); 251| 4.37k| } 252| 4.37k| return what_arg; 253| 4.37k| } _ZN8jsoncons25make_json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEEENS_20json_visitor_adaptorIT_T0_vEERSD_: 1064| 4.39k|{ 1065| 4.39k| return json_visitor_adaptor(to); 1066| 4.39k|} _ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvEC2ERSA_: 983| 4.39k| : supertype(visitor) 984| 4.39k| { 985| 4.39k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEEC2ERSA_: 721| 4.39k| : destination1_(std::addressof(visitor)) 722| 4.39k| { 723| 4.39k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE15visit_end_arrayERKNS_11ser_contextERNS6_10error_codeE: 783| 18.1k| { 784| 18.1k| destination1_->end_array(context, ec); 785| 18.1k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 18.1k|#define JSONCONS_VISITOR_RETURN return true ------------------ 786| 18.1k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE12visit_uint64EmNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 825| 15.5k| { 826| 15.5k| destination1_->uint64_value(value, tag, context, ec); 827| 15.5k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.5k|#define JSONCONS_VISITOR_RETURN return true ------------------ 828| 15.5k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11visit_int64ElNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 819| 151k| { 820| 151k| destination1_->int64_value(value, tag, context, ec); 821| 151k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 151k|#define JSONCONS_VISITOR_RETURN return true ------------------ 822| 151k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE12visit_doubleEdNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 813| 13.3k| { 814| 13.3k| destination1_->double_value(value, tag, context, ec); 815| 13.3k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 13.3k|#define JSONCONS_VISITOR_RETURN return true ------------------ 816| 13.3k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11visit_flushEv: 738| 16| { 739| 16| destination1_->flush(); 740| 16| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE18visit_begin_objectENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 745| 36.9k| { 746| 36.9k| destination1_->begin_object(tag, context, ec); 747| 36.9k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 36.9k|#define JSONCONS_VISITOR_RETURN return true ------------------ 748| 36.9k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE16visit_end_objectERKNS_11ser_contextERNS6_10error_codeE: 760| 24.8k| { 761| 24.8k| destination1_->end_object(context, ec); 762| 24.8k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 24.8k|#define JSONCONS_VISITOR_RETURN return true ------------------ 763| 24.8k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_begin_arrayENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 768| 40.7k| { 769| 40.7k| destination1_->begin_array(tag, context, ec); 770| 40.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 40.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 771| 40.7k| } _ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvE9visit_keyERKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEERKNS_11ser_contextERNS6_10error_codeE: 995| 9.98M| { 996| 9.98M| return destination().key(string_view_type(reinterpret_cast(key.data()),key.size()), context, ec); 997| 9.98M| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE11destinationEv: 732| 10.0M| { 733| 10.0M| return *destination1_; 734| 10.0M| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE10visit_nullENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 837| 20.7M| { 838| 20.7M| destination1_->null_value(tag, context, ec); 839| 20.7M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 20.7M|#define JSONCONS_VISITOR_RETURN return true ------------------ 840| 20.7M| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE10visit_boolEbNS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 831| 56.9k| { 832| 56.9k| destination1_->bool_value(value, tag, context, ec); 833| 56.9k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 56.9k|#define JSONCONS_VISITOR_RETURN return true ------------------ 834| 56.9k| } _ZN8jsoncons20json_visitor_adaptorINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEvE12visit_stringERKNS6_17basic_string_viewIcNS6_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS6_10error_codeE: 1003| 37.0k| { 1004| 37.0k| return destination().string_value(string_view_type(reinterpret_cast(value.data()),value.size()), tag, context, ec); 1005| 37.0k| } _ZN8jsoncons25json_visitor_adaptor_baseINS_18basic_json_visitorIcEENS_12json_decoderINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEES8_EEE17visit_byte_stringERKNS_16byte_string_viewEmRKNS_11ser_contextERNS6_10error_codeE: 801| 15.8k| { 802| 15.8k| destination1_->byte_string_value(b, ext_tag, context, ec); 803| 15.8k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.8k|#define JSONCONS_VISITOR_RETURN return true ------------------ 804| 15.8k| } _ZNK8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5emptyEv: 432| 3.43k| { 433| 3.43k| return members_.empty(); 434| 3.43k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5clearEv: 465| 3.26k| void clear() {members_.clear();} _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE5beginEv: 442| 3.26k| { 443| 3.26k| return members_.begin(); 444| 3.26k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE3endEv: 447| 3.26k| { 448| 3.26k| return members_.end(); 449| 3.26k| } _ZN8jsoncons9key_valueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EEE5valueEv: 120| 59.8k| { 121| 59.8k| return value_; 122| 59.8k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEED2Ev: 427| 36.9k| { 428| 36.9k| flatten_and_destroy(); 429| 36.9k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE19flatten_and_destroyEv: 986| 36.9k| { 987| 36.9k| if (!members_.empty()) ------------------ | Branch (987:17): [True: 10.1k, False: 26.7k] ------------------ 988| 10.1k| { 989| 10.1k| json_array temp(get_allocator()); 990| | 991| 10.1k| for (auto& kv : members_) ------------------ | Branch (991:31): [True: 39.9k, False: 10.1k] ------------------ 992| 39.9k| { 993| 39.9k| switch (kv.value().storage_kind()) 994| 39.9k| { 995| 4.25k| case json_storage_kind::array: ------------------ | Branch (995:25): [True: 4.25k, False: 35.7k] ------------------ 996| 6.13k| case json_storage_kind::object: ------------------ | Branch (996:25): [True: 1.88k, False: 38.0k] ------------------ 997| 6.13k| if (!kv.value().empty()) ------------------ | Branch (997:33): [True: 3.29k, False: 2.84k] ------------------ 998| 3.29k| { 999| 3.29k| temp.emplace_back(std::move(kv.value())); 1000| 3.29k| } 1001| 6.13k| break; 1002| 33.8k| default: ------------------ | Branch (1002:25): [True: 33.8k, False: 6.13k] ------------------ 1003| 33.8k| break; 1004| 39.9k| } 1005| 39.9k| } 1006| 10.1k| } 1007| 36.9k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2EOS7_: 49| 53.9M| index_key_value(index_key_value&&) = default; _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEEC2Ev: 334| 36.9k| { 335| 36.9k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEaSEOS7_: 60| 45.5M| index_key_value& operator=(index_key_value&&) = default; _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRmRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 15.5k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 15.5k| { 45| 15.5k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRlRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 151k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 151k| { 45| 151k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRdRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 13.3k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 13.3k| { 45| 13.3k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_17json_object_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 36.9k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 36.9k| { 45| 36.9k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE18uninitialized_initEPNS_15index_key_valueISA_EEm: 539| 13.0k| { 540| 13.0k| if (count > 0) ------------------ | Branch (540:17): [True: 13.0k, False: 0] ------------------ 541| 13.0k| { 542| 13.0k| members_.reserve(count); 543| | 544| 13.0k| std::sort(items, items+count, compare); 545| 13.0k| members_.emplace_back(key_type(items[0].name.data(), items[0].name.size(), get_allocator()), std::move(items[0].value)); 546| | 547| 8.64M| for (std::size_t i = 1; i < count; ++i) ------------------ | Branch (547:41): [True: 8.62M, False: 13.0k] ------------------ 548| 8.62M| { 549| 8.62M| auto& item = items[i]; 550| 8.62M| if (item.name != items[i-1].name) ------------------ | Branch (550:25): [True: 31.1k, False: 8.59M] ------------------ 551| 31.1k| { 552| 31.1k| members_.emplace_back(key_type(item.name.data(), item.name.size(), get_allocator()), std::move(item.value)); 553| 31.1k| } 554| 8.62M| } 555| 13.0k| } 556| 13.0k| } _ZN8jsoncons18sorted_json_objectINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EENS1_6vectorEE7compareERKNS_15index_key_valueISA_EESG_: 530| 201M| { 531| 201M| int comp = item1.name.compare(item2.name); 532| 201M| if (comp < 0) return true; ------------------ | Branch (532:17): [True: 1.55M, False: 200M] ------------------ 533| 200M| if (comp == 0) return item1.index < item2.index; ------------------ | Branch (533:17): [True: 199M, False: 654k] ------------------ 534| | 535| 654k| return false; 536| 200M| } _ZN8jsoncons9key_valueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES6_EEEC2IJSA_EEEOS7_DpOT_: 86| 44.2k| : key_(std::move(name)), value_(std::forward(args)...) 87| 44.2k| { 88| 44.2k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_16json_array_arg_tERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 40.7k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 40.7k| { 45| 40.7k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJNS_9null_typeERNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 20.7M| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 20.7M| { 45| 20.7M| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRbRNS_12semantic_tagEEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 56.9k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 56.9k| { 45| 56.9k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEERNS_12semantic_tagEEEEONS3_12basic_stringIcSB_S5_EElDpOT_: 43| 37.0k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 37.0k| { 45| 37.0k| } _ZN8jsoncons15index_key_valueINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEC2IJRKNS_17byte_string_arg_tERKNS_16byte_string_viewERmEEEONS3_12basic_stringIcNS3_11char_traitsIcEES5_EElDpOT_: 43| 15.8k| : name(std::move(Name)), index(Index), value(std::forward(args)...) 44| 15.8k| { 45| 15.8k| } _ZN8jsoncons18is_trivial_storageENS_17json_storage_kindE: 210| 159M| { 211| 159M| static const uint8_t mask{ uint8_t(json_storage_kind::long_str) & uint8_t(json_storage_kind::byte_str) 212| 159M| & uint8_t(json_storage_kind::array) & uint8_t(json_storage_kind::object) }; 213| 159M| return (uint8_t(storage_kind) & mask) != mask; 214| 159M| } _ZN8jsoncons18basic_json_visitorIcEC2Ev: 103| 8.78k| basic_json_visitor() = default; _ZN8jsoncons19typed_array_visitorD2Ev: 33| 8.78k| virtual ~typed_array_visitor() = default; _ZN8jsoncons18basic_json_visitorIcE12uint64_valueEmNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 414| 31.0k| { 415| 31.0k| visit_uint64(value, tag, context, ec); 416| 31.0k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 31.0k|#define JSONCONS_VISITOR_RETURN return true ------------------ 417| 31.0k| } _ZN8jsoncons18basic_json_visitorIcE9end_arrayERKNS_11ser_contextERNSt3__110error_codeE: 351| 36.3k| { 352| 36.3k| visit_end_array(context, ec); 353| 36.3k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 36.3k|#define JSONCONS_VISITOR_RETURN return true ------------------ 354| 36.3k| } _ZN8jsoncons18basic_json_visitorIcE11int64_valueElNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 423| 302k| { 424| 302k| visit_int64(value, tag, context, ec); 425| 302k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 302k|#define JSONCONS_VISITOR_RETURN return true ------------------ 426| 302k| } _ZN8jsoncons18basic_json_visitorIcE12double_valueEdNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 441| 26.7k| { 442| 26.7k| visit_double(value, tag, context, ec); 443| 26.7k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 26.7k|#define JSONCONS_VISITOR_RETURN return true ------------------ 444| 26.7k| } _ZN8jsoncons18basic_json_visitorIcE5flushEv: 108| 32| { 109| 32| visit_flush(); 110| 32| } _ZN8jsoncons18basic_json_visitorIcE12begin_objectENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 318| 73.9k| { 319| 73.9k| visit_begin_object(tag, context, ec); 320| 73.9k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 73.9k|#define JSONCONS_VISITOR_RETURN return true ------------------ 321| 73.9k| } _ZN8jsoncons18basic_json_visitorIcE10end_objectERKNS_11ser_contextERNSt3__110error_codeE: 333| 49.6k| { 334| 49.6k| visit_end_object(context, ec); 335| 49.6k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 49.6k|#define JSONCONS_VISITOR_RETURN return true ------------------ 336| 49.6k| } _ZN8jsoncons18basic_json_visitorIcE11begin_arrayENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 339| 81.5k| { 340| 81.5k| visit_begin_array(tag, context, ec); 341| 81.5k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 81.5k|#define JSONCONS_VISITOR_RETURN return true ------------------ 342| 81.5k| } _ZN8jsoncons18basic_json_visitorIcE3keyERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERKNS_11ser_contextERNS2_10error_codeE: 357| 19.9M| { 358| 19.9M| visit_key(name, context, ec); 359| 19.9M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 19.9M|#define JSONCONS_VISITOR_RETURN return true ------------------ 360| 19.9M| } _ZN8jsoncons18basic_json_visitorIcE10null_valueENS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 365| 41.5M| { 366| 41.5M| visit_null(tag, context, ec); 367| 41.5M| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 41.5M|#define JSONCONS_VISITOR_RETURN return true ------------------ 368| 41.5M| } _ZN8jsoncons18basic_json_visitorIcE10bool_valueEbNS_12semantic_tagERKNS_11ser_contextERNSt3__110error_codeE: 374| 113k| { 375| 113k| visit_bool(value, tag, context, ec); 376| 113k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 113k|#define JSONCONS_VISITOR_RETURN return true ------------------ 377| 113k| } _ZN8jsoncons18basic_json_visitorIcE12string_valueERKNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS_12semantic_tagERKNS_11ser_contextERNS2_10error_codeE: 383| 74.1k| { 384| 74.1k| visit_string(value, tag, context, ec); 385| 74.1k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 74.1k|#define JSONCONS_VISITOR_RETURN return true ------------------ 386| 74.1k| } _ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINS_16byte_string_viewEEEbRKT_mRKNS_11ser_contextERNSt3__110error_codeENSA_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS4_EE5valueEiE4typeE: 405| 15.8k| { 406| 15.8k| visit_byte_string(byte_string_view(reinterpret_cast(b.data()),b.size()), ext_tag, context, ec); 407| 15.8k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.8k|#define JSONCONS_VISITOR_RETURN return true ------------------ 408| 15.8k| } _ZN8jsoncons18basic_json_visitorIcE17byte_string_valueINSt3__16vectorIhNS3_9allocatorIhEEEEEEbRKT_mRKNS_11ser_contextERNS3_10error_codeENS3_9enable_ifIXsr10ext_traits18is_bytes_view_likeIS8_EE5valueEiE4typeE: 405| 15.8k| { 406| 15.8k| visit_byte_string(byte_string_view(reinterpret_cast(b.data()),b.size()), ext_tag, context, ec); 407| 15.8k| JSONCONS_VISITOR_RETURN; ------------------ | | 272| 15.8k|#define JSONCONS_VISITOR_RETURN return true ------------------ 408| 15.8k| } _ZN8jsoncons11ser_contextD2Ev: 21| 4.39k| virtual ~ser_context() = default; _ZN8jsoncons10read_errorC2ENSt3__110error_codeEmm: 63| 4.37k| : ec_{ec}, line_{line}, column_{column} 64| 4.37k| { 65| 4.37k| } _ZNK8jsoncons10read_error4codeEv: 81| 4.37k| { 82| 4.37k| return ec_; 83| 4.37k| } _ZNK8jsoncons10read_error4lineEv: 89| 4.37k| { 90| 4.37k| return line_; 91| 4.37k| } _ZNK8jsoncons10read_error6columnEv: 93| 4.37k| { 94| 4.37k| return column_; 95| 4.37k| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEEC2ERNS1_13basic_istreamIcNS1_11char_traitsIcEEEERKS3_: 171| 4.39k| : alloc_(alloc), stream_ptr_(std::addressof(is)), sbuf_(is.rdbuf()), 172| 4.39k| buffer_size_(default_max_buffer_size) 173| 4.39k| { 174| 4.39k| buffer_ = std::allocator_traits::allocate(alloc_, buffer_size_); 175| 4.39k| data_ = buffer_; 176| 4.39k| } _ZN8jsoncons18basic_null_istreamIcEC1Ev: 54| 4.39k| : std::basic_istream(&nb_) 55| 4.39k| { 56| 4.39k| } _ZN8jsoncons18basic_null_istreamIcE11null_bufferC2Ev: 40| 4.39k| null_buffer() = default; _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEED2Ev: 188| 4.39k| { 189| 4.39k| if (buffer_) ------------------ | Branch (189:17): [True: 4.39k, False: 0] ------------------ 190| 4.39k| { 191| 4.39k| std::allocator_traits::deallocate(alloc_, buffer_, buffer_size_); 192| 4.39k| } 193| 4.39k| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8positionEv: 281| 4.37k| { 282| 4.37k| return position_; 283| 4.37k| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE8is_errorEv: 276| 4.39k| { 277| 4.39k| return stream_ptr_->bad(); 278| 4.39k| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE4readEPhm: 343| 82.6M| { 344| 82.6M| std::size_t len = 0; 345| 82.6M| if (length_ > 0) ------------------ | Branch (345:17): [True: 82.5M, False: 10.5k] ------------------ 346| 82.5M| { 347| 82.5M| len = (std::min)(length_, length); 348| 82.5M| std::memcpy(p, data_, len*sizeof(value_type)); 349| 82.5M| data_ += len; 350| 82.5M| length_ -= len; 351| 82.5M| position_ += len; 352| 82.5M| } 353| 82.6M| if (length - len == 0) ------------------ | Branch (353:17): [True: 82.5M, False: 11.2k] ------------------ 354| 82.5M| { 355| 82.5M| return len; 356| 82.5M| } 357| 11.2k| else if (length - len < buffer_size_) ------------------ | Branch (357:22): [True: 10.9k, False: 244] ------------------ 358| 10.9k| { 359| 10.9k| fill_buffer(); 360| 10.9k| if (length_ > 0) ------------------ | Branch (360:21): [True: 9.59k, False: 1.39k] ------------------ 361| 9.59k| { 362| 9.59k| std::size_t len2 = (std::min)(length_, length-len); 363| 9.59k| std::memcpy(p+len, data_, len2*sizeof(value_type)); 364| 9.59k| data_ += len2; 365| 9.59k| length_ -= len2; 366| 9.59k| position_ += len2; 367| 9.59k| len += len2; 368| 9.59k| } 369| 10.9k| return len; 370| 10.9k| } 371| 244| else 372| 244| { 373| 244| if (stream_ptr_->eof()) ------------------ | Branch (373:21): [True: 0, False: 244] ------------------ 374| 0| { 375| 0| length_ = 0; 376| 0| return 0; 377| 0| } 378| 244| JSONCONS_TRY ------------------ | | 37| 244| #define JSONCONS_TRY try ------------------ 379| 244| { 380| 244| std::streamsize count = sbuf_->sgetn(reinterpret_cast(p+len), length-len); 381| 244| std::size_t len2 = static_cast(count); 382| 244| if (len2 < length-len) ------------------ | Branch (382:25): [True: 26, False: 218] ------------------ 383| 26| { 384| 26| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit); 385| 26| } 386| 244| len += len2; 387| 244| position_ += len2; 388| 244| return len; 389| 244| } 390| 244| JSONCONS_CATCH(const std::exception&) 391| 244| { 392| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit); 393| 0| return 0; 394| 0| } 395| 244| } 396| 82.6M| } _ZN8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE11fill_bufferEv: 399| 10.9k| { 400| 10.9k| if (stream_ptr_->eof()) ------------------ | Branch (400:17): [True: 1.36k, False: 9.62k] ------------------ 401| 1.36k| { 402| 1.36k| length_ = 0; 403| 1.36k| return; 404| 1.36k| } 405| | 406| 9.62k| data_ = buffer_; 407| 9.62k| JSONCONS_TRY ------------------ | | 37| 9.62k| #define JSONCONS_TRY try ------------------ 408| 9.62k| { 409| 9.62k| std::streamsize count = sbuf_->sgetn(reinterpret_cast(buffer_), buffer_size_); 410| 9.62k| length_ = static_cast(count); 411| | 412| 9.62k| if (length_ < buffer_size_) ------------------ | Branch (412:21): [True: 4.35k, False: 5.27k] ------------------ 413| 4.35k| { 414| 4.35k| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::eofbit); 415| 4.35k| } 416| 9.62k| } 417| 9.62k| JSONCONS_CATCH(const std::exception&) 418| 9.62k| { 419| 0| stream_ptr_->clear(stream_ptr_->rdstate() | std::ios::badbit | std::ios::eofbit); 420| 0| length_ = 0; 421| 0| } 422| 9.62k| } _ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_12basic_stringIcNS2_11char_traitsIcEENS3_IcEEEEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISE_EE5valuentsr10ext_traits14has_data_exactIPhSE_EE5valueEmE4typeERS5_RSE_m: 882| 2.38k| { 883| 2.38k| std::size_t unread = length; 884| | 885| 2.38k| std::size_t n = (std::min)(max_buffer_length, unread); 886| 3.87k| while (n > 0 && !source.eof()) ------------------ | Branch (886:20): [True: 1.62k, False: 2.24k] | Branch (886:29): [True: 1.49k, False: 134] ------------------ 887| 1.49k| { 888| 1.49k| v.reserve(v.size()+n); 889| 1.49k| std::size_t actual = 0; 890| 9.04M| while (actual < n) ------------------ | Branch (890:24): [True: 9.03M, False: 1.41k] ------------------ 891| 9.03M| { 892| 9.03M| typename Source::value_type c{}; 893| 9.03M| if (source.read(&c,1) != 1) ------------------ | Branch (893:25): [True: 82, False: 9.03M] ------------------ 894| 82| { 895| 82| break; 896| 82| } 897| 9.03M| v.push_back(c); 898| 9.03M| ++actual; 899| 9.03M| } 900| 1.49k| unread -= actual; 901| 1.49k| n = (std::min)(max_buffer_length, unread); 902| 1.49k| } 903| | 904| 2.38k| return length - unread; 905| 2.38k| } _ZNK8jsoncons13stream_sourceIhNSt3__19allocatorIhEEE3eofEv: 271| 10.8k| { 272| 10.8k| return length_ == 0 && stream_ptr_->eof(); ------------------ | Branch (272:20): [True: 685, False: 10.1k] | Branch (272:36): [True: 360, False: 325] ------------------ 273| 10.8k| } _ZN8jsoncons13source_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEEE4readINS2_6vectorIhS4_EEEENS2_9enable_ifIXaaaasr3std14is_convertibleIhNT_10value_typeEEE5valuesr10ext_traits11has_reserveISB_EE5valuesr10ext_traits14has_data_exactIPhSB_EE5valueEmE4typeERS5_RSB_m: 859| 16.0k| { 860| 16.0k| std::size_t unread = length; 861| | 862| 16.0k| std::size_t n = (std::min)(max_buffer_length, unread); 863| 25.0k| while (n > 0 && !source.eof()) ------------------ | Branch (863:20): [True: 9.23k, False: 15.8k] | Branch (863:29): [True: 9.00k, False: 226] ------------------ 864| 9.00k| { 865| 9.00k| std::size_t offset = v.size(); 866| 9.00k| v.resize(v.size()+n); 867| 9.00k| std::size_t actual = source.read(v.data()+offset, n); 868| 9.00k| unread -= actual; 869| 9.00k| n = (std::min)(max_buffer_length, unread); 870| 9.00k| } 871| | 872| 16.0k| return length - unread; 873| 16.0k| } _ZN8jsoncons6binary16little_to_nativeIiNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 197| 233k| { 198| 233k| if (sizeof(T) > count) ------------------ | Branch (198:13): [True: 0, False: 233k] ------------------ 199| 0| { 200| 0| return T{}; 201| 0| } 202| 233k| T val; 203| 233k| std::memcpy(&val,first,sizeof(T)); 204| 233k| return val; 205| 233k| } _ZN8jsoncons6binary16little_to_nativeIdNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 197| 13.3k| { 198| 13.3k| if (sizeof(T) > count) ------------------ | Branch (198:13): [True: 0, False: 13.3k] ------------------ 199| 0| { 200| 0| return T{}; 201| 0| } 202| 13.3k| T val; 203| 13.3k| std::memcpy(&val,first,sizeof(T)); 204| 13.3k| return val; 205| 13.3k| } _ZN8jsoncons6binary16little_to_nativeImNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 197| 40.7k| { 198| 40.7k| if (sizeof(T) > count) ------------------ | Branch (198:13): [True: 0, False: 40.7k] ------------------ 199| 0| { 200| 0| return T{}; 201| 0| } 202| 40.7k| T val; 203| 40.7k| std::memcpy(&val,first,sizeof(T)); 204| 40.7k| return val; 205| 40.7k| } _ZN8jsoncons6binary16little_to_nativeIlNS_6detail6endianEEENSt3__19enable_ifIXeqsrT0_6nativesrS6_6littleET_E4typeEPKhm: 197| 13.6k| { 198| 13.6k| if (sizeof(T) > count) ------------------ | Branch (198:13): [True: 0, False: 13.6k] ------------------ 199| 0| { 200| 0| return T{}; 201| 0| } 202| 13.6k| T val; 203| 13.6k| std::memcpy(&val,first,sizeof(T)); 204| 13.6k| return val; 205| 13.6k| } _ZNK8jsoncons16byte_string_view4dataEv: 399| 31.6k| { 400| 31.6k| return data_; 401| 31.6k| } _ZNK8jsoncons16byte_string_view4sizeEv: 403| 31.6k| { 404| 31.6k| return size_; 405| 31.6k| } _ZN8jsoncons16byte_string_viewC2EPKhm: 362| 31.6k| : data_(data), size_(length) 363| 31.6k| { 364| 31.6k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE7destroyEPNS0_11heap_stringIcS2_S5_EE: 169| 15.7k| { 170| 15.7k| if (ptr != nullptr) ------------------ | Branch (170:13): [True: 15.7k, False: 0] ------------------ 171| 15.7k| { 172| 15.7k| heap_string_type* rawp = ext_traits::to_plain_pointer(ptr); 173| | 174| 15.7k| char* q = launder_cast(rawp); 175| | 176| 15.7k| char* p = q - ptr->offset_; 177| | 178| 15.7k| std::size_t mem_size = ptr->align_pad_ + aligned_size(ptr->length_*sizeof(char_type)); 179| 15.7k| byte_allocator_type byte_alloc(ptr->get_allocator()); 180| 15.7k| byte_alloc.deallocate(p,mem_size); 181| 15.7k| } 182| 15.7k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE12aligned_sizeEm: 119| 31.5k| { 120| 31.5k| return sizeof(storage_type) + n; 121| 31.5k| } _ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEE13get_allocatorEv: 35| 15.7k| { 36| 15.7k| return alloc_; 37| 15.7k| } _ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE7destroyEPNS0_11heap_stringIhmS4_EE: 169| 15.8k| { 170| 15.8k| if (ptr != nullptr) ------------------ | Branch (170:13): [True: 15.8k, False: 0] ------------------ 171| 15.8k| { 172| 15.8k| heap_string_type* rawp = ext_traits::to_plain_pointer(ptr); 173| | 174| 15.8k| char* q = launder_cast(rawp); 175| | 176| 15.8k| char* p = q - ptr->offset_; 177| | 178| 15.8k| std::size_t mem_size = ptr->align_pad_ + aligned_size(ptr->length_*sizeof(char_type)); 179| 15.8k| byte_allocator_type byte_alloc(ptr->get_allocator()); 180| 15.8k| byte_alloc.deallocate(p,mem_size); 181| 15.8k| } 182| 15.8k| } _ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE12aligned_sizeEm: 119| 31.6k| { 120| 31.6k| return sizeof(storage_type) + n; 121| 31.6k| } _ZN8jsoncons4heap16heap_string_baseImNSt3__19allocatorIcEEE13get_allocatorEv: 35| 15.8k| { 36| 15.8k| return alloc_; 37| 15.8k| } _ZN8jsoncons4heap19heap_string_factoryIcNS_9null_typeENSt3__19allocatorIcEEE6createEPKcmS2_RKS5_: 126| 15.7k| { 127| 15.7k| std::size_t len = aligned_size(length*sizeof(char_type)); 128| | 129| 15.7k| std::size_t align = alignof(storage_type); 130| 15.7k| char* q = nullptr; 131| 15.7k| char* storage = nullptr; 132| 15.7k| byte_allocator_type byte_alloc(alloc); 133| 15.7k| uint8_t align_pad = 0; 134| | 135| 15.7k| if (align <= 8) { ------------------ | Branch (135:13): [True: 15.7k, False: 0] ------------------ 136| 15.7k| byte_pointer ptr = byte_alloc.allocate(len); 137| 15.7k| q = ext_traits::to_plain_pointer(ptr); 138| | 139| 15.7k| if (reinterpret_cast(q) % align == 0) { ------------------ | Branch (139:17): [True: 15.7k, False: 0] ------------------ 140| 15.7k| storage = q; 141| 15.7k| } else { 142| 0| byte_alloc.deallocate(ptr, len); 143| 0| } 144| 15.7k| } 145| | 146| 15.7k| if (storage == nullptr) { ------------------ | Branch (146:13): [True: 0, False: 15.7k] ------------------ 147| 0| align_pad = uint8_t(align-1); 148| 0| byte_pointer ptr = byte_alloc.allocate(align_pad+len); 149| 0| q = ext_traits::to_plain_pointer(ptr); 150| 0| storage = align_up(q, align); 151| 0| JSONCONS_ASSERT(storage >= q); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 152| 0| } 153| | 154| 15.7k| heap_string_type* ps = new(storage)heap_string_type(extra, byte_alloc); 155| | 156| 15.7k| auto psa = launder_cast(storage); 157| | 158| 15.7k| CharT* p = new(&psa->c)char_type[length + 1]; 159| 15.7k| std::memcpy(p, s, length*sizeof(char_type)); 160| 15.7k| p[length] = 0; 161| 15.7k| ps->p_ = std::pointer_traits::pointer_to(*p); 162| 15.7k| ps->length_ = length; 163| 15.7k| ps->offset_ = (uint8_t)(storage - q); 164| 15.7k| ps->align_pad_ = align_pad; 165| 15.7k| return std::pointer_traits::pointer_to(*ps); 166| 15.7k| } _ZN8jsoncons4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEC2ES2_RKS5_: 69| 15.7k| : heap_string_base(extra, alloc) 70| 15.7k| { 71| 15.7k| } _ZN8jsoncons4heap16heap_string_baseINS_9null_typeENSt3__19allocatorIcEEEC2ERKS2_RKS5_: 45| 15.7k| : extra_(extra), alloc_(alloc) 46| 15.7k| { 47| 15.7k| } _ZN8jsoncons4heap19heap_string_factoryIhmNSt3__19allocatorIcEEE6createEPKhmmRKS4_: 126| 15.8k| { 127| 15.8k| std::size_t len = aligned_size(length*sizeof(char_type)); 128| | 129| 15.8k| std::size_t align = alignof(storage_type); 130| 15.8k| char* q = nullptr; 131| 15.8k| char* storage = nullptr; 132| 15.8k| byte_allocator_type byte_alloc(alloc); 133| 15.8k| uint8_t align_pad = 0; 134| | 135| 15.8k| if (align <= 8) { ------------------ | Branch (135:13): [True: 15.8k, False: 0] ------------------ 136| 15.8k| byte_pointer ptr = byte_alloc.allocate(len); 137| 15.8k| q = ext_traits::to_plain_pointer(ptr); 138| | 139| 15.8k| if (reinterpret_cast(q) % align == 0) { ------------------ | Branch (139:17): [True: 15.8k, False: 0] ------------------ 140| 15.8k| storage = q; 141| 15.8k| } else { 142| 0| byte_alloc.deallocate(ptr, len); 143| 0| } 144| 15.8k| } 145| | 146| 15.8k| if (storage == nullptr) { ------------------ | Branch (146:13): [True: 0, False: 15.8k] ------------------ 147| 0| align_pad = uint8_t(align-1); 148| 0| byte_pointer ptr = byte_alloc.allocate(align_pad+len); 149| 0| q = ext_traits::to_plain_pointer(ptr); 150| 0| storage = align_up(q, align); 151| 0| JSONCONS_ASSERT(storage >= q); ------------------ | | 45| 0|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 0] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 152| 0| } 153| | 154| 15.8k| heap_string_type* ps = new(storage)heap_string_type(extra, byte_alloc); 155| | 156| 15.8k| auto psa = launder_cast(storage); 157| | 158| 15.8k| CharT* p = new(&psa->c)char_type[length + 1]; 159| 15.8k| std::memcpy(p, s, length*sizeof(char_type)); 160| 15.8k| p[length] = 0; 161| 15.8k| ps->p_ = std::pointer_traits::pointer_to(*p); 162| 15.8k| ps->length_ = length; 163| 15.8k| ps->offset_ = (uint8_t)(storage - q); 164| 15.8k| ps->align_pad_ = align_pad; 165| 15.8k| return std::pointer_traits::pointer_to(*ps); 166| 15.8k| } _ZN8jsoncons4heap11heap_stringIhmNSt3__19allocatorIcEEEC2EmRKS4_: 69| 15.8k| : heap_string_base(extra, alloc) 70| 15.8k| { 71| 15.8k| } _ZN8jsoncons4heap16heap_string_baseImNSt3__19allocatorIcEEEC2ERKmRKS4_: 45| 15.8k| : extra_(extra), alloc_(alloc) 46| 15.8k| { 47| 15.8k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIcNS_9null_typeENSt3__19allocatorIcEEEEEEPT_SA_: 241| 15.7k| { 242| 15.7k| return (ptr); 243| 15.7k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_4heap11heap_stringIhmNSt3__19allocatorIcEEEEEEPT_S9_: 241| 15.8k| { 242| 15.8k| return (ptr); 243| 15.8k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_10json_arrayINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEENS5_6vectorEEEEEPT_SC_: 241| 81.5k| { 242| 81.5k| return (ptr); 243| 81.5k| } _ZN8jsoncons10ext_traits16to_plain_pointerINS_18sorted_json_objectINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_10basic_jsonIcNS_13sorted_policyES8_EENS3_6vectorEEEEEPT_SG_: 241| 73.9k| { 242| 73.9k| return (ptr); 243| 73.9k| } _ZN8jsoncons10ext_traits16to_plain_pointerIcEEPT_S3_: 241| 31.6k| { 242| 31.6k| return (ptr); 243| 31.6k| } _ZN8jsoncons14unicode_traits8validateIcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_14convert_resultIS4_EEE4typeEPKS4_m: 1134| 9.98M| { 1135| 9.98M| conv_errc result = conv_errc(); 1136| 9.98M| const CharT* last = data + length; 1137| 30.9M| while (data != last) ------------------ | Branch (1137:16): [True: 20.9M, False: 9.98M] ------------------ 1138| 20.9M| { 1139| 20.9M| std::size_t len = static_cast(trailing_bytes_for_utf8[static_cast(*data)]) + 1; 1140| 20.9M| if (len > (std::size_t)(last - data)) ------------------ | Branch (1140:17): [True: 19, False: 20.9M] ------------------ 1141| 19| { 1142| 19| return convert_result{data, conv_errc::source_exhausted}; 1143| 19| } 1144| 20.9M| if ((result=is_legal_utf8(data, len)) != conv_errc()) ------------------ | Branch (1144:17): [True: 130, False: 20.9M] ------------------ 1145| 130| { 1146| 130| return convert_result{data,result} ; 1147| 130| } 1148| 20.9M| data += len; 1149| 20.9M| } 1150| 9.98M| return convert_result{data,result} ; 1151| 9.98M| } _ZN8jsoncons14unicode_traits13is_legal_utf8IcEENSt3__19enable_ifIXsr10ext_traits8is_char8IT_EE5valueENS0_9conv_errcEE4typeEPKS4_m: 303| 20.9M| { 304| 20.9M| uint8_t a; 305| 20.9M| const CharT* srcptr = first+length; 306| 20.9M| switch (length) { 307| 24| default: ------------------ | Branch (307:9): [True: 24, False: 20.9M] ------------------ 308| 24| return conv_errc::over_long_utf8_sequence; 309| 4.76k| case 4: ------------------ | Branch (309:9): [True: 4.76k, False: 20.9M] ------------------ 310| 4.76k| if (((a = (*--srcptr))& 0xC0) != 0x80) ------------------ | Branch (310:17): [True: 15, False: 4.75k] ------------------ 311| 15| return conv_errc::expected_continuation_byte; 312| 4.75k| JSONCONS_FALLTHROUGH; ------------------ | | 564| 4.75k|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 313| 8.10k| case 3: ------------------ | Branch (313:9): [True: 3.35k, False: 20.9M] ------------------ 314| 8.10k| if (((a = (*--srcptr))& 0xC0) != 0x80) ------------------ | Branch (314:17): [True: 15, False: 8.09k] ------------------ 315| 15| return conv_errc::expected_continuation_byte; 316| 8.09k| JSONCONS_FALLTHROUGH; ------------------ | | 564| 8.09k|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 317| 9.16k| case 2: ------------------ | Branch (317:9): [True: 1.07k, False: 20.9M] ------------------ 318| 9.16k| if (((a = (*--srcptr))& 0xC0) != 0x80) ------------------ | Branch (318:17): [True: 23, False: 9.14k] ------------------ 319| 23| return conv_errc::expected_continuation_byte; 320| | 321| 9.14k| switch (static_cast(*first)) 322| 9.14k| { 323| | // no fall-through in this inner switch 324| 1.06k| case 0xE0: if (a < 0xA0) return conv_errc::source_illegal; break; ------------------ | Branch (324:17): [True: 1.06k, False: 8.08k] | Branch (324:32): [True: 8, False: 1.05k] ------------------ 325| 1.05k| case 0xED: if (a > 0x9F) return conv_errc::source_illegal; break; ------------------ | Branch (325:17): [True: 590, False: 8.55k] | Branch (325:32): [True: 3, False: 587] ------------------ 326| 587| case 0xF0: if (a < 0x90) return conv_errc::source_illegal; break; ------------------ | Branch (326:17): [True: 426, False: 8.71k] | Branch (326:32): [True: 6, False: 420] ------------------ 327| 420| case 0xF4: if (a > 0x8F) return conv_errc::source_illegal; break; ------------------ | Branch (327:17): [True: 392, False: 8.75k] | Branch (327:32): [True: 4, False: 388] ------------------ 328| 6.67k| default: if (a < 0x80) return conv_errc::source_illegal; ------------------ | Branch (328:17): [True: 6.67k, False: 2.46k] | Branch (328:32): [True: 0, False: 6.67k] ------------------ 329| 9.14k| } 330| | 331| 9.12k| JSONCONS_FALLTHROUGH; ------------------ | | 564| 9.12k|# define JSONCONS_FALLTHROUGH [[fallthrough]] ------------------ 332| 20.9M| case 1: ------------------ | Branch (332:9): [True: 20.9M, False: 9.21k] ------------------ 333| 20.9M| if (static_cast(*first) >= 0x80 && static_cast(*first) < 0xC2) ------------------ | Branch (333:17): [True: 9.15k, False: 20.9M] | Branch (333:57): [True: 31, False: 9.11k] ------------------ 334| 31| return conv_errc::source_illegal; 335| 20.9M| break; 336| 20.9M| } 337| 20.9M| if (static_cast(*first) > 0xF4) ------------------ | Branch (337:13): [True: 1, False: 20.9M] ------------------ 338| 1| return conv_errc::source_illegal; 339| | 340| 20.9M| return conv_errc(); 341| 20.9M| } _ZN8jsoncons12from_integerIiNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS1_9enable_ifIXsr10ext_traits10is_integerIT_EE5valueEmE4typeES9_RT0_: 42| 10.7k|{ 43| 10.7k| using char_type = typename Result::value_type; 44| | 45| 10.7k| char_type buf[255]; 46| 10.7k| char_type *p = buf; 47| 10.7k| const char_type* last = buf+255; 48| | 49| 10.7k| bool is_negative = value < 0; 50| | 51| 10.7k| if (value < 0) ------------------ | Branch (51:9): [True: 8.85k, False: 1.87k] ------------------ 52| 8.85k| { 53| 8.85k| do 54| 35.2k| { 55| 35.2k| *p++ = static_cast(48 - (value % 10)); 56| 35.2k| } 57| 35.2k| while ((value /= 10) && (p < last)); ------------------ | Branch (57:16): [True: 26.3k, False: 8.85k] | Branch (57:33): [True: 26.3k, False: 0] ------------------ 58| 8.85k| } 59| 1.87k| else 60| 1.87k| { 61| | 62| 1.87k| do 63| 7.26k| { 64| 7.26k| *p++ = static_cast(48 + value % 10); 65| 7.26k| } 66| 7.26k| while ((value /= 10) && (p < last)); ------------------ | Branch (66:16): [True: 5.39k, False: 1.87k] | Branch (66:33): [True: 5.39k, False: 0] ------------------ 67| 1.87k| } 68| 10.7k| JSONCONS_ASSERT(p != last); ------------------ | | 45| 10.7k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 10.7k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 69| | 70| 10.7k| std::size_t count = (p - buf); 71| 10.7k| if (is_negative) ------------------ | Branch (71:9): [True: 8.85k, False: 1.87k] ------------------ 72| 8.85k| { 73| 8.85k| result.push_back('-'); 74| 8.85k| ++count; 75| 8.85k| } 76| 53.1k| while (--p >= buf) ------------------ | Branch (76:12): [True: 42.4k, False: 10.7k] ------------------ 77| 42.4k| { 78| 42.4k| result.push_back(*p); 79| 42.4k| } 80| | 81| 10.7k| return count; 82| 10.7k|} _ZN8jsoncons4bson3TP1C2Ev: 78| 12.6k| constexpr TP1() : low(0), high(0) {} _ZN8jsoncons4bson19decimal128_to_charsEPcS1_RKNS0_3TP1E: 335| 12.6k| { 336| 12.6k| const std::string bson_decimal128_inf = "Infinity"; 337| 12.6k| const std::string bson_decimal128_nan = "NaN"; 338| | 339| 12.6k| const uint32_t combination_mask = 0x1f; /* Extract least significant 5 bits */ 340| 12.6k| const uint32_t exponent_mask = 0x3fff; /* Extract least significant 14 bits */ 341| 12.6k| const uint32_t combination_infinity = 30; /* Value of combination field for Inf */ 342| 12.6k| const uint32_t combination_nan = 31; /* Value of combination field for NaN */ 343| 12.6k| const uint32_t exponent_bias = 6176; /* decimal128 exponent bias */ 344| | 345| 12.6k| char* str_out = first; /* output pointer in string */ 346| 12.6k| char significand_str[35]; /* decoded significand digits */ 347| | 348| | /* Note: bits in this routine are referred to starting at 0, */ 349| | /* from the sign bit, towards the coefficient. */ 350| 12.6k| uint32_t high; /* bits 0 - 31 */ 351| 12.6k| uint32_t midh; /* bits 32 - 63 */ 352| 12.6k| uint32_t midl; /* bits 64 - 95 */ 353| 12.6k| uint32_t low; /* bits 96 - 127 */ 354| 12.6k| uint32_t combination; /* bits 1 - 5 */ 355| 12.6k| uint32_t biased_exponent; /* decoded biased exponent (14 bits) */ 356| 12.6k| uint32_t significand_digits = 0; /* the number of significand digits */ 357| 12.6k| uint32_t significand[36] = {0}; /* the base-10 digits in the significand */ 358| 12.6k| uint32_t *significand_read = significand; /* read pointer into significand */ 359| 12.6k| int32_t exponent; /* unbiased exponent */ 360| 12.6k| int32_t scientific_exponent; /* the exponent if scientific notation is 361| | * used */ 362| 12.6k| bool is_zero = false; /* true if the number is zero */ 363| | 364| 12.6k| uint8_t significand_msb; /* the most signifcant significand bits (50-46) */ 365| 12.6k| bson_uint128_t 366| 12.6k| significand128; /* temporary storage for significand decoding */ 367| | 368| 12.6k| memset (significand_str, 0, sizeof (significand_str)); 369| | 370| 12.6k| if ((int64_t) dec.high < 0) { /* negative */ ------------------ | Branch (370:13): [True: 2.59k, False: 10.0k] ------------------ 371| 2.59k| *(str_out++) = '-'; 372| 2.59k| } 373| | 374| 12.6k| low = (uint32_t) dec.low, midl = (uint32_t) (dec.low >> 32), 375| 12.6k| midh = (uint32_t) dec.high, high = (uint32_t) (dec.high >> 32); 376| | 377| | /* Decode combination field and exponent */ 378| 12.6k| combination = (high >> 26) & combination_mask; 379| | 380| 12.6k| if (JSONCONS_UNLIKELY ((combination >> 3) == 3)) { ------------------ | | 78| 12.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2.68k, False: 9.95k] | | ------------------ ------------------ 381| | /* Check for 'special' values */ 382| 2.68k| if (combination == combination_infinity) { /* Infinity */ ------------------ | Branch (382:16): [True: 196, False: 2.48k] ------------------ 383| 196| if (last-str_out >= static_cast(bson_decimal128_inf.size())) ------------------ | Branch (383:20): [True: 196, False: 0] ------------------ 384| 196| { 385| 196| std::memcpy(str_out, bson_decimal128_inf.data(), bson_decimal128_inf.size()); 386| 196| str_out += bson_decimal128_inf.size(); 387| 196| } 388| 196| *str_out = 0; 389| | //strcpy_s (str_out, last-str_out, bson_decimal128_inf.c_str()); 390| 196| return decimal128_to_chars_result{str_out, std::errc{}}; 391| 2.48k| } else if (combination == combination_nan) { /* NaN */ ------------------ | Branch (391:23): [True: 765, False: 1.72k] ------------------ 392| | /* first, not str_out, to erase the sign */ 393| 765| str_out = first; 394| 765| if (last-str_out >= static_cast(bson_decimal128_nan.size())) ------------------ | Branch (394:20): [True: 765, False: 0] ------------------ 395| 765| { 396| 765| std::memcpy(str_out, bson_decimal128_nan.data(), bson_decimal128_nan.size()); 397| 765| str_out += bson_decimal128_nan.size(); 398| 765| } 399| 765| *str_out = 0; 400| | //strcpy_s (first, last-first, bson_decimal128_nan.c_str()); 401| | /* we don't care about the NaN payload. */ 402| 765| return decimal128_to_chars_result{str_out, std::errc{}}; 403| 1.72k| } else { 404| 1.72k| biased_exponent = (high >> 15) & exponent_mask; 405| 1.72k| significand_msb = 0x8 + ((high >> 14) & 0x1); 406| 1.72k| } 407| 9.95k| } else { 408| 9.95k| significand_msb = (high >> 14) & 0x7; 409| 9.95k| biased_exponent = (high >> 17) & exponent_mask; 410| 9.95k| } 411| | 412| 11.6k| exponent = biased_exponent - exponent_bias; 413| | /* Create string of significand digits */ 414| | 415| | /* Convert the 114-bit binary number represented by */ 416| | /* (high, midh, midl, low) to at most 34 decimal */ 417| | /* digits through modulo and division. */ 418| 11.6k| significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14); 419| 11.6k| significand128.parts[1] = midh; 420| 11.6k| significand128.parts[2] = midl; 421| 11.6k| significand128.parts[3] = low; 422| | 423| 11.6k| if (significand128.parts[0] == 0 && significand128.parts[1] == 0 && ------------------ | Branch (423:13): [True: 3.84k, False: 7.83k] | Branch (423:45): [True: 1.94k, False: 1.90k] ------------------ 424| 1.94k| significand128.parts[2] == 0 && significand128.parts[3] == 0) { ------------------ | Branch (424:13): [True: 1.55k, False: 388] | Branch (424:45): [True: 972, False: 584] ------------------ 425| 972| is_zero = true; 426| 10.7k| } else if (significand128.parts[0] >= (1 << 17)) { ------------------ | Branch (426:20): [True: 1.72k, False: 8.98k] ------------------ 427| | /* The significand is non-canonical or zero. 428| | * In order to preserve compatibility with the densely packed decimal 429| | * format, the maximum value for the significand of decimal128 is 430| | * 1e34 - 1. If the value is greater than 1e34 - 1, the IEEE 754 431| | * standard dictates that the significand is interpreted as zero. 432| | */ 433| 1.72k| is_zero = true; 434| 8.98k| } else { 435| 44.9k| for (int k = 3; k >= 0; k--) { ------------------ | Branch (435:28): [True: 35.9k, False: 8.98k] ------------------ 436| 35.9k| uint32_t least_digits = 0; 437| 35.9k| detail::bson_uint128_divide1B ( 438| 35.9k| significand128, &significand128, &least_digits); 439| | 440| | /* We now have the 9 least significant digits (in base 2). */ 441| | /* Convert and output to string. */ 442| 35.9k| if (!least_digits) { ------------------ | Branch (442:19): [True: 2.00k, False: 33.9k] ------------------ 443| 2.00k| continue; 444| 2.00k| } 445| | 446| 339k| for (int j = 8; j >= 0; j--) { ------------------ | Branch (446:31): [True: 305k, False: 33.9k] ------------------ 447| 305k| significand[k * 9 + j] = least_digits % 10; 448| 305k| least_digits /= 10; 449| 305k| } 450| 33.9k| } 451| 8.98k| } 452| | 453| | /* Output format options: */ 454| | /* Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd */ 455| | /* Regular - ddd.ddd */ 456| | 457| 11.6k| if (is_zero) { ------------------ | Branch (457:13): [True: 2.69k, False: 8.98k] ------------------ 458| 2.69k| significand_digits = 1; 459| 2.69k| *significand_read = 0; 460| 8.98k| } else { 461| 8.98k| significand_digits = 36; 462| 63.3k| while (!(*significand_read)) { ------------------ | Branch (462:19): [True: 54.3k, False: 8.98k] ------------------ 463| 54.3k| significand_digits--; 464| 54.3k| significand_read++; 465| 54.3k| } 466| 8.98k| } 467| | 468| 11.6k| scientific_exponent = significand_digits - 1 + exponent; 469| | 470| | /* The scientific exponent checks are dictated by the string conversion 471| | * specification and are somewhat arbitrary cutoffs. 472| | * 473| | * We must check exponent > 0, because if this is the case, the number 474| | * has trailing zeros. However, we *cannot* output these trailing zeros, 475| | * because doing so would change the precision of the value, and would 476| | * change stored data if the string converted number is round tripped. 477| | */ 478| 11.6k| if (scientific_exponent < -6 || exponent > 0) { ------------------ | Branch (478:13): [True: 8.85k, False: 2.83k] | Branch (478:41): [True: 1.87k, False: 959] ------------------ 479| | /* Scientific format */ 480| 10.7k| *(str_out++) = char(*(significand_read++)) + '0'; 481| 10.7k| significand_digits--; 482| | 483| 10.7k| if (significand_digits) { ------------------ | Branch (483:16): [True: 8.04k, False: 2.68k] ------------------ 484| 8.04k| *(str_out++) = '.'; 485| 8.04k| } 486| | 487| 244k| for (std::size_t i = 0; i < significand_digits && (str_out - first) < 36; i++) { ------------------ | Branch (487:36): [True: 233k, False: 10.7k] | Branch (487:62): [True: 233k, False: 2] ------------------ 488| 233k| *(str_out++) = char(*(significand_read++)) + '0'; 489| 233k| } 490| | /* Exponent */ 491| 10.7k| *(str_out++) = 'E'; 492| | 493| 10.7k| std::string s; 494| 10.7k| if (scientific_exponent >= 0) { ------------------ | Branch (494:16): [True: 1.87k, False: 8.85k] ------------------ 495| 1.87k| s.push_back('+'); 496| 1.87k| } 497| 10.7k| jsoncons::from_integer(scientific_exponent, s); 498| 10.7k| if (str_out + s.size() < last) ------------------ | Branch (498:16): [True: 10.0k, False: 690] ------------------ 499| 10.0k| { 500| 10.0k| std::memcpy(str_out, s.data(), s.size()); 501| 10.0k| } 502| 690| else 503| 690| { 504| 690| return decimal128_to_chars_result{str_out, std::errc::value_too_large}; 505| 690| } 506| 10.0k| str_out += s.size(); 507| 10.0k| } else { 508| | /* Regular format with no decimal place */ 509| 959| if (exponent >= 0) { ------------------ | Branch (509:16): [True: 340, False: 619] ------------------ 510| 9.15k| for (std::size_t i = 0; i < significand_digits && (str_out - first) < 36; i++) { ------------------ | Branch (510:39): [True: 8.81k, False: 340] | Branch (510:65): [True: 8.81k, False: 0] ------------------ 511| 8.81k| *(str_out++) = char(*(significand_read++)) + '0'; 512| 8.81k| } 513| 619| } else { 514| 619| int32_t radix_position = significand_digits + exponent; 515| | 516| 619| if (radix_position > 0) { /* non-zero digits before radix */ ------------------ | Branch (516:19): [True: 227, False: 392] ------------------ 517| 227| for (int32_t i = 0; 518| 1.67k| i < radix_position && (str_out < last); ------------------ | Branch (518:23): [True: 1.44k, False: 227] | Branch (518:45): [True: 1.44k, False: 0] ------------------ 519| 1.44k| i++) { 520| 1.44k| *(str_out++) = char(*(significand_read++)) + '0'; 521| 1.44k| } 522| 392| } else { /* leading zero before radix point */ 523| 392| *(str_out++) = '0'; 524| 392| } 525| | 526| 619| *(str_out++) = '.'; 527| 1.65k| while (radix_position++ < 0) { /* add leading zeros after radix */ ------------------ | Branch (527:22): [True: 1.03k, False: 619] ------------------ 528| 1.03k| *(str_out++) = '0'; 529| 1.03k| } 530| | 531| 619| for (std::size_t i = 0; 532| 17.9k| (i < significand_digits - (std::max) (radix_position - 1, 0)) && ------------------ | Branch (532:20): [True: 17.3k, False: 612] | Branch (532:20): [True: 17.3k, False: 619] ------------------ 533| 17.3k| (str_out < last); ------------------ | Branch (533:20): [True: 17.3k, False: 7] ------------------ 534| 17.3k| i++) { 535| 17.3k| *(str_out++) = char(*(significand_read++)) + '0'; 536| 17.3k| } 537| 619| } 538| 959| } 539| 10.9k| return decimal128_to_chars_result{str_out, std::errc{}}; 540| 11.6k| } _ZN8jsoncons4bson6detail21bson_uint128_divide1BENS0_14bson_uint128_tEPS2_Pj: 178| 35.9k| { 179| 35.9k| const uint32_t DIVISOR = 1000 * 1000 * 1000; 180| 35.9k| uint64_t _rem = 0; 181| 35.9k| int i = 0; 182| | 183| 35.9k| if (!value.parts[0] && !value.parts[1] && !value.parts[2] && ------------------ | Branch (183:17): [True: 29.8k, False: 6.11k] | Branch (183:36): [True: 21.2k, False: 8.56k] | Branch (183:55): [True: 11.5k, False: 9.73k] ------------------ 184| 11.5k| !value.parts[3]) { ------------------ | Branch (184:17): [True: 2.00k, False: 9.53k] ------------------ 185| 2.00k| *quotient = value; 186| 2.00k| *rem = 0; 187| 2.00k| return; 188| 2.00k| } 189| | 190| 169k| for (i = 0; i <= 3; i++) { ------------------ | Branch (190:25): [True: 135k, False: 33.9k] ------------------ 191| 135k| _rem <<= 32; /* Adjust remainder to match value of next dividend */ 192| 135k| _rem += value.parts[i]; /* Add the divided to _rem */ 193| 135k| value.parts[i] = (uint32_t) (_rem / DIVISOR); 194| 135k| _rem %= DIVISOR; /* Store the remainder */ 195| 135k| } 196| | 197| 33.9k| *quotient = value; 198| 33.9k| *rem = (uint32_t) _rem; 199| 33.9k| } _ZN8jsoncons4bson15make_error_codeENS0_9bson_errcE: 91| 4.44k|{ 92| 4.44k| return std::error_code(static_cast(result),bson_error_category()); 93| 4.44k|} _ZN8jsoncons4bson19bson_error_categoryEv: 84| 4.44k|{ 85| 4.44k| static bson_error_category_impl instance; 86| 4.44k| return instance; 87| 4.44k|} _ZNK8jsoncons4bson24bson_error_category_impl7messageEi: 45| 4.37k| { 46| 4.37k| switch (static_cast(ev)) 47| 4.37k| { 48| 1.47k| case bson_errc::unexpected_eof: ------------------ | Branch (48:13): [True: 1.47k, False: 2.90k] ------------------ 49| 1.47k| return "Unexpected end of file"; 50| 0| case bson_errc::source_error: ------------------ | Branch (50:13): [True: 0, False: 4.37k] ------------------ 51| 0| return "Source error"; 52| 149| case bson_errc::invalid_utf8_text_string: ------------------ | Branch (52:13): [True: 149, False: 4.22k] ------------------ 53| 149| return "Illegal UTF-8 encoding in text string"; 54| 2| case bson_errc::max_nesting_depth_exceeded: ------------------ | Branch (54:13): [True: 2, False: 4.37k] ------------------ 55| 2| return "Data item nesting exceeds limit in options"; 56| 35| case bson_errc::string_length_is_non_positive: ------------------ | Branch (56:13): [True: 35, False: 4.34k] ------------------ 57| 35| return "Request for the length of a string returned a non-positive result"; 58| 35| case bson_errc::length_is_negative: ------------------ | Branch (58:13): [True: 35, False: 4.34k] ------------------ 59| 35| return "Request for the length of a binary returned a negative result"; 60| 106| case bson_errc::unknown_type: ------------------ | Branch (60:13): [True: 106, False: 4.27k] ------------------ 61| 106| return "An unknown type was found in the stream"; 62| 0| case bson_errc::number_too_large: ------------------ | Branch (62:13): [True: 0, False: 4.37k] ------------------ 63| 0| return "Number too large"; 64| 0| case bson_errc::invalid_decimal128_string: ------------------ | Branch (64:13): [True: 0, False: 4.37k] ------------------ 65| 0| return "Invalid decimal128 string"; 66| 0| case bson_errc::datetime_too_large: ------------------ | Branch (66:13): [True: 0, False: 4.37k] ------------------ 67| 0| return "datetime too large"; 68| 0| case bson_errc::datetime_too_small: ------------------ | Branch (68:13): [True: 0, False: 4.37k] ------------------ 69| 0| return "datetime too small"; 70| 0| case bson_errc::expected_bson_document: ------------------ | Branch (70:13): [True: 0, False: 4.37k] ------------------ 71| 0| return "Expected BSON document"; 72| 0| case bson_errc::invalid_regex_string: ------------------ | Branch (72:13): [True: 0, False: 4.37k] ------------------ 73| 0| return "Invalid regex string"; 74| 2.57k| case bson_errc::size_mismatch: ------------------ | Branch (74:13): [True: 2.57k, False: 1.79k] ------------------ 75| 2.57k| return "Document or array size doesn't match bytes read"; 76| 0| default: ------------------ | Branch (76:13): [True: 0, False: 4.37k] ------------------ 77| 0| return "Unknown BSON parser error"; 78| 4.37k| } 79| 4.37k| } _ZN8jsoncons4bson5oid_tC2EPh: 53| 4.30k| { 54| 4.30k| std::memcpy(bytes_.data(),data,12); 55| 4.30k| } _ZN8jsoncons4bson9to_stringINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRKNS0_5oid_tERT_: 236| 4.30k| { 237| 4.30k| s.resize(24); 238| 4.30k| detail::init_hex_char_pairs(oid, reinterpret_cast(&s[0])); 239| 4.30k| } _ZN8jsoncons4bson6detail19init_hex_char_pairsERKNS0_5oid_tEPt: 213| 4.30k| { 214| 4.30k| const uint8_t* bytes = oid.data(); 215| 4.30k| const uint16_t* gHexCharPairs = get_hex_char_pairs(std::integral_constant()); 216| | 217| 4.30k| data[0] = gHexCharPairs[bytes[0]]; 218| 4.30k| data[1] = gHexCharPairs[bytes[1]]; 219| 4.30k| data[2] = gHexCharPairs[bytes[2]]; 220| 4.30k| data[3] = gHexCharPairs[bytes[3]]; 221| 4.30k| data[4] = gHexCharPairs[bytes[4]]; 222| 4.30k| data[5] = gHexCharPairs[bytes[5]]; 223| 4.30k| data[6] = gHexCharPairs[bytes[6]]; 224| 4.30k| data[7] = gHexCharPairs[bytes[7]]; 225| 4.30k| data[8] = gHexCharPairs[bytes[8]]; 226| 4.30k| data[9] = gHexCharPairs[bytes[9]]; 227| 4.30k| data[10] = gHexCharPairs[bytes[10]]; 228| 4.30k| data[11] = gHexCharPairs[bytes[11]]; 229| 4.30k| } _ZNK8jsoncons4bson5oid_t4dataEv: 67| 4.30k| { 68| 4.30k| return bytes_.data(); 69| 4.30k| } _ZN8jsoncons4bson6detail18get_hex_char_pairsENSt3__117integral_constantIbLb0EEE: 181| 4.30k| { 182| 4.30k| static const uint16_t hex_char_pairs[] = { 183| 4.30k| 12336, 12592, 12848, 13104, 13360, 13616, 13872, 14128, 14384, 14640, 24880, 184| 4.30k| 25136, 25392, 25648, 25904, 26160, 12337, 12593, 12849, 13105, 13361, 13617, 185| 4.30k| 13873, 14129, 14385, 14641, 24881, 25137, 25393, 25649, 25905, 26161, 12338, 186| 4.30k| 12594, 12850, 13106, 13362, 13618, 13874, 14130, 14386, 14642, 24882, 25138, 187| 4.30k| 25394, 25650, 25906, 26162, 12339, 12595, 12851, 13107, 13363, 13619, 13875, 188| 4.30k| 14131, 14387, 14643, 24883, 25139, 25395, 25651, 25907, 26163, 12340, 12596, 189| 4.30k| 12852, 13108, 13364, 13620, 13876, 14132, 14388, 14644, 24884, 25140, 25396, 190| 4.30k| 25652, 25908, 26164, 12341, 12597, 12853, 13109, 13365, 13621, 13877, 14133, 191| 4.30k| 14389, 14645, 24885, 25141, 25397, 25653, 25909, 26165, 12342, 12598, 12854, 192| 4.30k| 13110, 13366, 13622, 13878, 14134, 14390, 14646, 24886, 25142, 25398, 25654, 193| 4.30k| 25910, 26166, 12343, 12599, 12855, 13111, 13367, 13623, 13879, 14135, 14391, 194| 4.30k| 14647, 24887, 25143, 25399, 25655, 25911, 26167, 12344, 12600, 12856, 13112, 195| 4.30k| 13368, 13624, 13880, 14136, 14392, 14648, 24888, 25144, 25400, 25656, 25912, 196| 4.30k| 26168, 12345, 12601, 12857, 13113, 13369, 13625, 13881, 14137, 14393, 14649, 197| 4.30k| 24889, 25145, 25401, 25657, 25913, 26169, 12385, 12641, 12897, 13153, 13409, 198| 4.30k| 13665, 13921, 14177, 14433, 14689, 24929, 25185, 25441, 25697, 25953, 26209, 199| 4.30k| 12386, 12642, 12898, 13154, 13410, 13666, 13922, 14178, 14434, 14690, 24930, 200| 4.30k| 25186, 25442, 25698, 25954, 26210, 12387, 12643, 12899, 13155, 13411, 13667, 201| 4.30k| 13923, 14179, 14435, 14691, 24931, 25187, 25443, 25699, 25955, 26211, 12388, 202| 4.30k| 12644, 12900, 13156, 13412, 13668, 13924, 14180, 14436, 14692, 24932, 25188, 203| 4.30k| 25444, 25700, 25956, 26212, 12389, 12645, 12901, 13157, 13413, 13669, 13925, 204| 4.30k| 14181, 14437, 14693, 24933, 25189, 25445, 25701, 25957, 26213, 12390, 12646, 205| 4.30k| 12902, 13158, 13414, 13670, 13926, 14182, 14438, 14694, 24934, 25190, 25446, 206| 4.30k| 25702, 25958, 26214}; 207| | 208| 4.30k| return hex_char_pairs; 209| 4.30k| } _ZNK8jsoncons4bson19bson_options_common17max_nesting_depthEv: 31| 4.39k| { 32| 4.39k| return max_nesting_depth_; 33| 4.39k| } _ZN8jsoncons4bson19bson_decode_optionsC1Ev: 40| 4.39k| bson_decode_options() = default; _ZN8jsoncons4bson19bson_options_commonC2Ev: 23| 4.39k| bson_options_common() = default; _ZN8jsoncons4bson19bson_options_commonD2Ev: 25| 4.39k| virtual ~bson_options_common() = default; _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_13basic_istreamIcNS3_11char_traitsIcEEEEEEOT_RKNS0_19bson_decode_optionsERKS7_: 85| 4.39k| : source_(std::forward(source)), 86| 4.39k| max_nesting_depth_(options.max_nesting_depth()), 87| 4.39k| bytes_buffer_(temp_alloc), 88| 4.39k| name_buffer_(temp_alloc), 89| 4.39k| text_buffer_(temp_alloc), 90| 4.39k| state_stack_(temp_alloc) 91| 4.39k| { 92| 4.39k| state_stack_.emplace_back(parse_mode::root,0,0); 93| 4.39k| } _ZN8jsoncons4bson11parse_stateC2ENS0_10parse_modeEmmh: 48| 86.5k| : mode(mode_), length(length_), pos(pos_), type(type_) 49| 86.5k| { 50| 86.5k| } _ZNK8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4lineEv: 149| 4.37k| { 150| 4.37k| return 0; 151| 4.37k| } _ZNK8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE6columnEv: 154| 4.37k| { 155| 4.37k| return source_.position(); 156| 4.37k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5resetEv: 101| 4.39k| { 102| 4.39k| more_ = true; 103| 4.39k| done_ = false; 104| 4.39k| bytes_buffer_.clear(); 105| 4.39k| name_buffer_.clear(); 106| 4.39k| text_buffer_.clear(); 107| 4.39k| state_stack_.clear(); 108| 4.39k| state_stack_.emplace_back(parse_mode::root,0,0); 109| 4.39k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5parseERNS_18basic_json_visitorIcEERNS3_10error_codeE: 169| 4.39k| { 170| 4.39k| if (JSONCONS_UNLIKELY(source_.is_error())) ------------------ | | 78| 4.39k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 4.39k] | | ------------------ ------------------ 171| 0| { 172| 0| ec = bson_errc::source_error; 173| 0| more_ = false; 174| 0| return; 175| 0| } 176| | 177| 31.1M| while (!done_ && more_) ------------------ | Branch (177:16): [True: 31.1M, False: 16] | Branch (177:26): [True: 31.1M, False: 3.62k] ------------------ 178| 31.1M| { 179| 31.1M| switch (state_stack_.back().mode) ------------------ | Branch (179:21): [True: 31.1M, False: 0] ------------------ 180| 31.1M| { 181| 4.39k| case parse_mode::root: ------------------ | Branch (181:17): [True: 4.39k, False: 31.1M] ------------------ 182| 4.39k| state_stack_.back().mode = parse_mode::accept; 183| 4.39k| begin_document(visitor, ec); 184| 4.39k| break; 185| 10.0M| case parse_mode::document: ------------------ | Branch (185:17): [True: 10.0M, False: 21.1M] ------------------ 186| 10.0M| { 187| 10.0M| uint8_t type; 188| 10.0M| std::size_t n = source_.read(&type, 1); 189| 10.0M| state_stack_.back().pos += n; 190| 10.0M| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 10.0M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 645, False: 10.0M] | | ------------------ ------------------ 191| 645| { 192| 645| ec = bson_errc::unexpected_eof; 193| 645| more_ = false; 194| 645| return; 195| 645| } 196| 10.0M| if (type != 0x00) ------------------ | Branch (196:25): [True: 9.98M, False: 24.8k] ------------------ 197| 9.98M| { 198| 9.98M| read_e_name(visitor,jsoncons::bson::bson_container_type::document,ec); 199| 9.98M| state_stack_.back().mode = parse_mode::value; 200| 9.98M| state_stack_.back().type = type; 201| 9.98M| } 202| 24.8k| else 203| 24.8k| { 204| 24.8k| end_document(visitor,ec); 205| 24.8k| } 206| 10.0M| break; 207| 10.0M| } 208| 11.1M| case parse_mode::array: ------------------ | Branch (208:17): [True: 11.1M, False: 19.9M] ------------------ 209| 11.1M| { 210| 11.1M| uint8_t type; 211| 11.1M| std::size_t n = source_.read(&type, 1); 212| 11.1M| state_stack_.back().pos += n; 213| 11.1M| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 11.1M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 103, False: 11.1M] | | ------------------ ------------------ 214| 103| { 215| 103| ec = bson_errc::unexpected_eof; 216| 103| more_ = false; 217| 103| return; 218| 103| } 219| 11.1M| if (type != 0x00) ------------------ | Branch (219:25): [True: 11.1M, False: 18.1k] ------------------ 220| 11.1M| { 221| 11.1M| read_e_name(visitor,jsoncons::bson::bson_container_type::array,ec); 222| 11.1M| read_value(visitor, type, ec); 223| 11.1M| } 224| 18.1k| else 225| 18.1k| { 226| 18.1k| end_array(visitor,ec); 227| 18.1k| } 228| 11.1M| break; 229| 11.1M| } 230| 9.98M| case parse_mode::value: ------------------ | Branch (230:17): [True: 9.98M, False: 21.2M] ------------------ 231| 9.98M| state_stack_.back().mode = parse_mode::document; 232| 9.98M| read_value(visitor,state_stack_.back().type,ec); 233| 9.98M| break; 234| 16| case parse_mode::accept: ------------------ | Branch (234:17): [True: 16, False: 31.1M] ------------------ 235| 16| { 236| 16| JSONCONS_ASSERT(state_stack_.size() == 1); ------------------ | | 45| 16|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 16] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 237| 16| state_stack_.clear(); 238| 16| more_ = false; 239| 16| done_ = true; 240| 16| visitor.flush(); 241| 16| break; 242| 16| } 243| 31.1M| } 244| 31.1M| } 245| 4.39k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE14begin_documentERNS_18basic_json_visitorIcEERNS3_10error_codeE: 250| 37.0k| { 251| 37.0k| if (JSONCONS_UNLIKELY(static_cast(state_stack_.size()) > max_nesting_depth_)) ------------------ | | 78| 37.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 37.0k] | | ------------------ ------------------ 252| 1| { 253| 1| ec = bson_errc::max_nesting_depth_exceeded; 254| 1| more_ = false; 255| 1| return; 256| 1| } 257| | 258| 37.0k| uint8_t buf[sizeof(int32_t)]; 259| 37.0k| std::size_t n = source_.read(buf, sizeof(int32_t)); 260| 37.0k| if (JSONCONS_UNLIKELY(n != sizeof(int32_t))) ------------------ | | 78| 37.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 34, False: 36.9k] | | ------------------ ------------------ 261| 34| { 262| 34| ec = bson_errc::unexpected_eof; 263| 34| more_ = false; 264| 34| return; 265| 34| } 266| | 267| 36.9k| auto length = binary::little_to_native(buf, sizeof(buf)); 268| | 269| 36.9k| visitor.begin_object(semantic_tag::none, *this, ec); 270| 36.9k| more_ = !cursor_mode_; 271| 36.9k| state_stack_.emplace_back(parse_mode::document,length,n); 272| 36.9k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_e_nameERNS_18basic_json_visitorIcEENS0_19bson_container_typeERNS3_10error_codeE: 344| 21.1M| { 345| 21.1M| name_buffer_.clear(); 346| 21.1M| read_cstring(name_buffer_, ec); 347| 21.1M| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 21.1M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 152, False: 21.1M] | | ------------------ ------------------ 348| 152| { 349| 152| return; 350| 152| } 351| 21.1M| if (type == jsoncons::bson::bson_container_type::document) ------------------ | Branch (351:13): [True: 9.98M, False: 11.1M] ------------------ 352| 9.98M| { 353| 9.98M| auto result = unicode_traits::validate(name_buffer_.data(),name_buffer_.size()); 354| 9.98M| if (JSONCONS_UNLIKELY(result.ec != unicode_traits::conv_errc())) ------------------ | | 78| 9.98M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 83, False: 9.98M] | | ------------------ ------------------ 355| 83| { 356| 83| ec = bson_errc::invalid_utf8_text_string; 357| 83| more_ = false; 358| 83| return; 359| 83| } 360| 9.98M| visitor.key(jsoncons::basic_string_view(name_buffer_.data(),name_buffer_.length()), *this, ec); 361| 9.98M| more_ = !cursor_mode_; 362| 9.98M| } 363| 21.1M| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12read_cstringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE: 647| 21.1M| { 648| 21.1M| uint8_t c = 0xff; 649| 51.9M| while (true) ------------------ | Branch (649:16): [True: 51.9M, Folded] ------------------ 650| 51.9M| { 651| 51.9M| std::size_t n = source_.read(&c, 1); 652| 51.9M| state_stack_.back().pos += n; 653| 51.9M| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 51.9M|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 204, False: 51.9M] | | ------------------ ------------------ 654| 204| { 655| 204| ec = bson_errc::unexpected_eof; 656| 204| more_ = false; 657| 204| return; 658| 204| } 659| 51.9M| if (c == 0) ------------------ | Branch (659:17): [True: 21.1M, False: 30.7M] ------------------ 660| 21.1M| { 661| 21.1M| break; 662| 21.1M| } 663| 30.7M| buffer.push_back(c); 664| 30.7M| } 665| 21.1M| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE12end_documentERNS_18basic_json_visitorIcEERNS3_10error_codeE: 275| 24.8k| { 276| 24.8k| JSONCONS_ASSERT(state_stack_.size() >= 2); ------------------ | | 45| 24.8k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 24.8k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 277| | 278| 24.8k| visitor.end_object(*this,ec); 279| 24.8k| more_ = !cursor_mode_; 280| 24.8k| if (level() == mark_level_) ------------------ | Branch (280:13): [True: 0, False: 24.8k] ------------------ 281| 0| { 282| 0| more_ = false; 283| 0| } 284| 24.8k| if (JSONCONS_UNLIKELY(state_stack_.back().pos != state_stack_.back().length)) ------------------ | | 78| 24.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2.23k, False: 22.5k] | | ------------------ ------------------ 285| 2.23k| { 286| 2.23k| ec = bson_errc::size_mismatch; 287| 2.23k| more_ = false; 288| 2.23k| return; 289| 2.23k| } 290| 22.5k| std::size_t pos = state_stack_.back().pos; 291| 22.5k| state_stack_.pop_back(); 292| 22.5k| state_stack_.back().pos += pos; 293| 22.5k| } _ZNK8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE5levelEv: 124| 42.9k| { 125| 42.9k| return static_cast(state_stack_.size()); 126| 42.9k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE10read_valueERNS_18basic_json_visitorIcEEhRNS3_10error_codeE: 366| 21.1M| { 367| 21.1M| switch (type) 368| 21.1M| { 369| 13.4k| case jsoncons::bson::bson_type::double_type: ------------------ | Branch (369:13): [True: 13.4k, False: 21.1M] ------------------ 370| 13.4k| { 371| 13.4k| uint8_t buf[sizeof(double)]; 372| 13.4k| std::size_t n = source_.read(buf, sizeof(double)); 373| 13.4k| state_stack_.back().pos += n; 374| 13.4k| if (JSONCONS_UNLIKELY(n != sizeof(double))) ------------------ | | 78| 13.4k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 7, False: 13.3k] | | ------------------ ------------------ 375| 7| { 376| 7| ec = bson_errc::unexpected_eof; 377| 7| more_ = false; 378| 7| return; 379| 7| } 380| 13.3k| double res = binary::little_to_native(buf, sizeof(buf)); 381| 13.3k| visitor.double_value(res, semantic_tag::none, *this, ec); 382| 13.3k| more_ = !cursor_mode_; 383| 13.3k| break; 384| 13.4k| } 385| 303| case jsoncons::bson::bson_type::symbol_type: ------------------ | Branch (385:13): [True: 303, False: 21.1M] ------------------ 386| 824| case jsoncons::bson::bson_type::min_key_type: ------------------ | Branch (386:13): [True: 521, False: 21.1M] ------------------ 387| 1.04k| case jsoncons::bson::bson_type::max_key_type: ------------------ | Branch (387:13): [True: 222, False: 21.1M] ------------------ 388| 1.86k| case jsoncons::bson::bson_type::string_type: ------------------ | Branch (388:13): [True: 816, False: 21.1M] ------------------ 389| 1.86k| { 390| 1.86k| text_buffer_.clear(); 391| 1.86k| read_string(text_buffer_, ec); 392| 1.86k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 1.86k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 202, False: 1.66k] | | ------------------ ------------------ 393| 202| { 394| 202| return; 395| 202| } 396| 1.66k| auto result = unicode_traits::validate(text_buffer_.data(), text_buffer_.size()); 397| 1.66k| if (JSONCONS_UNLIKELY(result.ec != unicode_traits::conv_errc())) ------------------ | | 78| 1.66k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 35, False: 1.62k] | | ------------------ ------------------ 398| 35| { 399| 35| ec = bson_errc::invalid_utf8_text_string; 400| 35| more_ = false; 401| 35| return; 402| 35| } 403| 1.62k| visitor.string_value(text_buffer_, semantic_tag::none, *this, ec); 404| 1.62k| more_ = !cursor_mode_; 405| 1.62k| break; 406| 1.66k| } 407| 610| case jsoncons::bson::bson_type::javascript_type: ------------------ | Branch (407:13): [True: 610, False: 21.1M] ------------------ 408| 610| { 409| 610| text_buffer_.clear(); 410| 610| read_string(text_buffer_, ec); 411| 610| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 610|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 44, False: 566] | | ------------------ ------------------ 412| 44| { 413| 44| return; 414| 44| } 415| 566| auto result = unicode_traits::validate(text_buffer_.data(), text_buffer_.size()); 416| 566| if (JSONCONS_UNLIKELY(result.ec != unicode_traits::conv_errc())) ------------------ | | 78| 566|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 31, False: 535] | | ------------------ ------------------ 417| 31| { 418| 31| ec = bson_errc::invalid_utf8_text_string; 419| 31| more_ = false; 420| 31| return; 421| 31| } 422| 535| visitor.string_value(text_buffer_, semantic_tag::code, *this, ec); 423| 535| more_ = !cursor_mode_; 424| 535| break; 425| 566| } 426| 18.0k| case jsoncons::bson::bson_type::regex_type: ------------------ | Branch (426:13): [True: 18.0k, False: 21.1M] ------------------ 427| 18.0k| { 428| 18.0k| text_buffer_.clear(); 429| 18.0k| text_buffer_.push_back('/'); 430| 18.0k| read_cstring(text_buffer_, ec); 431| 18.0k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 18.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 33, False: 17.9k] | | ------------------ ------------------ 432| 33| { 433| 33| return; 434| 33| } 435| 17.9k| text_buffer_.push_back('/'); 436| 17.9k| read_cstring(text_buffer_, ec); 437| 17.9k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 17.9k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 19, False: 17.9k] | | ------------------ ------------------ 438| 19| { 439| 19| return; 440| 19| } 441| 17.9k| visitor.string_value(text_buffer_, semantic_tag::regex, *this, ec); 442| 17.9k| more_ = !cursor_mode_; 443| 17.9k| break; 444| 17.9k| } 445| 32.6k| case jsoncons::bson::bson_type::document_type: ------------------ | Branch (445:13): [True: 32.6k, False: 21.1M] ------------------ 446| 32.6k| { 447| 32.6k| begin_document(visitor,ec); 448| 32.6k| break; 449| 17.9k| } 450| | 451| 40.8k| case jsoncons::bson::bson_type::array_type: ------------------ | Branch (451:13): [True: 40.8k, False: 21.1M] ------------------ 452| 40.8k| { 453| 40.8k| begin_array(visitor,ec); 454| 40.8k| break; 455| 17.9k| } 456| 5.90k| case jsoncons::bson::bson_type::undefined_type: ------------------ | Branch (456:13): [True: 5.90k, False: 21.1M] ------------------ 457| 5.90k| { 458| 5.90k| visitor.null_value(semantic_tag::undefined, *this, ec); 459| 5.90k| more_ = !cursor_mode_; 460| 5.90k| break; 461| 17.9k| } 462| 20.7M| case jsoncons::bson::bson_type::null_type: ------------------ | Branch (462:13): [True: 20.7M, False: 369k] ------------------ 463| 20.7M| { 464| 20.7M| visitor.null_value(semantic_tag::none, *this, ec); 465| 20.7M| more_ = !cursor_mode_; 466| 20.7M| break; 467| 17.9k| } 468| 56.9k| case jsoncons::bson::bson_type::bool_type: ------------------ | Branch (468:13): [True: 56.9k, False: 21.1M] ------------------ 469| 56.9k| { 470| 56.9k| uint8_t c; 471| 56.9k| std::size_t n = source_.read(&c, 1); 472| 56.9k| state_stack_.back().pos += n; 473| 56.9k| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 56.9k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 2, False: 56.9k] | | ------------------ ------------------ 474| 2| { 475| 2| ec = bson_errc::unexpected_eof; 476| 2| more_ = false; 477| 2| return; 478| 2| } 479| 56.9k| visitor.bool_value(c != 0, semantic_tag::none, *this, ec); 480| 56.9k| more_ = !cursor_mode_; 481| 56.9k| break; 482| 56.9k| } 483| 137k| case jsoncons::bson::bson_type::int32_type: ------------------ | Branch (483:13): [True: 137k, False: 21.0M] ------------------ 484| 137k| { 485| 137k| uint8_t buf[sizeof(int32_t)]; 486| 137k| std::size_t n = source_.read(buf, sizeof(int32_t)); 487| 137k| state_stack_.back().pos += n; 488| 137k| if (JSONCONS_UNLIKELY(n != sizeof(int32_t))) ------------------ | | 78| 137k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 9, False: 137k] | | ------------------ ------------------ 489| 9| { 490| 9| ec = bson_errc::unexpected_eof; 491| 9| more_ = false; 492| 9| return; 493| 9| } 494| 137k| auto val = binary::little_to_native(buf, sizeof(buf)); 495| 137k| visitor.int64_value(val, semantic_tag::none, *this, ec); 496| 137k| more_ = !cursor_mode_; 497| 137k| break; 498| 137k| } 499| | 500| 15.5k| case jsoncons::bson::bson_type::timestamp_type: ------------------ | Branch (500:13): [True: 15.5k, False: 21.1M] ------------------ 501| 15.5k| { 502| 15.5k| uint8_t buf[sizeof(uint64_t)]; 503| 15.5k| std::size_t n = source_.read(buf, sizeof(uint64_t)); 504| 15.5k| state_stack_.back().pos += n; 505| 15.5k| if (JSONCONS_UNLIKELY(n != sizeof(uint64_t))) ------------------ | | 78| 15.5k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 8, False: 15.5k] | | ------------------ ------------------ 506| 8| { 507| 8| ec = bson_errc::unexpected_eof; 508| 8| more_ = false; 509| 8| return; 510| 8| } 511| 15.5k| auto val = binary::little_to_native(buf, sizeof(buf)); 512| 15.5k| visitor.uint64_value(val, semantic_tag::none, *this, ec); 513| 15.5k| more_ = !cursor_mode_; 514| 15.5k| break; 515| 15.5k| } 516| | 517| 6.72k| case jsoncons::bson::bson_type::int64_type: ------------------ | Branch (517:13): [True: 6.72k, False: 21.1M] ------------------ 518| 6.72k| { 519| 6.72k| uint8_t buf[sizeof(int64_t)]; 520| 6.72k| std::size_t n = source_.read(buf, sizeof(int64_t)); 521| 6.72k| state_stack_.back().pos += n; 522| 6.72k| if (JSONCONS_UNLIKELY(n != sizeof(int64_t))) ------------------ | | 78| 6.72k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 9, False: 6.72k] | | ------------------ ------------------ 523| 9| { 524| 9| ec = bson_errc::unexpected_eof; 525| 9| more_ = false; 526| 9| return; 527| 9| } 528| 6.72k| auto val = binary::little_to_native(buf, sizeof(buf)); 529| 6.72k| visitor.int64_value(val, semantic_tag::none, *this, ec); 530| 6.72k| more_ = !cursor_mode_; 531| 6.72k| break; 532| 6.72k| } 533| | 534| 6.89k| case jsoncons::bson::bson_type::datetime_type: ------------------ | Branch (534:13): [True: 6.89k, False: 21.1M] ------------------ 535| 6.89k| { 536| 6.89k| uint8_t buf[sizeof(int64_t)]; 537| 6.89k| std::size_t n = source_.read(buf, sizeof(int64_t)); 538| 6.89k| state_stack_.back().pos += n; 539| 6.89k| if (JSONCONS_UNLIKELY(n != sizeof(int64_t))) ------------------ | | 78| 6.89k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 6, False: 6.88k] | | ------------------ ------------------ 540| 6| { 541| 6| ec = bson_errc::unexpected_eof; 542| 6| more_ = false; 543| 6| return; 544| 6| } 545| 6.88k| auto val = binary::little_to_native(buf, sizeof(buf)); 546| 6.88k| visitor.int64_value(val, semantic_tag::epoch_milli, *this, ec); 547| 6.88k| more_ = !cursor_mode_; 548| 6.88k| break; 549| 6.89k| } 550| 16.1k| case jsoncons::bson::bson_type::binary_type: ------------------ | Branch (550:13): [True: 16.1k, False: 21.1M] ------------------ 551| 16.1k| { 552| 16.1k| uint8_t buf[sizeof(int32_t)]; 553| 16.1k| std::size_t n = source_.read(buf, sizeof(int32_t)); 554| 16.1k| state_stack_.back().pos += n; 555| 16.1k| if (JSONCONS_UNLIKELY(n != sizeof(int32_t))) ------------------ | | 78| 16.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 12, False: 16.1k] | | ------------------ ------------------ 556| 12| { 557| 12| ec = bson_errc::unexpected_eof; 558| 12| more_ = false; 559| 12| return; 560| 12| } 561| 16.1k| const auto len = binary::little_to_native(buf, sizeof(buf)); 562| 16.1k| if (JSONCONS_UNLIKELY(len < 0)) ------------------ | | 78| 16.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 35, False: 16.0k] | | ------------------ ------------------ 563| 35| { 564| 35| ec = bson_errc::length_is_negative; 565| 35| more_ = false; 566| 35| return; 567| 35| } 568| 16.0k| uint8_t subtype; 569| 16.0k| n = source_.read(&subtype, 1); 570| 16.0k| state_stack_.back().pos += n; 571| 16.0k| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 16.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 9, False: 16.0k] | | ------------------ ------------------ 572| 9| { 573| 9| ec = bson_errc::unexpected_eof; 574| 9| more_ = false; 575| 9| return; 576| 9| } 577| | 578| 16.0k| bytes_buffer_.clear(); 579| 16.0k| n = source_reader::read(source_, bytes_buffer_, len); 580| 16.0k| state_stack_.back().pos += n; 581| 16.0k| if (JSONCONS_UNLIKELY(n != static_cast(len))) ------------------ | | 78| 16.0k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 226, False: 15.8k] | | ------------------ ------------------ 582| 226| { 583| 226| ec = bson_errc::unexpected_eof; 584| 226| more_ = false; 585| 226| return; 586| 226| } 587| | 588| 15.8k| visitor.byte_string_value(bytes_buffer_, 589| 15.8k| subtype, 590| 15.8k| *this, 591| 15.8k| ec); 592| 15.8k| more_ = !cursor_mode_; 593| 15.8k| break; 594| 16.0k| } 595| 12.6k| case jsoncons::bson::bson_type::decimal128_type: ------------------ | Branch (595:13): [True: 12.6k, False: 21.1M] ------------------ 596| 12.6k| { 597| 12.6k| uint8_t buf[sizeof(uint64_t)*2]; 598| 12.6k| std::size_t n = source_.read(buf, sizeof(buf)); 599| 12.6k| state_stack_.back().pos += n; 600| 12.6k| if (JSONCONS_UNLIKELY(n != sizeof(buf))) ------------------ | | 78| 12.6k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 20, False: 12.6k] | | ------------------ ------------------ 601| 20| { 602| 20| ec = bson_errc::unexpected_eof; 603| 20| more_ = false; 604| 20| return; 605| 20| } 606| | 607| 12.6k| decimal128_t dec; 608| 12.6k| dec.low = binary::little_to_native(buf, sizeof(uint64_t)); 609| 12.6k| dec.high = binary::little_to_native(buf+sizeof(uint64_t), sizeof(uint64_t)); 610| | 611| 12.6k| text_buffer_.clear(); 612| 12.6k| text_buffer_.resize(bson::decimal128_limits::buf_size); 613| 12.6k| auto r = bson::decimal128_to_chars(&text_buffer_[0], &text_buffer_[0]+text_buffer_.size(), dec); 614| 12.6k| visitor.string_value(string_view(text_buffer_.data(),static_cast(r.ptr-text_buffer_.data())), semantic_tag::float128, *this, ec); 615| 12.6k| more_ = !cursor_mode_; 616| 12.6k| break; 617| 12.6k| } 618| 4.31k| case jsoncons::bson::bson_type::object_id_type: ------------------ | Branch (618:13): [True: 4.31k, False: 21.1M] ------------------ 619| 4.31k| { 620| 4.31k| uint8_t buf[12]; 621| 4.31k| std::size_t n = source_.read(buf, sizeof(buf)); 622| 4.31k| state_stack_.back().pos += n; 623| 4.31k| if (JSONCONS_UNLIKELY(n != sizeof(buf))) ------------------ | | 78| 4.31k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 6, False: 4.30k] | | ------------------ ------------------ 624| 6| { 625| 6| ec = bson_errc::unexpected_eof; 626| 6| more_ = false; 627| 6| return; 628| 6| } 629| | 630| 4.30k| oid_t oid(buf); 631| 4.30k| to_string(oid, text_buffer_); 632| | 633| 4.30k| visitor.string_value(text_buffer_, semantic_tag::id, *this, ec); 634| 4.30k| more_ = !cursor_mode_; 635| 4.30k| break; 636| 4.31k| } 637| 106| default: ------------------ | Branch (637:13): [True: 106, False: 21.1M] ------------------ 638| 106| { 639| 106| ec = bson_errc::unknown_type; 640| 106| more_ = false; 641| 106| return; 642| 4.31k| } 643| 21.1M| } 644| 21.1M| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11read_stringERNS3_12basic_stringIcNS3_11char_traitsIcEES7_EERNS3_10error_codeE: 668| 2.47k| { 669| 2.47k| uint8_t buf[sizeof(int32_t)]; 670| 2.47k| std::size_t n = source_.read(buf, sizeof(int32_t)); 671| 2.47k| state_stack_.back().pos += n; 672| 2.47k| if (JSONCONS_UNLIKELY(n != sizeof(int32_t))) ------------------ | | 78| 2.47k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 57, False: 2.41k] | | ------------------ ------------------ 673| 57| { 674| 57| ec = bson_errc::unexpected_eof; 675| 57| more_ = false; 676| 57| return; 677| 57| } 678| 2.41k| auto len = binary::little_to_native(buf, sizeof(buf)); 679| 2.41k| if (JSONCONS_UNLIKELY(len < 1)) ------------------ | | 78| 2.41k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 35, False: 2.38k] | | ------------------ ------------------ 680| 35| { 681| 35| ec = bson_errc::string_length_is_non_positive; 682| 35| more_ = false; 683| 35| return; 684| 35| } 685| | 686| 2.38k| std::size_t size = static_cast(len) - static_cast(1); 687| 2.38k| n = source_reader::read(source_, buffer, size); 688| 2.38k| state_stack_.back().pos += n; 689| | 690| 2.38k| if (JSONCONS_UNLIKELY(n != size)) ------------------ | | 78| 2.38k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 134, False: 2.24k] | | ------------------ ------------------ 691| 134| { 692| 134| ec = bson_errc::unexpected_eof; 693| 134| more_ = false; 694| 134| return; 695| 134| } 696| 2.24k| uint8_t c; 697| 2.24k| n = source_.read(&c, 1); 698| 2.24k| state_stack_.back().pos += n; 699| 2.24k| if (JSONCONS_UNLIKELY(n != 1)) ------------------ | | 78| 2.24k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 20, False: 2.22k] | | ------------------ ------------------ 700| 20| { 701| 20| ec = bson_errc::unexpected_eof; 702| 20| more_ = false; 703| 20| return; 704| 20| } 705| 2.24k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE11begin_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE: 296| 40.8k| { 297| 40.8k| if (JSONCONS_UNLIKELY(static_cast(state_stack_.size()) > max_nesting_depth_)) ------------------ | | 78| 40.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 1, False: 40.8k] | | ------------------ ------------------ 298| 1| { 299| 1| ec = bson_errc::max_nesting_depth_exceeded; 300| 1| more_ = false; 301| 1| return; 302| 1| } 303| 40.8k| uint8_t buf[sizeof(int32_t)]; 304| 40.8k| std::size_t n = source_.read(buf, sizeof(int32_t)); 305| 40.8k| if (JSONCONS_UNLIKELY(n != sizeof(int32_t))) ------------------ | | 78| 40.8k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 24, False: 40.7k] | | ------------------ ------------------ 306| 24| { 307| 24| ec = bson_errc::unexpected_eof; 308| 24| more_ = false; 309| 24| return; 310| 24| } 311| 40.7k| auto length = binary::little_to_native(buf, sizeof(buf)); 312| | 313| 40.7k| visitor.begin_array(semantic_tag::none, *this, ec); 314| 40.7k| more_ = !cursor_mode_; 315| 40.7k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 40.7k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 40.7k] | | ------------------ ------------------ 316| 0| { 317| 0| return; 318| 0| } 319| 40.7k| state_stack_.emplace_back(parse_mode::array, length, n); 320| 40.7k| } _ZN8jsoncons4bson17basic_bson_parserINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE9end_arrayERNS_18basic_json_visitorIcEERNS3_10error_codeE: 323| 18.1k| { 324| 18.1k| JSONCONS_ASSERT(state_stack_.size() >= 2); ------------------ | | 45| 18.1k|#define JSONCONS_ASSERT(x) if (!(x)) { \ | | ------------------ | | | Branch (45:32): [True: 0, False: 18.1k] | | ------------------ | | 46| 0| JSONCONS_THROW(jsoncons::assertion_error("assertion '" #x "' failed at <> :" \ | | ------------------ | | | | 35| 0| #define JSONCONS_THROW(exception) throw exception | | ------------------ | | 47| 0| JSONCONS_STR( 0 ))); } ------------------ 325| | 326| 18.1k| visitor.end_array(*this, ec); 327| 18.1k| more_ = !cursor_mode_; 328| 18.1k| if (level() == mark_level_) ------------------ | Branch (328:13): [True: 0, False: 18.1k] ------------------ 329| 0| { 330| 0| more_ = false; 331| 0| } 332| 18.1k| if (JSONCONS_UNLIKELY(state_stack_.back().pos != state_stack_.back().length)) ------------------ | | 78| 18.1k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 343, False: 17.8k] | | ------------------ ------------------ 333| 343| { 334| 343| ec = bson_errc::size_mismatch; 335| 343| more_ = false; 336| 343| return; 337| 343| } 338| 17.8k| std::size_t pos = state_stack_.back().pos; 339| 17.8k| state_stack_.pop_back(); 340| 17.8k| state_stack_.back().pos += pos; 341| 17.8k| } _ZN8jsoncons4bson17basic_bson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEEC2IRNS3_13basic_istreamIcNS3_11char_traitsIcEEEEEEOT_RNS_18basic_json_visitorIcEERKNS0_19bson_decode_optionsERKS7_: 46| 4.39k| : parser_(std::forward(source), options, temp_alloc), 47| 4.39k| visitor_(visitor) 48| 4.39k| { 49| 4.39k| } _ZN8jsoncons4bson17basic_bson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4readERNS3_10error_codeE: 62| 4.39k| { 63| 4.39k| parser_.reset(); 64| 4.39k| parser_.parse(visitor_, ec); 65| 4.39k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 4.39k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 4.37k, False: 16] | | ------------------ ------------------ 66| 4.37k| { 67| 4.37k| return; 68| 4.37k| } 69| 4.39k| } _ZNK8jsoncons4bson17basic_bson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE4lineEv: 72| 4.37k| { 73| 4.37k| return parser_.line(); 74| 4.37k| } _ZNK8jsoncons4bson17basic_bson_readerINS_13stream_sourceIhNSt3__19allocatorIhEEEENS4_IcEEE6columnEv: 77| 4.37k| { 78| 4.37k| return parser_.column(); 79| 4.37k| } _ZN8jsoncons4bson11decode_bsonINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEJRNS4_19basic_istringstreamIcNS4_11char_traitsIcEES6_EEEEET_DpOT0_: 256| 4.39k|{ 257| 4.39k| auto result = try_decode_bson(std::forward(args)...); 258| 4.39k| if (!result) ------------------ | Branch (258:9): [True: 4.37k, False: 16] ------------------ 259| 4.37k| { 260| 4.37k| JSONCONS_THROW(ser_error(result.error().code(), result.error().line(), result.error().column())); ------------------ | | 35| 4.37k| #define JSONCONS_THROW(exception) throw exception ------------------ 261| 4.37k| } 262| 16| return std::move(*result); 263| 4.39k|} _ZN8jsoncons4bson15try_decode_bsonINS_10basic_jsonIcNS_13sorted_policyENSt3__19allocatorIcEEEEEENS4_9enable_ifIXsr10ext_traits13is_basic_jsonIT_EE5valueENS_6detail8expectedIS9_NS_10read_errorEEEE4typeERNS4_13basic_istreamIcNS4_11char_traitsIcEEEERKNS0_19bson_decode_optionsE: 79| 4.39k|{ 80| 4.39k| using value_type = T; 81| 4.39k| using result_type = read_result; 82| | 83| 4.39k| std::error_code ec; 84| 4.39k| jsoncons::json_decoder decoder; 85| 4.39k| auto adaptor = make_json_visitor_adaptor(decoder); 86| 4.39k| bson_stream_reader reader(is, adaptor, options); 87| 4.39k| reader.read(ec); 88| 4.39k| if (JSONCONS_UNLIKELY(ec)) ------------------ | | 78| 4.39k|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 4.37k, False: 16] | | ------------------ ------------------ 89| 4.37k| { 90| 4.37k| return result_type{jsoncons::unexpect, ec, reader.line(), reader.column()}; 91| 4.37k| } 92| 16| if (JSONCONS_UNLIKELY(!decoder.is_valid())) ------------------ | | 78| 16|#define JSONCONS_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (78:30): [True: 0, False: 16] | | ------------------ ------------------ 93| 0| { 94| 0| return result_type{jsoncons::unexpect, conv_errc::conversion_failed, reader.line(), reader.column()}; 95| 0| } 96| 16| return result_type{decoder.get_result()}; 97| 16|}