_ZNK11ArduinoJson8V6213HB46detail14CollectionData4headEv: 69| 1.08k| VariantSlot* head() const { 70| 1.08k| return head_; 71| 1.08k| } _ZN11ArduinoJson8V6213HB46detail14CollectionData5clearEv: 47| 4.92k|inline void CollectionData::clear() { 48| 4.92k| head_ = 0; 49| 4.92k| tail_ = 0; 50| 4.92k|} _ZN11ArduinoJson8V6213HB46detail14CollectionData7addSlotEPNS1_10MemoryPoolE: 14| 18.5k|inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) { 15| 18.5k| VariantSlot* slot = pool->allocVariant(); 16| 18.5k| if (!slot) ------------------ | Branch (16:7): [True: 6, False: 18.5k] ------------------ 17| 6| return 0; 18| | 19| 18.5k| if (tail_) { ------------------ | Branch (19:7): [True: 15.4k, False: 3.11k] ------------------ 20| 15.4k| ARDUINOJSON_ASSERT(pool->owns(tail_)); // Can't alter a linked array/object ------------------ | | 11| 15.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 21| 0| tail_->setNextNotNull(slot); 22| 15.4k| tail_ = slot; 23| 15.4k| } else { 24| 3.11k| head_ = slot; 25| 3.11k| tail_ = slot; 26| 3.11k| } 27| | 28| 0| slot->clear(); 29| 18.5k| return slot; 30| 18.5k|} _ZN11ArduinoJson8V6213HB46detail14CollectionData10addElementEPNS1_10MemoryPoolE: 32| 16.3k|inline VariantData* CollectionData::addElement(MemoryPool* pool) { 33| 16.3k| return slotData(addSlot(pool)); 34| 16.3k|} _ZNK11ArduinoJson8V6213HB46detail14CollectionData4sizeEv: 176| 1.08k|inline size_t CollectionData::size() const { 177| 1.08k| return slotSize(head_); 178| 1.08k|} _ZNK11ArduinoJson8V6213HB420DeserializationErrorcvbEv: 56| 1.96k| explicit operator bool() const { 57| 1.96k| return code_ != Ok; 58| 1.96k| } _ZN11ArduinoJson8V6213HB420DeserializationErrorC2ENS1_4CodeE: 29| 1.96k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V6213HB46detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 1.96k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 1.96k| return {{}, nestingLimit}; 33| 1.96k|} _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter10allowValueEv: 59| 20.1k| bool allowValue() const { 60| 20.1k| return true; 61| 20.1k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter11allowObjectEv: 55| 1.94k| bool allowObject() const { 56| 1.94k| return true; 57| 1.94k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilterixIPKcEES2_RKT_: 64| 2.16k| AllowAllFilter operator[](const TKey&) const { 65| 2.16k| return AllowAllFilter(); 66| 2.16k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter5allowEv: 47| 18.5k| bool allow() const { 48| 18.5k| return true; 49| 18.5k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilter10allowArrayEv: 51| 2.98k| bool allowArray() const { 52| 2.98k| return true; 53| 2.98k| } _ZNK11ArduinoJson8V6213HB46detail14AllowAllFilterixIjEES2_RKT_: 64| 2.98k| AllowAllFilter operator[](const TKey&) const { 65| 2.98k| return AllowAllFilter(); 66| 2.98k| } _ZN11ArduinoJson8V6213HB421DeserializationOption12NestingLimitC2Ev: 15| 1.96k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} _ZNK11ArduinoJson8V6213HB421DeserializationOption12NestingLimit7reachedEv: 23| 4.92k| bool reached() const { 24| 4.92k| return value_ == 0; 25| 4.92k| } _ZNK11ArduinoJson8V6213HB421DeserializationOption12NestingLimit9decrementEv: 18| 18.5k| NestingLimit decrement() const { 19| 18.5k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 18.5k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 0| return NestingLimit(static_cast(value_ - 1)); 21| 18.5k| } _ZN11ArduinoJson8V6213HB421DeserializationOption12NestingLimitC2Eh: 16| 18.5k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V6213HB46detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 71| 1.96k|BoundedReader makeReader(TChar* input, size_t inputSize) { 72| 1.96k| return BoundedReader{input, inputSize}; 73| 1.96k|} _ZN11ArduinoJson8V6213HB46detail14IteratorReaderIPKcEC2ES4_S4_: 15| 1.96k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V6213HB46detail14IteratorReaderIPKcE4readEv: 17| 28.1k| int read() { 18| 28.1k| if (ptr_ < end_) ------------------ | Branch (18:9): [True: 27.3k, False: 748] ------------------ 19| 27.3k| return static_cast(*ptr_++); 20| 748| else 21| 748| return -1; 22| 28.1k| } _ZN11ArduinoJson8V6213HB46detail14IteratorReaderIPKcE9readBytesEPcm: 24| 13.2k| size_t readBytes(char* buffer, size_t length) { 25| 13.2k| size_t i = 0; 26| 38.3k| while (i < length && ptr_ < end_) ------------------ | Branch (26:12): [True: 25.7k, False: 12.6k] | Branch (26:26): [True: 25.1k, False: 568] ------------------ 27| 25.1k| buffer[i++] = *ptr_++; 28| 13.2k| return i; 29| 13.2k| } _ZN11ArduinoJson8V6213HB46detail13BoundedReaderIPKhvEC2EPKvm: 48| 1.96k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V6213HB46detail11deserializeINS1_19MsgPackDeserializerEKhmJEvEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT0_T1_DpT2_: 55| 1.96k| Size inputSize, Args... args) { 56| 1.96k| auto reader = makeReader(input, size_t(inputSize)); 57| 1.96k| auto data = VariantAttorney::getData(doc); 58| 1.96k| auto pool = VariantAttorney::getPool(doc); 59| 1.96k| auto options = makeDeserializationOptions(args...); 60| 1.96k| doc.clear(); 61| 1.96k| return makeDeserializer(pool, reader, 62| 1.96k| makeStringStorage(input, pool)) 63| 1.96k| .parse(*data, options.filter, options.nestingLimit); 64| 1.96k|} _ZN11ArduinoJson8V6213HB46detail16makeDeserializerINS1_19MsgPackDeserializerENS1_13BoundedReaderIPKhvEENS1_12StringCopierEEET_IT0_T1_EPNS1_10MemoryPoolESA_SB_: 30| 1.96k| TWriter writer) { 31| 1.96k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 1.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 0| return TDeserializer(pool, reader, writer); 33| 1.96k|} _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEEC2EmS2_: 46| 1.96k| : AllocatorOwner(alloc), JsonDocument(allocPool(capa)) {} _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEEC2ES2_: 17| 1.96k| AllocatorOwner(TAllocator a) : allocator_(a) {} _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEE9allocPoolEm: 137| 1.96k| detail::MemoryPool allocPool(size_t requiredSize) { 138| 1.96k| size_t capa = detail::addPadding(requiredSize); 139| 1.96k| return {reinterpret_cast(this->allocate(capa)), capa}; 140| 1.96k| } _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEE8allocateEm: 19| 1.96k| void* allocate(size_t size) { 20| 1.96k| return allocator_.allocate(size); 21| 1.96k| } _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEED2Ev: 83| 1.96k| ~BasicJsonDocument() { 84| 1.96k| freePool(); 85| 1.96k| } _ZN11ArduinoJson8V6213HB417BasicJsonDocumentINS0_16DefaultAllocatorEE8freePoolEv: 150| 1.96k| void freePool() { 151| 1.96k| this->deallocate(getPool()->buffer()); 152| 1.96k| } _ZN11ArduinoJson8V6213HB414AllocatorOwnerINS0_16DefaultAllocatorEE10deallocateEPv: 23| 1.96k| void deallocate(void* ptr) { 24| 1.96k| if (ptr) ------------------ | Branch (24:9): [True: 1.96k, False: 0] ------------------ 25| 1.96k| allocator_.deallocate(ptr); 26| 1.96k| } _ZN11ArduinoJson8V6213HB416DefaultAllocator8allocateEm: 15| 1.96k| void* allocate(size_t size) { 16| 1.96k| return malloc(size); 17| 1.96k| } _ZN11ArduinoJson8V6213HB416DefaultAllocator10deallocateEPv: 19| 1.96k| void deallocate(void* ptr) { 20| 1.96k| free(ptr); 21| 1.96k| } _ZNK11ArduinoJson8V6213HB412JsonDocumentcvNS0_16JsonVariantConstEEv: 275| 616| FORCE_INLINE operator JsonVariantConst() const { 276| 616| return getVariant(); 277| 616| } _ZNK11ArduinoJson8V6213HB412JsonDocument10getVariantEv: 296| 616| JsonVariantConst getVariant() const { 297| 616| return JsonVariantConst(&data_); 298| 616| } _ZN11ArduinoJson8V6213HB412JsonDocumentC2ENS0_6detail10MemoryPoolE: 282| 1.96k| JsonDocument(detail::MemoryPool pool) : pool_(pool) {} _ZN11ArduinoJson8V6213HB412JsonDocument7getPoolEv: 304| 3.92k| detail::MemoryPool* getPool() { 305| 3.92k| return &pool_; 306| 3.92k| } _ZN11ArduinoJson8V6213HB412JsonDocumentD2Ev: 286| 1.96k| ~JsonDocument() {} _ZN11ArduinoJson8V6213HB412JsonDocument7getDataEv: 308| 1.96k| detail::VariantData* getData() { 309| 1.96k| return &data_; 310| 1.96k| } _ZN11ArduinoJson8V6213HB412JsonDocument5clearEv: 42| 1.96k| void clear() { 43| 1.96k| pool_.clear(); 44| 1.96k| data_.setNull(); 45| 1.96k| } _ZN11ArduinoJson8V6213HB46detail10addPaddingEm: 21| 1.96k|inline size_t addPadding(size_t bytes) { 22| 1.96k| const size_t mask = sizeof(void*) - 1; 23| 1.96k| return (bytes + mask) & ~mask; 24| 1.96k|} _ZN11ArduinoJson8V6213HB46detail9isAlignedIcEEbPT_: 50| 6.72k|inline bool isAligned(T* ptr) { 51| 6.72k| return isAligned(reinterpret_cast(ptr)); 52| 6.72k|} _ZN11ArduinoJson8V6213HB46detail9isAlignedEm: 15| 6.72k|inline bool isAligned(size_t value) { 16| 6.72k| const size_t mask = sizeof(void*) - 1; 17| 6.72k| size_t addr = value; 18| 6.72k| return (addr & mask) == 0; 19| 6.72k|} _ZN11ArduinoJson8V6213HB46detail10MemoryPoolC2EPcm: 44| 1.96k| overflowed_(false) { 45| 1.96k| ARDUINOJSON_ASSERT(isAligned(begin_)); ------------------ | | 11| 1.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 46| 1.96k| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 1.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 1.96k| ARDUINOJSON_ASSERT(isAligned(end_)); ------------------ | | 11| 1.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 1.96k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool6bufferEv: 50| 1.96k| void* buffer() { 51| 1.96k| return begin_; // NOLINT(clang-analyzer-unix.Malloc) 52| | // movePointers() alters this pointer 53| 1.96k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool5clearEv: 116| 1.96k| void clear() { 117| 1.96k| left_ = begin_; 118| 1.96k| right_ = end_; 119| 1.96k| overflowed_ = false; 120| 1.96k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool11getFreeZoneEPPcPm: 93| 4.56k| void getFreeZone(char** zoneStart, size_t* zoneSize) const { 94| 4.56k| *zoneStart = left_; 95| 4.56k| *zoneSize = size_t(right_ - left_); 96| 4.56k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool16markAsOverflowedEv: 112| 341| void markAsOverflowed() { 113| 341| overflowed_ = true; 114| 341| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool10overflowedEv: 64| 4.31k| bool overflowed() const { 65| 4.31k| return overflowed_; 66| 4.31k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool22saveStringFromFreeZoneEm: 98| 4.30k| const char* saveStringFromFreeZone(size_t len) { 99| 4.30k|#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 100| 4.30k| const char* dup = findString(adaptString(left_, len)); 101| 4.30k| if (dup) ------------------ | Branch (101:9): [True: 3.46k, False: 837] ------------------ 102| 3.46k| return dup; 103| 837|#endif 104| | 105| 837| const char* str = left_; 106| 837| left_ += len; 107| 837| *left_++ = 0; 108| 837| checkInvariants(); 109| 837| return str; 110| 4.30k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool10findStringINS1_14SizedRamStringEEEPKcRKT_: 179| 4.30k| const char* findString(const TAdaptedString& str) const { 180| 4.30k| size_t n = str.size(); 181| 8.21k| for (char* next = begin_; next + n < left_; ++next) { ------------------ | Branch (181:31): [True: 7.38k, False: 837] ------------------ 182| 7.38k| if (next[n] == '\0' && stringEquals(str, adaptString(next, n))) ------------------ | Branch (182:11): [True: 6.60k, False: 776] | Branch (182:11): [True: 3.46k, False: 3.91k] | Branch (182:30): [True: 3.46k, False: 3.14k] ------------------ 183| 3.46k| return next; 184| | 185| | // jump to next terminator 186| 7.89k| while (*next) ------------------ | Branch (186:14): [True: 3.97k, False: 3.91k] ------------------ 187| 3.97k| ++next; 188| 3.91k| } 189| 837| return 0; 190| 4.30k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool15checkInvariantsEv: 170| 837| void checkInvariants() { 171| 837| ARDUINOJSON_ASSERT(begin_ <= left_); ------------------ | | 11| 837|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 172| 837| ARDUINOJSON_ASSERT(left_ <= right_); ------------------ | | 11| 837|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 173| 837| ARDUINOJSON_ASSERT(right_ <= end_); ------------------ | | 11| 837|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 174| 837| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 837|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 175| 837| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool12allocVariantEv: 68| 18.5k| VariantSlot* allocVariant() { 69| 18.5k| return allocRight(); 70| 18.5k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool10allocRightINS1_11VariantSlotEEEPT_v: 205| 18.5k| T* allocRight() { 206| 18.5k| return reinterpret_cast(allocRight(sizeof(T))); 207| 18.5k| } _ZN11ArduinoJson8V6213HB46detail10MemoryPool10allocRightEm: 209| 18.5k| void* allocRight(size_t bytes) { 210| 18.5k| if (!canAlloc(bytes)) { ------------------ | Branch (210:9): [True: 6, False: 18.5k] ------------------ 211| 6| overflowed_ = true; 212| 6| return 0; 213| 6| } 214| 18.5k| right_ -= bytes; 215| 18.5k| return right_; 216| 18.5k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool8canAllocEm: 122| 18.5k| bool canAlloc(size_t bytes) const { 123| 18.5k| return left_ + bytes <= right_; 124| 18.5k| } _ZNK11ArduinoJson8V6213HB46detail10MemoryPool4ownsEPv: 126| 15.4k| bool owns(void* p) const { 127| 15.4k| return begin_ <= p && p < end_; ------------------ | Branch (127:12): [True: 15.4k, False: 0] | Branch (127:27): [True: 15.4k, False: 0] ------------------ 128| 15.4k| } _ZN11ArduinoJson8V6213HB418deserializeMsgPackIKhJRmEEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT_DpOT0_: 579| 1.96k| Args&&... args) { 580| 1.96k| using namespace detail; 581| 1.96k| return deserialize(doc, input, 582| 1.96k| detail::forward(args)...); 583| 1.96k|} _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEEC2EPNS1_10MemoryPoolES6_S7_: 24| 1.96k| foundSomething_(false) {} _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 28| 1.96k| DeserializationOption::NestingLimit nestingLimit) { 29| 1.96k| DeserializationError::Code err; 30| 1.96k| err = parseVariant(&variant, filter, nestingLimit); 31| 1.96k| return foundSomething_ ? err : DeserializationError::EmptyInput; ------------------ | Branch (31:12): [True: 1.96k, False: 0] ------------------ 32| 1.96k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 38| 20.4k| DeserializationOption::NestingLimit nestingLimit) { 39| 20.4k| DeserializationError::Code err; 40| | 41| 20.4k| uint8_t code = 0; // TODO: why do we need to initialize this variable? 42| 20.4k| err = readByte(code); 43| 20.4k| if (err) ------------------ | Branch (43:9): [True: 379, False: 20.1k] ------------------ 44| 379| return err; 45| | 46| 20.1k| foundSomething_ = true; 47| | 48| 20.1k| bool allowValue = filter.allowValue(); 49| | 50| 20.1k| if (allowValue) { ------------------ | Branch (50:9): [True: 20.1k, False: 0] ------------------ 51| | // callers pass a null pointer only when value must be ignored 52| 20.1k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 20.1k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 53| 20.1k| } 54| | 55| 0| switch (code) { ------------------ | Branch (55:13): [True: 12.4k, False: 7.63k] ------------------ 56| 476| case 0xc0: ------------------ | Branch (56:7): [True: 476, False: 19.6k] ------------------ 57| | // already null 58| 476| return DeserializationError::Ok; 59| | 60| 3| case 0xc1: ------------------ | Branch (60:7): [True: 3, False: 20.1k] ------------------ 61| 3| return DeserializationError::InvalidInput; 62| | 63| 300| case 0xc2: ------------------ | Branch (63:7): [True: 300, False: 19.8k] ------------------ 64| 300| if (allowValue) ------------------ | Branch (64:13): [True: 300, False: 0] ------------------ 65| 300| variant->setBoolean(false); 66| 300| return DeserializationError::Ok; 67| | 68| 277| case 0xc3: ------------------ | Branch (68:7): [True: 277, False: 19.8k] ------------------ 69| 277| if (allowValue) ------------------ | Branch (69:13): [True: 277, False: 0] ------------------ 70| 277| variant->setBoolean(true); 71| 277| return DeserializationError::Ok; 72| | 73| 237| case 0xc4: // bin 8 (not supported) ------------------ | Branch (73:7): [True: 237, False: 19.8k] ------------------ 74| 237| return skipString(); 75| | 76| 395| case 0xc5: // bin 16 (not supported) ------------------ | Branch (76:7): [True: 395, False: 19.7k] ------------------ 77| 395| return skipString(); 78| | 79| 310| case 0xc6: // bin 32 (not supported) ------------------ | Branch (79:7): [True: 310, False: 19.7k] ------------------ 80| 310| return skipString(); 81| | 82| 213| case 0xc7: // ext 8 (not supported) ------------------ | Branch (82:7): [True: 213, False: 19.8k] ------------------ 83| 213| return skipExt(); 84| | 85| 242| case 0xc8: // ext 16 (not supported) ------------------ | Branch (85:7): [True: 242, False: 19.8k] ------------------ 86| 242| return skipExt(); 87| | 88| 301| case 0xc9: // ext 32 (not supported) ------------------ | Branch (88:7): [True: 301, False: 19.8k] ------------------ 89| 301| return skipExt(); 90| | 91| 570| case 0xca: ------------------ | Branch (91:7): [True: 570, False: 19.5k] ------------------ 92| 570| if (allowValue) ------------------ | Branch (92:13): [True: 570, False: 0] ------------------ 93| 570| return readFloat(variant); 94| 0| else 95| 0| return skipBytes(4); 96| | 97| 96| case 0xcb: ------------------ | Branch (97:7): [True: 96, False: 20.0k] ------------------ 98| 96| if (allowValue) ------------------ | Branch (98:13): [True: 96, False: 0] ------------------ 99| 96| return readDouble(variant); 100| 0| else 101| 0| return skipBytes(8); 102| | 103| 188| case 0xcc: ------------------ | Branch (103:7): [True: 188, False: 19.9k] ------------------ 104| 188| if (allowValue) ------------------ | Branch (104:13): [True: 188, False: 0] ------------------ 105| 188| return readInteger(variant); 106| 0| else 107| 0| return skipBytes(1); 108| | 109| 318| case 0xcd: ------------------ | Branch (109:7): [True: 318, False: 19.7k] ------------------ 110| 318| if (allowValue) ------------------ | Branch (110:13): [True: 318, False: 0] ------------------ 111| 318| return readInteger(variant); 112| 0| else 113| 0| return skipBytes(2); 114| | 115| 236| case 0xce: ------------------ | Branch (115:7): [True: 236, False: 19.8k] ------------------ 116| 236| if (allowValue) ------------------ | Branch (116:13): [True: 236, False: 0] ------------------ 117| 236| return readInteger(variant); 118| 0| else 119| 0| return skipBytes(4); 120| | 121| 169| case 0xcf: ------------------ | Branch (121:7): [True: 169, False: 19.9k] ------------------ 122| 169|#if ARDUINOJSON_USE_LONG_LONG 123| 169| if (allowValue) ------------------ | Branch (123:13): [True: 169, False: 0] ------------------ 124| 169| return readInteger(variant); 125| 0| else 126| 0| return skipBytes(8); 127| |#else 128| | return skipBytes(8); // not supported 129| |#endif 130| | 131| 156| case 0xd0: ------------------ | Branch (131:7): [True: 156, False: 19.9k] ------------------ 132| 156| if (allowValue) ------------------ | Branch (132:13): [True: 156, False: 0] ------------------ 133| 156| return readInteger(variant); 134| 0| else 135| 0| return skipBytes(1); 136| | 137| 375| case 0xd1: ------------------ | Branch (137:7): [True: 375, False: 19.7k] ------------------ 138| 375| if (allowValue) ------------------ | Branch (138:13): [True: 375, False: 0] ------------------ 139| 375| return readInteger(variant); 140| 0| else 141| 0| return skipBytes(2); 142| | 143| 225| case 0xd2: ------------------ | Branch (143:7): [True: 225, False: 19.8k] ------------------ 144| 225| if (allowValue) ------------------ | Branch (144:13): [True: 225, False: 0] ------------------ 145| 225| return readInteger(variant); 146| 0| else 147| 0| return skipBytes(4); 148| | 149| 104| case 0xd3: ------------------ | Branch (149:7): [True: 104, False: 20.0k] ------------------ 150| 104|#if ARDUINOJSON_USE_LONG_LONG 151| 104| if (allowValue) ------------------ | Branch (151:13): [True: 104, False: 0] ------------------ 152| 104| return readInteger(variant); 153| 0| else 154| 0| return skipBytes(8); // not supported 155| |#else 156| | return skipBytes(8); 157| |#endif 158| | 159| 205| case 0xd4: // fixext 1 (not supported) ------------------ | Branch (159:7): [True: 205, False: 19.9k] ------------------ 160| 205| return skipBytes(2); 161| | 162| 172| case 0xd5: // fixext 2 (not supported) ------------------ | Branch (162:7): [True: 172, False: 19.9k] ------------------ 163| 172| return skipBytes(3); 164| | 165| 160| case 0xd6: // fixext 4 (not supported) ------------------ | Branch (165:7): [True: 160, False: 19.9k] ------------------ 166| 160| return skipBytes(5); 167| | 168| 91| case 0xd7: // fixext 8 (not supported) ------------------ | Branch (168:7): [True: 91, False: 20.0k] ------------------ 169| 91| return skipBytes(9); 170| | 171| 53| case 0xd8: // fixext 16 (not supported) ------------------ | Branch (171:7): [True: 53, False: 20.0k] ------------------ 172| 53| return skipBytes(17); 173| | 174| 167| case 0xd9: ------------------ | Branch (174:7): [True: 167, False: 19.9k] ------------------ 175| 167| if (allowValue) ------------------ | Branch (175:13): [True: 167, False: 0] ------------------ 176| 167| return readString(variant); 177| 0| else 178| 0| return skipString(); 179| | 180| 298| case 0xda: ------------------ | Branch (180:7): [True: 298, False: 19.8k] ------------------ 181| 298| if (allowValue) ------------------ | Branch (181:13): [True: 298, False: 0] ------------------ 182| 298| return readString(variant); 183| 0| else 184| 0| return skipString(); 185| | 186| 196| case 0xdb: ------------------ | Branch (186:7): [True: 196, False: 19.9k] ------------------ 187| 196| if (allowValue) ------------------ | Branch (187:13): [True: 196, False: 0] ------------------ 188| 196| return readString(variant); 189| 0| else 190| 0| return skipString(); 191| | 192| 367| case 0xdc: ------------------ | Branch (192:7): [True: 367, False: 19.7k] ------------------ 193| 367| return readArray(variant, filter, nestingLimit); 194| | 195| 196| case 0xdd: ------------------ | Branch (195:7): [True: 196, False: 19.9k] ------------------ 196| 196| return readArray(variant, filter, nestingLimit); 197| | 198| 343| case 0xde: ------------------ | Branch (198:7): [True: 343, False: 19.7k] ------------------ 199| 343| return readObject(variant, filter, nestingLimit); 200| | 201| 196| case 0xdf: ------------------ | Branch (201:7): [True: 196, False: 19.9k] ------------------ 202| 196| return readObject(variant, filter, nestingLimit); 203| 20.1k| } 204| | 205| 12.4k| switch (code & 0xf0) { ------------------ | Branch (205:13): [True: 8.59k, False: 3.88k] ------------------ 206| 1.43k| case 0x80: ------------------ | Branch (206:7): [True: 1.43k, False: 11.0k] ------------------ 207| 1.43k| return readObject(variant, code & 0x0F, filter, nestingLimit); 208| | 209| 2.44k| case 0x90: ------------------ | Branch (209:7): [True: 2.44k, False: 10.0k] ------------------ 210| 2.44k| return readArray(variant, code & 0x0F, filter, nestingLimit); 211| 12.4k| } 212| | 213| 8.59k| if ((code & 0xe0) == 0xa0) { ------------------ | Branch (213:9): [True: 1.58k, False: 7.00k] ------------------ 214| 1.58k| if (allowValue) ------------------ | Branch (214:11): [True: 1.58k, False: 0] ------------------ 215| 1.58k| return readString(variant, code & 0x1f); 216| 0| else 217| 0| return skipBytes(code & 0x1f); 218| 1.58k| } 219| | 220| 7.00k| if (allowValue) ------------------ | Branch (220:9): [True: 7.00k, False: 0] ------------------ 221| 7.00k| variant->setInteger(static_cast(code)); 222| | 223| 7.00k| return DeserializationError::Ok; 224| 8.59k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE8readByteERh: 226| 22.9k| DeserializationError::Code readByte(uint8_t& value) { 227| 22.9k| int c = reader_.read(); 228| 22.9k| if (c < 0) ------------------ | Branch (228:9): [True: 450, False: 22.4k] ------------------ 229| 450| return DeserializationError::IncompleteInput; 230| 22.4k| value = static_cast(c); 231| 22.4k| return DeserializationError::Ok; 232| 22.9k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringIhEENS0_20DeserializationError4CodeEv: 356| 237| DeserializationError::Code skipString() { 357| 237| DeserializationError::Code err; 358| 237| T size; 359| | 360| 237| err = readInteger(size); 361| 237| if (err) ------------------ | Branch (361:9): [True: 7, False: 230] ------------------ 362| 7| return err; 363| | 364| 230| return skipBytes(size); 365| 237| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIhEENS0_20DeserializationError4CodeERT_: 254| 1.05k| DeserializationError::Code readInteger(T& value) { 255| 1.05k| DeserializationError::Code err; 256| | 257| 1.05k| err = readBytes(value); 258| 1.05k| if (err) ------------------ | Branch (258:9): [True: 35, False: 1.01k] ------------------ 259| 35| return err; 260| | 261| 1.01k| fixEndianess(value); 262| | 263| 1.01k| return DeserializationError::Ok; 264| 1.05k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIhEENS0_20DeserializationError4CodeERT_: 241| 7.40k| DeserializationError::Code readBytes(T& value) { 242| 7.40k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 7.40k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesEPhm: 234| 13.2k| DeserializationError::Code readBytes(uint8_t* p, size_t n) { 235| 13.2k| if (reader_.readBytes(reinterpret_cast(p), n) == n) ------------------ | Branch (235:9): [True: 12.6k, False: 568] ------------------ 236| 12.6k| return DeserializationError::Ok; 237| 568| return DeserializationError::IncompleteInput; 238| 13.2k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringItEENS0_20DeserializationError4CodeEv: 356| 395| DeserializationError::Code skipString() { 357| 395| DeserializationError::Code err; 358| 395| T size; 359| | 360| 395| err = readInteger(size); 361| 395| if (err) ------------------ | Branch (361:9): [True: 13, False: 382] ------------------ 362| 13| return err; 363| | 364| 382| return skipBytes(size); 365| 395| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerItEENS0_20DeserializationError4CodeERT_: 254| 2.37k| DeserializationError::Code readInteger(T& value) { 255| 2.37k| DeserializationError::Code err; 256| | 257| 2.37k| err = readBytes(value); 258| 2.37k| if (err) ------------------ | Branch (258:9): [True: 90, False: 2.28k] ------------------ 259| 90| return err; 260| | 261| 2.28k| fixEndianess(value); 262| | 263| 2.28k| return DeserializationError::Ok; 264| 2.37k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesItEENS0_20DeserializationError4CodeERT_: 241| 2.37k| DeserializationError::Code readBytes(T& value) { 242| 2.37k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 2.37k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringIjEENS0_20DeserializationError4CodeEv: 356| 310| DeserializationError::Code skipString() { 357| 310| DeserializationError::Code err; 358| 310| T size; 359| | 360| 310| err = readInteger(size); 361| 310| if (err) ------------------ | Branch (361:9): [True: 14, False: 296] ------------------ 362| 14| return err; 363| | 364| 296| return skipBytes(size); 365| 310| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIjEENS0_20DeserializationError4CodeERT_: 254| 1.74k| DeserializationError::Code readInteger(T& value) { 255| 1.74k| DeserializationError::Code err; 256| | 257| 1.74k| err = readBytes(value); 258| 1.74k| if (err) ------------------ | Branch (258:9): [True: 98, False: 1.64k] ------------------ 259| 98| return err; 260| | 261| 1.64k| fixEndianess(value); 262| | 263| 1.64k| return DeserializationError::Ok; 264| 1.74k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIjEENS0_20DeserializationError4CodeERT_: 241| 1.74k| DeserializationError::Code readBytes(T& value) { 242| 1.74k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 1.74k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtIhEENS0_20DeserializationError4CodeEv: 546| 213| DeserializationError::Code skipExt() { 547| 213| DeserializationError::Code err; 548| 213| T size; 549| | 550| 213| err = readInteger(size); 551| 213| if (err) ------------------ | Branch (551:9): [True: 7, False: 206] ------------------ 552| 7| return err; 553| | 554| 206| return skipBytes(size + 1U); 555| 213| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtItEENS0_20DeserializationError4CodeEv: 546| 242| DeserializationError::Code skipExt() { 547| 242| DeserializationError::Code err; 548| 242| T size; 549| | 550| 242| err = readInteger(size); 551| 242| if (err) ------------------ | Branch (551:9): [True: 12, False: 230] ------------------ 552| 12| return err; 553| | 554| 230| return skipBytes(size + 1U); 555| 242| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtIjEENS0_20DeserializationError4CodeEv: 546| 301| DeserializationError::Code skipExt() { 547| 301| DeserializationError::Code err; 548| 301| T size; 549| | 550| 301| err = readInteger(size); 551| 301| if (err) ------------------ | Branch (551:9): [True: 14, False: 287] ------------------ 552| 14| return err; 553| | 554| 287| return skipBytes(size + 1U); 555| 301| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readFloatIfEENS1_9enable_ifIXeqstT_Li4EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 282| 570| readFloat(VariantData* variant) { 283| 570| DeserializationError::Code err; 284| 570| T value; 285| | 286| 570| err = readBytes(value); 287| 570| if (err) ------------------ | Branch (287:9): [True: 14, False: 556] ------------------ 288| 14| return err; 289| | 290| 556| fixEndianess(value); 291| 556| variant->setFloat(value); 292| | 293| 556| return DeserializationError::Ok; 294| 570| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIfEENS0_20DeserializationError4CodeERT_: 241| 570| DeserializationError::Code readBytes(T& value) { 242| 570| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 570| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9skipBytesEm: 245| 2.31k| DeserializationError::Code skipBytes(size_t n) { 246| 7.18k| for (; n; --n) { ------------------ | Branch (246:12): [True: 5.17k, False: 2.01k] ------------------ 247| 5.17k| if (reader_.read() < 0) ------------------ | Branch (247:11): [True: 298, False: 4.87k] ------------------ 248| 298| return DeserializationError::IncompleteInput; 249| 5.17k| } 250| 2.01k| return DeserializationError::Ok; 251| 2.31k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readDoubleIdEENS1_9enable_ifIXeqstT_Li8EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 298| 96| readDouble(VariantData* variant) { 299| 96| DeserializationError::Code err; 300| 96| T value; 301| | 302| 96| err = readBytes(value); 303| 96| if (err) ------------------ | Branch (303:9): [True: 15, False: 81] ------------------ 304| 15| return err; 305| | 306| 81| fixEndianess(value); 307| 81| variant->setFloat(value); 308| | 309| 81| return DeserializationError::Ok; 310| 96| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIdEENS0_20DeserializationError4CodeERT_: 241| 96| DeserializationError::Code readBytes(T& value) { 242| 96| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 96| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIhEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 188| DeserializationError::Code readInteger(VariantData* variant) { 268| 188| DeserializationError::Code err; 269| 188| T value; 270| | 271| 188| err = readInteger(value); 272| 188| if (err) ------------------ | Branch (272:9): [True: 7, False: 181] ------------------ 273| 7| return err; 274| | 275| 181| variant->setInteger(value); 276| | 277| 181| return DeserializationError::Ok; 278| 188| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerItEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 318| DeserializationError::Code readInteger(VariantData* variant) { 268| 318| DeserializationError::Code err; 269| 318| T value; 270| | 271| 318| err = readInteger(value); 272| 318| if (err) ------------------ | Branch (272:9): [True: 13, False: 305] ------------------ 273| 13| return err; 274| | 275| 305| variant->setInteger(value); 276| | 277| 305| return DeserializationError::Ok; 278| 318| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIjEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 236| DeserializationError::Code readInteger(VariantData* variant) { 268| 236| DeserializationError::Code err; 269| 236| T value; 270| | 271| 236| err = readInteger(value); 272| 236| if (err) ------------------ | Branch (272:9): [True: 14, False: 222] ------------------ 273| 14| return err; 274| | 275| 222| variant->setInteger(value); 276| | 277| 222| return DeserializationError::Ok; 278| 236| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerImEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 169| DeserializationError::Code readInteger(VariantData* variant) { 268| 169| DeserializationError::Code err; 269| 169| T value; 270| | 271| 169| err = readInteger(value); 272| 169| if (err) ------------------ | Branch (272:9): [True: 15, False: 154] ------------------ 273| 15| return err; 274| | 275| 154| variant->setInteger(value); 276| | 277| 154| return DeserializationError::Ok; 278| 169| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerImEENS0_20DeserializationError4CodeERT_: 254| 169| DeserializationError::Code readInteger(T& value) { 255| 169| DeserializationError::Code err; 256| | 257| 169| err = readBytes(value); 258| 169| if (err) ------------------ | Branch (258:9): [True: 15, False: 154] ------------------ 259| 15| return err; 260| | 261| 154| fixEndianess(value); 262| | 263| 154| return DeserializationError::Ok; 264| 169| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesImEENS0_20DeserializationError4CodeERT_: 241| 169| DeserializationError::Code readBytes(T& value) { 242| 169| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 169| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIaEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 156| DeserializationError::Code readInteger(VariantData* variant) { 268| 156| DeserializationError::Code err; 269| 156| T value; 270| | 271| 156| err = readInteger(value); 272| 156| if (err) ------------------ | Branch (272:9): [True: 7, False: 149] ------------------ 273| 7| return err; 274| | 275| 149| variant->setInteger(value); 276| | 277| 149| return DeserializationError::Ok; 278| 156| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIaEENS0_20DeserializationError4CodeERT_: 254| 156| DeserializationError::Code readInteger(T& value) { 255| 156| DeserializationError::Code err; 256| | 257| 156| err = readBytes(value); 258| 156| if (err) ------------------ | Branch (258:9): [True: 7, False: 149] ------------------ 259| 7| return err; 260| | 261| 149| fixEndianess(value); 262| | 263| 149| return DeserializationError::Ok; 264| 156| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIaEENS0_20DeserializationError4CodeERT_: 241| 156| DeserializationError::Code readBytes(T& value) { 242| 156| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 156| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIsEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 375| DeserializationError::Code readInteger(VariantData* variant) { 268| 375| DeserializationError::Code err; 269| 375| T value; 270| | 271| 375| err = readInteger(value); 272| 375| if (err) ------------------ | Branch (272:9): [True: 13, False: 362] ------------------ 273| 13| return err; 274| | 275| 362| variant->setInteger(value); 276| | 277| 362| return DeserializationError::Ok; 278| 375| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIsEENS0_20DeserializationError4CodeERT_: 254| 375| DeserializationError::Code readInteger(T& value) { 255| 375| DeserializationError::Code err; 256| | 257| 375| err = readBytes(value); 258| 375| if (err) ------------------ | Branch (258:9): [True: 13, False: 362] ------------------ 259| 13| return err; 260| | 261| 362| fixEndianess(value); 262| | 263| 362| return DeserializationError::Ok; 264| 375| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIsEENS0_20DeserializationError4CodeERT_: 241| 375| DeserializationError::Code readBytes(T& value) { 242| 375| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 375| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIiEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 225| DeserializationError::Code readInteger(VariantData* variant) { 268| 225| DeserializationError::Code err; 269| 225| T value; 270| | 271| 225| err = readInteger(value); 272| 225| if (err) ------------------ | Branch (272:9): [True: 14, False: 211] ------------------ 273| 14| return err; 274| | 275| 211| variant->setInteger(value); 276| | 277| 211| return DeserializationError::Ok; 278| 225| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIiEENS0_20DeserializationError4CodeERT_: 254| 225| DeserializationError::Code readInteger(T& value) { 255| 225| DeserializationError::Code err; 256| | 257| 225| err = readBytes(value); 258| 225| if (err) ------------------ | Branch (258:9): [True: 14, False: 211] ------------------ 259| 14| return err; 260| | 261| 211| fixEndianess(value); 262| | 263| 211| return DeserializationError::Ok; 264| 225| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIiEENS0_20DeserializationError4CodeERT_: 241| 225| DeserializationError::Code readBytes(T& value) { 242| 225| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 225| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIlEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 104| DeserializationError::Code readInteger(VariantData* variant) { 268| 104| DeserializationError::Code err; 269| 104| T value; 270| | 271| 104| err = readInteger(value); 272| 104| if (err) ------------------ | Branch (272:9): [True: 15, False: 89] ------------------ 273| 15| return err; 274| | 275| 89| variant->setInteger(value); 276| | 277| 89| return DeserializationError::Ok; 278| 104| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIlEENS0_20DeserializationError4CodeERT_: 254| 104| DeserializationError::Code readInteger(T& value) { 255| 104| DeserializationError::Code err; 256| | 257| 104| err = readBytes(value); 258| 104| if (err) ------------------ | Branch (258:9): [True: 15, False: 89] ------------------ 259| 15| return err; 260| | 261| 89| fixEndianess(value); 262| | 263| 89| return DeserializationError::Ok; 264| 104| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIlEENS0_20DeserializationError4CodeERT_: 241| 104| DeserializationError::Code readBytes(T& value) { 242| 104| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 104| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIhEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 332| 167| DeserializationError::Code readString(VariantData* variant) { 333| 167| DeserializationError::Code err; 334| 167| T size; 335| | 336| 167| err = readInteger(size); 337| 167| if (err) ------------------ | Branch (337:9): [True: 7, False: 160] ------------------ 338| 7| return err; 339| | 340| 160| return readString(variant, size); 341| 167| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringItEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 332| 298| DeserializationError::Code readString(VariantData* variant) { 333| 298| DeserializationError::Code err; 334| 298| T size; 335| | 336| 298| err = readInteger(size); 337| 298| if (err) ------------------ | Branch (337:9): [True: 13, False: 285] ------------------ 338| 13| return err; 339| | 340| 285| return readString(variant, size); 341| 298| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIjEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 332| 196| DeserializationError::Code readString(VariantData* variant) { 333| 196| DeserializationError::Code err; 334| 196| T size; 335| | 336| 196| err = readInteger(size); 337| 196| if (err) ------------------ | Branch (337:9): [True: 14, False: 182] ------------------ 338| 14| return err; 339| | 340| 182| return readString(variant, size); 341| 196| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayItNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 401| 367| DeserializationOption::NestingLimit nestingLimit) { 402| 367| DeserializationError::Code err; 403| 367| TSize size; 404| | 405| 367| err = readInteger(size); 406| 367| if (err) ------------------ | Branch (406:9): [True: 13, False: 354] ------------------ 407| 13| return err; 408| | 409| 354| return readArray(variant, size, filter, nestingLimit); 410| 367| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayIjNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 401| 196| DeserializationOption::NestingLimit nestingLimit) { 402| 196| DeserializationError::Code err; 403| 196| TSize size; 404| | 405| 196| err = readInteger(size); 406| 196| if (err) ------------------ | Branch (406:9): [True: 14, False: 182] ------------------ 407| 14| return err; 408| | 409| 182| return readArray(variant, size, filter, nestingLimit); 410| 196| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectItNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 456| 343| DeserializationOption::NestingLimit nestingLimit) { 457| 343| DeserializationError::Code err; 458| 343| TSize size; 459| | 460| 343| err = readInteger(size); 461| 343| if (err) ------------------ | Branch (461:9): [True: 13, False: 330] ------------------ 462| 13| return err; 463| | 464| 330| return readObject(variant, size, filter, nestingLimit); 465| 343| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectIjNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 456| 196| DeserializationOption::NestingLimit nestingLimit) { 457| 196| DeserializationError::Code err; 458| 196| TSize size; 459| | 460| 196| err = readInteger(size); 461| 196| if (err) ------------------ | Branch (461:9): [True: 14, False: 182] ------------------ 462| 14| return err; 463| | 464| 182| return readObject(variant, size, filter, nestingLimit); 465| 196| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 470| 1.94k| DeserializationOption::NestingLimit nestingLimit) { 471| 1.94k| DeserializationError::Code err; 472| | 473| 1.94k| if (nestingLimit.reached()) ------------------ | Branch (473:9): [True: 1, False: 1.94k] ------------------ 474| 1| return DeserializationError::TooDeep; 475| | 476| 1.94k| CollectionData* object; 477| 1.94k| if (filter.allowObject()) { ------------------ | Branch (477:9): [True: 1.94k, False: 0] ------------------ 478| 1.94k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 1.94k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 479| 0| object = &variant->toObject(); 480| 1.94k| } else { 481| 0| object = 0; 482| 0| } 483| | 484| 3.72k| for (; n; --n) { ------------------ | Branch (484:12): [True: 2.46k, False: 1.25k] ------------------ 485| 2.46k| err = readKey(); 486| 2.46k| if (err) ------------------ | Branch (486:11): [True: 302, False: 2.16k] ------------------ 487| 302| return err; 488| | 489| 2.16k| JsonString key = stringStorage_.str(); 490| 2.16k| TFilter memberFilter = filter[key.c_str()]; 491| 2.16k| VariantData* member; 492| | 493| 2.16k| if (memberFilter.allow()) { ------------------ | Branch (493:11): [True: 2.16k, False: 0] ------------------ 494| 2.16k| ARDUINOJSON_ASSERT(object != 0); ------------------ | | 11| 2.16k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 495| | 496| | // Save key in memory pool. 497| | // This MUST be done before adding the slot. 498| 0| key = stringStorage_.save(); 499| | 500| 2.16k| VariantSlot* slot = object->addSlot(pool_); 501| 2.16k| if (!slot) ------------------ | Branch (501:13): [True: 2, False: 2.15k] ------------------ 502| 2| return DeserializationError::NoMemory; 503| | 504| 2.15k| slot->setKey(key); 505| | 506| 2.15k| member = slot->data(); 507| 2.15k| } else { 508| 0| member = 0; 509| 0| } 510| | 511| 2.15k| err = parseVariant(member, memberFilter, nestingLimit.decrement()); 512| 2.15k| if (err) ------------------ | Branch (512:11): [True: 381, False: 1.77k] ------------------ 513| 381| return err; 514| 2.15k| } 515| | 516| 1.25k| return DeserializationError::Ok; 517| 1.94k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7readKeyEv: 519| 2.46k| DeserializationError::Code readKey() { 520| 2.46k| DeserializationError::Code err; 521| 2.46k| uint8_t code; 522| | 523| 2.46k| err = readByte(code); 524| 2.46k| if (err) ------------------ | Branch (524:9): [True: 71, False: 2.39k] ------------------ 525| 71| return err; 526| | 527| 2.39k| if ((code & 0xe0) == 0xa0) ------------------ | Branch (527:9): [True: 1.41k, False: 976] ------------------ 528| 1.41k| return readString(code & 0x1f); 529| | 530| 976| switch (code) { 531| 249| case 0xd9: ------------------ | Branch (531:7): [True: 249, False: 727] ------------------ 532| 249| return readString(); 533| | 534| 411| case 0xda: ------------------ | Branch (534:7): [True: 411, False: 565] ------------------ 535| 411| return readString(); 536| | 537| 311| case 0xdb: ------------------ | Branch (537:7): [True: 311, False: 665] ------------------ 538| 311| return readString(); 539| | 540| 5| default: ------------------ | Branch (540:7): [True: 5, False: 971] ------------------ 541| 5| return DeserializationError::InvalidInput; 542| 976| } 543| 976| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringEm: 378| 4.56k| DeserializationError::Code readString(size_t n) { 379| 4.56k| DeserializationError::Code err; 380| | 381| 4.56k| stringStorage_.startString(); 382| 10.6k| for (; n; --n) { ------------------ | Branch (382:12): [True: 6.34k, False: 4.31k] ------------------ 383| 6.34k| uint8_t c; 384| | 385| 6.34k| err = readBytes(c); 386| 6.34k| if (err) ------------------ | Branch (386:11): [True: 252, False: 6.09k] ------------------ 387| 252| return err; 388| | 389| 6.09k| stringStorage_.append(static_cast(c)); 390| 6.09k| } 391| | 392| 4.31k| if (!stringStorage_.isValid()) ------------------ | Branch (392:9): [True: 12, False: 4.30k] ------------------ 393| 12| return DeserializationError::NoMemory; 394| | 395| 4.30k| return DeserializationError::Ok; 396| 4.31k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIhEENS0_20DeserializationError4CodeEv: 344| 249| DeserializationError::Code readString() { 345| 249| DeserializationError::Code err; 346| 249| T size; 347| | 348| 249| err = readInteger(size); 349| 249| if (err) ------------------ | Branch (349:9): [True: 7, False: 242] ------------------ 350| 7| return err; 351| | 352| 242| return readString(size); 353| 249| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringItEENS0_20DeserializationError4CodeEv: 344| 411| DeserializationError::Code readString() { 345| 411| DeserializationError::Code err; 346| 411| T size; 347| | 348| 411| err = readInteger(size); 349| 411| if (err) ------------------ | Branch (349:9): [True: 13, False: 398] ------------------ 350| 13| return err; 351| | 352| 398| return readString(size); 353| 411| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIjEENS0_20DeserializationError4CodeEv: 344| 311| DeserializationError::Code readString() { 345| 311| DeserializationError::Code err; 346| 311| T size; 347| | 348| 311| err = readInteger(size); 349| 311| if (err) ------------------ | Branch (349:9): [True: 14, False: 297] ------------------ 350| 14| return err; 351| | 352| 297| return readString(size); 353| 311| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 415| 2.98k| DeserializationOption::NestingLimit nestingLimit) { 416| 2.98k| DeserializationError::Code err; 417| | 418| 2.98k| if (nestingLimit.reached()) ------------------ | Branch (418:9): [True: 2, False: 2.98k] ------------------ 419| 2| return DeserializationError::TooDeep; 420| | 421| 2.98k| bool allowArray = filter.allowArray(); 422| | 423| 2.98k| CollectionData* array; 424| 2.98k| if (allowArray) { ------------------ | Branch (424:9): [True: 2.98k, False: 0] ------------------ 425| 2.98k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 2.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 426| 0| array = &variant->toArray(); 427| 2.98k| } else { 428| 0| array = 0; 429| 0| } 430| | 431| 0| TFilter memberFilter = filter[0U]; 432| | 433| 18.1k| for (; n; --n) { ------------------ | Branch (433:12): [True: 16.3k, False: 1.81k] ------------------ 434| 16.3k| VariantData* value; 435| | 436| 16.3k| if (memberFilter.allow()) { ------------------ | Branch (436:11): [True: 16.3k, False: 0] ------------------ 437| 16.3k| ARDUINOJSON_ASSERT(array != 0); ------------------ | | 11| 16.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 438| 0| value = array->addElement(pool_); 439| 16.3k| if (!value) ------------------ | Branch (439:13): [True: 4, False: 16.3k] ------------------ 440| 4| return DeserializationError::NoMemory; 441| 16.3k| } else { 442| 0| value = 0; 443| 0| } 444| | 445| 16.3k| err = parseVariant(value, memberFilter, nestingLimit.decrement()); 446| 16.3k| if (err) ------------------ | Branch (446:11): [True: 1.16k, False: 15.2k] ------------------ 447| 1.16k| return err; 448| 16.3k| } 449| | 450| 1.81k| return DeserializationError::Ok; 451| 2.98k| } _ZN11ArduinoJson8V6213HB46detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringEPNS1_11VariantDataEm: 367| 2.21k| DeserializationError::Code readString(VariantData* variant, size_t n) { 368| 2.21k| DeserializationError::Code err; 369| | 370| 2.21k| err = readString(n); 371| 2.21k| if (err) ------------------ | Branch (371:9): [True: 72, False: 2.13k] ------------------ 372| 72| return err; 373| | 374| 2.13k| variant->setString(stringStorage_.save()); 375| 2.13k| return DeserializationError::Ok; 376| 2.21k| } _ZN11ArduinoJson8V6213HB416serializeMsgPackINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT_: 207| 616|inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) { 208| 616| using namespace ArduinoJson::detail; 209| 616| return serialize(source, output); 210| 616|} _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 22| 616| MsgPackSerializer(TWriter writer) : writer_(writer) {} _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitFloatIdEENS1_9enable_ifIXeqstT_Li8EEmE4typeESF_: 38| 464| typename enable_if::type visitFloat(T value64) { 39| 464| float value32 = float(value64); 40| 464| if (value32 == value64) ------------------ | Branch (40:9): [True: 387, False: 77] ------------------ 41| 387| return visitFloat(value32); 42| 77| writeByte(0xCB); 43| 77| writeInteger(value64); 44| 77| return bytesWritten(); 45| 464| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitFloatIfEENS1_9enable_ifIXeqstT_Li4EEmE4typeESF_: 25| 387| typename enable_if::type visitFloat(T value32) { 26| 387| if (canConvertNumber(value32)) { ------------------ | Branch (26:9): [True: 321, False: 66] ------------------ 27| 321| JsonInteger truncatedValue = JsonInteger(value32); 28| 321| if (value32 == T(truncatedValue)) ------------------ | Branch (28:11): [True: 255, False: 66] ------------------ 29| 255| return visitSignedInteger(truncatedValue); 30| 321| } 31| 132| writeByte(0xCA); 32| 132| writeInteger(value32); 33| 132| return bytesWritten(); 34| 387| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIfEEvT_: 192| 132| void writeInteger(T value) { 193| 132| fixEndianess(value); 194| 132| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 132| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeBytesEPKhm: 187| 3.19k| void writeBytes(const uint8_t* p, size_t n) { 188| 3.19k| writer_.write(p, n); 189| 3.19k| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeByteEh: 183| 3.59k| void writeByte(uint8_t c) { 184| 3.59k| writer_.write(c); 185| 3.59k| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIdEEvT_: 192| 77| void writeInteger(T value) { 193| 77| fixEndianess(value); 194| 77| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 77| } _ZNK11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 179| 5.23k| size_t bytesWritten() const { 180| 5.23k| return writer_.count(); 181| 5.23k| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitArrayERKNS1_14CollectionDataE: 47| 754| size_t visitArray(const CollectionData& array) { 48| 754| size_t n = array.size(); 49| 754| if (n < 0x10) { ------------------ | Branch (49:9): [True: 726, False: 28] ------------------ 50| 726| writeByte(uint8_t(0x90 + n)); 51| 726| } else if (n < 0x10000) { ------------------ | Branch (51:16): [True: 28, False: 0] ------------------ 52| 28| writeByte(0xDC); 53| 28| writeInteger(uint16_t(n)); 54| 28| } else { 55| 0| writeByte(0xDD); 56| 0| writeInteger(uint32_t(n)); 57| 0| } 58| 3.89k| for (const VariantSlot* slot = array.head(); slot; slot = slot->next()) { ------------------ | Branch (58:50): [True: 3.13k, False: 754] ------------------ 59| 3.13k| slot->data()->accept(*this); 60| 3.13k| } 61| 754| return bytesWritten(); 62| 754| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEEvT_: 192| 141| void writeInteger(T value) { 193| 141| fixEndianess(value); 194| 141| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 141| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEEvT_: 192| 116| void writeInteger(T value) { 193| 116| fixEndianess(value); 194| 116| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 116| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitObjectERKNS1_14CollectionDataE: 64| 333| size_t visitObject(const CollectionData& object) { 65| 333| size_t n = object.size(); 66| 333| if (n < 0x10) { ------------------ | Branch (66:9): [True: 321, False: 12] ------------------ 67| 321| writeByte(uint8_t(0x80 + n)); 68| 321| } else if (n < 0x10000) { ------------------ | Branch (68:16): [True: 12, False: 0] ------------------ 69| 12| writeByte(0xDE); 70| 12| writeInteger(uint16_t(n)); 71| 12| } else { 72| 0| writeByte(0xDF); 73| 0| writeInteger(uint32_t(n)); 74| 0| } 75| 792| for (const VariantSlot* slot = object.head(); slot; slot = slot->next()) { ------------------ | Branch (75:51): [True: 459, False: 333] ------------------ 76| 459| visitString(slot->key()); 77| 459| slot->data()->accept(*this); 78| 459| } 79| 333| return bytesWritten(); 80| 333| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitStringEPKc: 82| 459| size_t visitString(const char* value) { 83| 459| return visitString(value, strlen(value)); 84| 459| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitStringEPKcm: 86| 966| size_t visitString(const char* value, size_t n) { 87| 966| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 966|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 88| | 89| 966| if (n < 0x20) { ------------------ | Branch (89:9): [True: 942, False: 24] ------------------ 90| 942| writeByte(uint8_t(0xA0 + n)); 91| 942| } else if (n < 0x100) { ------------------ | Branch (91:16): [True: 24, False: 0] ------------------ 92| 24| writeByte(0xD9); 93| 24| writeInteger(uint8_t(n)); 94| 24| } else if (n < 0x10000) { ------------------ | Branch (94:16): [True: 0, False: 0] ------------------ 95| 0| writeByte(0xDA); 96| 0| writeInteger(uint16_t(n)); 97| 0| } else { 98| 0| writeByte(0xDB); 99| 0| writeInteger(uint32_t(n)); 100| 0| } 101| 966| writeBytes(reinterpret_cast(value), n); 102| 966| return bytesWritten(); 103| 966| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIhEEvT_: 192| 571| void writeInteger(T value) { 193| 571| fixEndianess(value); 194| 571| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 571| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE18visitSignedIntegerEl: 110| 1.59k| size_t visitSignedInteger(JsonInteger value) { 111| 1.59k| if (value > 0) { ------------------ | Branch (111:9): [True: 561, False: 1.03k] ------------------ 112| 561| visitUnsignedInteger(static_cast(value)); 113| 1.03k| } else if (value >= -0x20) { ------------------ | Branch (113:16): [True: 606, False: 430] ------------------ 114| 606| writeInteger(int8_t(value)); 115| 606| } else if (value >= -0x80) { ------------------ | Branch (115:16): [True: 75, False: 355] ------------------ 116| 75| writeByte(0xD0); 117| 75| writeInteger(int8_t(value)); 118| 355| } else if (value >= -0x8000) { ------------------ | Branch (118:16): [True: 90, False: 265] ------------------ 119| 90| writeByte(0xD1); 120| 90| writeInteger(int16_t(value)); 121| 90| } 122| 265|#if ARDUINOJSON_USE_LONG_LONG 123| 265| else if (value >= -0x80000000LL) ------------------ | Branch (123:14): [True: 107, False: 158] ------------------ 124| |#else 125| | else 126| |#endif 127| 107| { 128| 107| writeByte(0xD2); 129| 107| writeInteger(int32_t(value)); 130| 107| } 131| 158|#if ARDUINOJSON_USE_LONG_LONG 132| 158| else { 133| 158| writeByte(0xD3); 134| 158| writeInteger(int64_t(value)); 135| 158| } 136| 1.59k|#endif 137| 1.59k| return bytesWritten(); 138| 1.59k| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIaEEvT_: 192| 681| void writeInteger(T value) { 193| 681| fixEndianess(value); 194| 681| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 681| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEEvT_: 192| 90| void writeInteger(T value) { 193| 90| fixEndianess(value); 194| 90| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 90| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIiEEvT_: 192| 107| void writeInteger(T value) { 193| 107| fixEndianess(value); 194| 107| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 107| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEEvT_: 192| 158| void writeInteger(T value) { 193| 158| fixEndianess(value); 194| 158| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 158| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE20visitUnsignedIntegerEm: 140| 919| size_t visitUnsignedInteger(JsonUInt value) { 141| 919| if (value <= 0x7F) { ------------------ | Branch (141:9): [True: 472, False: 447] ------------------ 142| 472| writeInteger(uint8_t(value)); 143| 472| } else if (value <= 0xFF) { ------------------ | Branch (143:16): [True: 75, False: 372] ------------------ 144| 75| writeByte(0xCC); 145| 75| writeInteger(uint8_t(value)); 146| 372| } else if (value <= 0xFFFF) { ------------------ | Branch (146:16): [True: 101, False: 271] ------------------ 147| 101| writeByte(0xCD); 148| 101| writeInteger(uint16_t(value)); 149| 101| } 150| 271|#if ARDUINOJSON_USE_LONG_LONG 151| 271| else if (value <= 0xFFFFFFFF) ------------------ | Branch (151:14): [True: 116, False: 155] ------------------ 152| |#else 153| | else 154| |#endif 155| 116| { 156| 116| writeByte(0xCE); 157| 116| writeInteger(uint32_t(value)); 158| 116| } 159| 155|#if ARDUINOJSON_USE_LONG_LONG 160| 155| else { 161| 155| writeByte(0xCF); 162| 155| writeInteger(uint64_t(value)); 163| 155| } 164| 919|#endif 165| 919| return bytesWritten(); 166| 919| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEEvT_: 192| 155| void writeInteger(T value) { 193| 155| fixEndianess(value); 194| 155| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 155| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12visitBooleanEb: 168| 231| size_t visitBoolean(bool value) { 169| 231| writeByte(value ? 0xC3 : 0xC2); ------------------ | Branch (169:15): [True: 167, False: 64] ------------------ 170| 231| return bytesWritten(); 171| 231| } _ZN11ArduinoJson8V6213HB46detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9visitNullEv: 173| 222| size_t visitNull() { 174| 222| writeByte(0xC0); 175| 222| return bytesWritten(); 176| 222| } _ZN11ArduinoJson8V6213HB46detail12fixEndianessIhEEvRT_: 37| 1.59k|inline void fixEndianess(T& value) { 38| 1.59k| fixEndianess(reinterpret_cast(&value), 39| 1.59k| integral_constant()); 40| 1.59k|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessEPhNS1_17integral_constantImLm1EEE: 34| 2.42k|inline void fixEndianess(uint8_t*, integral_constant) {} _ZN11ArduinoJson8V6213HB46detail12fixEndianessItEEvRT_: 37| 2.42k|inline void fixEndianess(T& value) { 38| 2.42k| fixEndianess(reinterpret_cast(&value), 39| 2.42k| integral_constant()); 40| 2.42k|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessEPhNS1_17integral_constantImLm2EEE: 30| 2.87k|inline void fixEndianess(uint8_t* p, integral_constant) { 31| 2.87k| swapBytes(p[0], p[1]); 32| 2.87k|} _ZN11ArduinoJson8V6213HB46detail9swapBytesERhS2_: 12| 11.2k|inline void swapBytes(uint8_t& a, uint8_t& b) { 13| 11.2k| uint8_t t(a); 14| 11.2k| a = b; 15| 11.2k| b = t; 16| 11.2k|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIjEEvRT_: 37| 1.76k|inline void fixEndianess(T& value) { 38| 1.76k| fixEndianess(reinterpret_cast(&value), 39| 1.76k| integral_constant()); 40| 1.76k|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessEPhNS1_17integral_constantImLm4EEE: 25| 2.77k|inline void fixEndianess(uint8_t* p, integral_constant) { 26| 2.77k| swapBytes(p[0], p[3]); 27| 2.77k| swapBytes(p[1], p[2]); 28| 2.77k|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIfEEvRT_: 37| 688|inline void fixEndianess(T& value) { 38| 688| fixEndianess(reinterpret_cast(&value), 39| 688| integral_constant()); 40| 688|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIdEEvRT_: 37| 158|inline void fixEndianess(T& value) { 38| 158| fixEndianess(reinterpret_cast(&value), 39| 158| integral_constant()); 40| 158|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessEPhNS1_17integral_constantImLm8EEE: 18| 714|inline void fixEndianess(uint8_t* p, integral_constant) { 19| 714| swapBytes(p[0], p[7]); 20| 714| swapBytes(p[1], p[6]); 21| 714| swapBytes(p[2], p[5]); 22| 714| swapBytes(p[3], p[4]); 23| 714|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessImEEvRT_: 37| 309|inline void fixEndianess(T& value) { 38| 309| fixEndianess(reinterpret_cast(&value), 39| 309| integral_constant()); 40| 309|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIaEEvRT_: 37| 830|inline void fixEndianess(T& value) { 38| 830| fixEndianess(reinterpret_cast(&value), 39| 830| integral_constant()); 40| 830|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIsEEvRT_: 37| 452|inline void fixEndianess(T& value) { 38| 452| fixEndianess(reinterpret_cast(&value), 39| 452| integral_constant()); 40| 452|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIiEEvRT_: 37| 318|inline void fixEndianess(T& value) { 38| 318| fixEndianess(reinterpret_cast(&value), 39| 318| integral_constant()); 40| 318|} _ZN11ArduinoJson8V6213HB46detail12fixEndianessIlEEvRT_: 37| 247|inline void fixEndianess(T& value) { 38| 247| fixEndianess(reinterpret_cast(&value), 39| 247| integral_constant()); 40| 247|} _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIfLm4EE11highest_forIlEEfPNS1_9enable_ifIXaaaasr11is_integralIT_EE5valuesr9is_signedIS6_EE5valueeqstS6_Li8EEiE4typeE: 178| 321| signed>::type* = 0) { 179| 321| return forge(0x5EFFFFFF); // 9.22337148709896192E18 180| 321| } _ZN11ArduinoJson8V6213HB46detail11FloatTraitsIfLm4EE5forgeEj: 142| 321| static T forge(uint32_t bits) { 143| 321| return alias_cast(bits); 144| 321| } _ZN11ArduinoJson8V6213HB46detail16canConvertNumberIlfEENS1_9enable_ifIXaaaasr17is_floating_pointIT0_EE5valuesr11is_integralIT_EE5valuegestS5_stS4_EbE4typeES4_: 118| 387|canConvertNumber(TIn value) { 119| | // Avoid error "9.22337e+18 is outside the range of representable values of 120| | // type 'long'" 121| 387| return value >= numeric_limits::lowest() && ------------------ | Branch (121:10): [True: 321, False: 66] ------------------ 122| 387| value <= FloatTraits::template highest_for(); ------------------ | Branch (122:10): [True: 321, False: 0] ------------------ 123| 387|} _ZN11ArduinoJson8V6213HB46detail10alias_castIfjEET_T0_: 24| 321|T alias_cast(F raw_data) { 25| 321| alias_cast_t ac; 26| 321| ac.raw = raw_data; 27| 321| return ac.data; 28| 321|} _ZN11ArduinoJson8V6213HB46detail14numeric_limitsIivE6lowestEv: 33| 30.8k| static T lowest() { 34| 30.8k| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 30.8k| } _ZN11ArduinoJson8V6213HB46detail14numeric_limitsIivE7highestEv: 36| 15.4k| static T highest() { 37| 15.4k| return T(~lowest()); 38| 15.4k| } _ZN11ArduinoJson8V6213HB46detail14numeric_limitsIlvE6lowestEv: 33| 387| static T lowest() { 34| 387| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 387| } _ZN11ArduinoJson8V6213HB46detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 12| 1.96k|T&& forward(typename remove_reference::type& t) noexcept { 13| 1.96k| return static_cast(t); 14| 1.96k|} _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 616| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 3.19k| void write(const uint8_t* s, size_t n) { 21| 3.19k| count_ += writer_.write(s, n); 22| 3.19k| } _ZN11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 3.59k| void write(uint8_t c) { 17| 3.59k| count_ += writer_.write(c); 18| 3.59k| } _ZNK11ArduinoJson8V6213HB46detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 5.23k| size_t count() const { 25| 5.23k| return count_; 26| 5.23k| } _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 27| 616| Writer(TDestination& str) : str_(&str) {} _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 34| 3.19k| size_t write(const uint8_t* s, size_t n) { 35| 3.19k| str_->append(reinterpret_cast(s), n); 36| 3.19k| return n; 37| 3.19k| } _ZN11ArduinoJson8V6213HB46detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 29| 3.59k| size_t write(uint8_t c) { 30| 3.59k| str_->push_back(static_cast(c)); 31| 3.59k| return 1; 32| 3.59k| } _ZN11ArduinoJson8V6213HB46detail9serializeINS1_17MsgPackSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 20| 616| TDestination& destination) { 21| 616| Writer writer(destination); 22| 616| return doSerialize(source, writer); 23| 616|} _ZN11ArduinoJson8V6213HB46detail11doSerializeINS1_17MsgPackSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 13| 616|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 14| 616| TSerializer serializer(writer); 15| 616| return variantAccept(VariantAttorney::getData(source), serializer); 16| 616|} _ZN11ArduinoJson8V6213HB46detail12StringCopierC2EPNS1_10MemoryPoolE: 13| 1.96k| StringCopier(MemoryPool* pool) : pool_(pool) {} _ZN11ArduinoJson8V6213HB46detail12StringCopier11startStringEv: 15| 4.56k| void startString() { 16| 4.56k| pool_->getFreeZone(&ptr_, &capacity_); 17| 4.56k| size_ = 0; 18| 4.56k| if (capacity_ == 0) ------------------ | Branch (18:9): [True: 39, False: 4.52k] ------------------ 19| 39| pool_->markAsOverflowed(); 20| 4.56k| } _ZN11ArduinoJson8V6213HB46detail12StringCopier6appendEc: 39| 6.09k| void append(char c) { 40| 6.09k| if (size_ + 1 < capacity_) ------------------ | Branch (40:9): [True: 5.79k, False: 302] ------------------ 41| 5.79k| ptr_[size_++] = c; 42| 302| else 43| 302| pool_->markAsOverflowed(); 44| 6.09k| } _ZNK11ArduinoJson8V6213HB46detail12StringCopier7isValidEv: 46| 4.31k| bool isValid() const { 47| 4.31k| return !pool_->overflowed(); 48| 4.31k| } _ZNK11ArduinoJson8V6213HB46detail12StringCopier3strEv: 54| 2.16k| JsonString str() const { 55| 2.16k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 2.16k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 56| 2.16k| ARDUINOJSON_ASSERT(size_ < capacity_); ------------------ | | 11| 2.16k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 57| 0| ptr_[size_] = 0; 58| 2.16k| return JsonString(ptr_, size_, JsonString::Copied); 59| 2.16k| } _ZN11ArduinoJson8V6213HB46detail12StringCopier4saveEv: 22| 4.30k| JsonString save() { 23| 4.30k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 4.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 24| 4.30k| ARDUINOJSON_ASSERT(size_ < capacity_); // needs room for the terminator ------------------ | | 11| 4.30k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 25| 0| return JsonString(pool_->saveStringFromFreeZone(size_), size_, 26| 4.30k| JsonString::Copied); 27| 4.30k| } _ZN11ArduinoJson8V6213HB46detail17makeStringStorageIPKhEENS1_12StringCopierERT_PNS1_10MemoryPoolE: 13| 1.96k|StringCopier makeStringStorage(TInput&, MemoryPool* pool) { 14| 1.96k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 1.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 15| 0| return StringCopier(pool); 16| 1.96k|} _ZNK11ArduinoJson8V6213HB46detail14SizedRamString4sizeEv: 110| 25.2k| size_t size() const { 111| 25.2k| return size_; 112| 25.2k| } _ZNK11ArduinoJson8V6213HB46detail14SizedRamString6isNullEv: 106| 13.2k| bool isNull() const { 107| 13.2k| return !str_; 108| 13.2k| } _ZNK11ArduinoJson8V6213HB46detail14SizedRamStringixEm: 114| 7.76k| char operator[](size_t i) const { 115| 7.76k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 7.76k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 116| 7.76k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 7.76k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 117| 0| return str_[i]; 118| 7.76k| } _ZN11ArduinoJson8V6213HB46detail18SizedStringAdapterIPcvE5adaptEPKcm: 138| 10.9k| static AdaptedString adapt(const TChar* p, size_t n) { 139| 10.9k| return AdaptedString(reinterpret_cast(p), n); 140| 10.9k| } _ZN11ArduinoJson8V6213HB46detail14SizedRamStringC2EPKcm: 104| 10.9k| SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {} _ZN11ArduinoJson8V6213HB410JsonStringC2EPKcmNS1_9OwnershipE: 25| 6.46k| : data_(data), size_(sz), ownership_(ownership) {} _ZNK11ArduinoJson8V6213HB410JsonString5c_strEv: 28| 6.45k| const char* c_str() const { 29| 6.45k| return data_; 30| 6.45k| } _ZNK11ArduinoJson8V6213HB410JsonStringcvbEv: 49| 4.29k| explicit operator bool() const { 50| 4.29k| return data_ != 0; 51| 4.29k| } _ZNK11ArduinoJson8V6213HB410JsonString8isLinkedEv: 39| 4.29k| bool isLinked() const { 40| 4.29k| return ownership_ == Linked; 41| 4.29k| } _ZNK11ArduinoJson8V6213HB410JsonString4sizeEv: 44| 2.13k| size_t size() const { 45| 2.13k| return size_; 46| 2.13k| } _ZN11ArduinoJson8V6213HB46detail11adaptStringIcEENS1_18SizedStringAdapterIPT_vE13AdaptedStringES5_m: 27| 10.9k| size_t n) { 28| 10.9k| return SizedStringAdapter::adapt(p, n); 29| 10.9k|} _ZN11ArduinoJson8V6213HB46detail12stringEqualsINS1_14SizedRamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 48| 6.60k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 49| 6.60k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 6.60k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 50| 6.60k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 6.60k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 51| 0| size_t size1 = s1.size(); 52| 6.60k| size_t size2 = s2.size(); 53| 6.60k| if (size1 != size2) ------------------ | Branch (53:7): [True: 0, False: 6.60k] ------------------ 54| 0| return false; 55| 7.34k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (55:22): [True: 3.88k, False: 3.46k] ------------------ 56| 3.88k| if (s1[i] != s2[i]) ------------------ | Branch (56:9): [True: 3.14k, False: 741] ------------------ 57| 3.14k| return false; 58| 3.88k| } 59| 3.46k| return true; 60| 6.60k|} _ZN11ArduinoJson8V6213HB416JsonVariantConstC2EPKNS0_6detail11VariantDataE: 36| 616| explicit JsonVariantConst(const detail::VariantData* data) : data_(data) {} _ZNK11ArduinoJson8V6213HB416JsonVariantConst7getDataEv: 136| 616| const detail::VariantData* getData() const { 137| 616| return data_; 138| 616| } _ZN11ArduinoJson8V6213HB46detail8slotDataEPNS1_11VariantSlotE: 42| 16.3k|inline VariantData* slotData(VariantSlot* slot) { 43| 16.3k| return reinterpret_cast(slot); 44| 16.3k|} _ZN11ArduinoJson8V6213HB46detail8slotSizeEPKNS1_11VariantSlotE: 33| 1.08k|inline size_t slotSize(const VariantSlot* var) { 34| 1.08k| size_t n = 0; 35| 4.68k| while (var) { ------------------ | Branch (35:10): [True: 3.59k, False: 1.08k] ------------------ 36| 3.59k| n++; 37| 3.59k| var = var->next(); 38| 3.59k| } 39| 1.08k| return n; 40| 1.08k|} _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getDataINS0_12JsonDocumentEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 1.96k| TClient& client) { 39| 1.96k| return client.getData(); 40| 1.96k| } _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getPoolINS0_12JsonDocumentEEEPNS1_10MemoryPoolERT_: 32| 1.96k| FORCE_INLINE static MemoryPool* getPool(TClient& client) { 33| 1.96k| return client.getPool(); 34| 1.96k| } _ZN11ArduinoJson8V6213HB46detail15VariantAttorney7getDataINS0_16JsonVariantConstEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 616| TClient& client) { 39| 616| return client.getData(); 40| 616| } _ZN11ArduinoJson8V6213HB46detail11VariantDataC2Ev: 21| 1.96k| VariantData() : flags_(VALUE_IS_NULL) {} _ZN11ArduinoJson8V6213HB46detail11VariantData7setNullEv: 199| 1.96k| void setNull() { 200| 1.96k| setType(VALUE_IS_NULL); 201| 1.96k| } _ZN11ArduinoJson8V6213HB46detail11VariantData7setTypeEh: 302| 18.9k| void setType(uint8_t t) { 303| 18.9k| flags_ &= OWNED_KEY_BIT; 304| 18.9k| flags_ |= t; 305| 18.9k| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setBooleanEb: 153| 577| void setBoolean(bool value) { 154| 577| setType(VALUE_IS_BOOLEAN); 155| 577| content_.asBoolean = value; 156| 577| } _ZN11ArduinoJson8V6213HB46detail11VariantData8setFloatEd: 158| 637| void setFloat(JsonFloat value) { 159| 637| setType(VALUE_IS_FLOAT); 160| 637| content_.asFloat = value; 161| 637| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIhEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 181| typename enable_if::value>::type setInteger(T value) { 189| 181| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 181| content_.asUnsignedInteger = static_cast(value); 191| 181| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerItEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 305| typename enable_if::value>::type setInteger(T value) { 189| 305| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 305| content_.asUnsignedInteger = static_cast(value); 191| 305| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIjEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 222| typename enable_if::value>::type setInteger(T value) { 189| 222| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 222| content_.asUnsignedInteger = static_cast(value); 191| 222| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 154| typename enable_if::value>::type setInteger(T value) { 189| 154| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 154| content_.asUnsignedInteger = static_cast(value); 191| 154| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIsEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 362| typename enable_if::value>::type setInteger(T value) { 195| 362| setType(VALUE_IS_SIGNED_INTEGER); 196| 362| content_.asSignedInteger = value; 197| 362| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIiEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 211| typename enable_if::value>::type setInteger(T value) { 195| 211| setType(VALUE_IS_SIGNED_INTEGER); 196| 211| content_.asSignedInteger = value; 197| 211| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 89| typename enable_if::value>::type setInteger(T value) { 195| 89| setType(VALUE_IS_SIGNED_INTEGER); 196| 89| content_.asSignedInteger = value; 197| 89| } _ZN11ArduinoJson8V6213HB46detail11VariantData8toObjectEv: 219| 1.94k| CollectionData& toObject() { 220| 1.94k| setType(VALUE_IS_OBJECT); 221| 1.94k| content_.asCollection.clear(); 222| 1.94k| return content_.asCollection; 223| 1.94k| } _ZN11ArduinoJson8V6213HB46detail11VariantData7toArrayEv: 213| 2.98k| CollectionData& toArray() { 214| 2.98k| setType(VALUE_IS_ARRAY); 215| 2.98k| content_.asCollection.clear(); 216| 2.98k| return content_.asCollection; 217| 2.98k| } _ZN11ArduinoJson8V6213HB46detail11VariantData9setStringENS0_10JsonStringE: 203| 2.13k| void setString(JsonString s) { 204| 2.13k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 2.13k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 205| 2.13k| if (s.isLinked()) ------------------ | Branch (205:9): [True: 0, False: 2.13k] ------------------ 206| 0| setType(VALUE_IS_LINKED_STRING); 207| 2.13k| else 208| 2.13k| setType(VALUE_IS_OWNED_STRING); 209| 2.13k| content_.asString.data = s.c_str(); 210| 2.13k| content_.asString.size = s.size(); 211| 2.13k| } _ZN11ArduinoJson8V6213HB46detail11VariantData10setIntegerIaEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 7.15k| typename enable_if::value>::type setInteger(T value) { 195| 7.15k| setType(VALUE_IS_SIGNED_INTEGER); 196| 7.15k| content_.asSignedInteger = value; 197| 7.15k| } _ZNK11ArduinoJson8V6213HB46detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_: 29| 4.21k| typename TVisitor::result_type accept(TVisitor& visitor) const { 30| 4.21k| switch (type()) { 31| 464| case VALUE_IS_FLOAT: ------------------ | Branch (31:7): [True: 464, False: 3.74k] ------------------ 32| 464| return visitor.visitFloat(content_.asFloat); 33| | 34| 754| case VALUE_IS_ARRAY: ------------------ | Branch (34:7): [True: 754, False: 3.45k] ------------------ 35| 754| return visitor.visitArray(content_.asCollection); 36| | 37| 333| case VALUE_IS_OBJECT: ------------------ | Branch (37:7): [True: 333, False: 3.87k] ------------------ 38| 333| return visitor.visitObject(content_.asCollection); 39| | 40| 0| case VALUE_IS_LINKED_STRING: ------------------ | Branch (40:7): [True: 0, False: 4.21k] ------------------ 41| 507| case VALUE_IS_OWNED_STRING: ------------------ | Branch (41:7): [True: 507, False: 3.70k] ------------------ 42| 507| return visitor.visitString(content_.asString.data, 43| 507| content_.asString.size); 44| | 45| 0| case VALUE_IS_OWNED_RAW: ------------------ | Branch (45:7): [True: 0, False: 4.21k] ------------------ 46| 0| case VALUE_IS_LINKED_RAW: ------------------ | Branch (46:7): [True: 0, False: 4.21k] ------------------ 47| 0| return visitor.visitRawJson(content_.asString.data, 48| 0| content_.asString.size); 49| | 50| 1.34k| case VALUE_IS_SIGNED_INTEGER: ------------------ | Branch (50:7): [True: 1.34k, False: 2.86k] ------------------ 51| 1.34k| return visitor.visitSignedInteger(content_.asSignedInteger); 52| | 53| 358| case VALUE_IS_UNSIGNED_INTEGER: ------------------ | Branch (53:7): [True: 358, False: 3.85k] ------------------ 54| 358| return visitor.visitUnsignedInteger(content_.asUnsignedInteger); 55| | 56| 231| case VALUE_IS_BOOLEAN: ------------------ | Branch (56:7): [True: 231, False: 3.98k] ------------------ 57| 231| return visitor.visitBoolean(content_.asBoolean != 0); 58| | 59| 222| default: ------------------ | Branch (59:7): [True: 222, False: 3.98k] ------------------ 60| 222| return visitor.visitNull(); 61| 4.21k| } 62| 4.21k| } _ZNK11ArduinoJson8V6213HB46detail11VariantData4typeEv: 287| 4.21k| uint8_t type() const { 288| 4.21k| return flags_ & VALUE_MASK; 289| 4.21k| } _ZN11ArduinoJson8V6213HB46detail13variantAcceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEEENT_11result_typeEPKNS1_11VariantDataERSE_: 16| 616| TVisitor& visitor) { 17| 616| if (var != 0) ------------------ | Branch (17:7): [True: 616, False: 0] ------------------ 18| 616| return var->accept(visitor); 19| 0| else 20| 0| return visitor.visitNull(); 21| 616|} _ZN11ArduinoJson8V6213HB46detail11VariantSlot14setNextNotNullEPS2_: 70| 15.4k| void setNextNotNull(VariantSlot* slot) { 71| 15.4k| ARDUINOJSON_ASSERT(slot != 0); ------------------ | | 11| 15.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 72| 15.4k| ARDUINOJSON_ASSERT(slot - this >= ------------------ | | 11| 15.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 73| 0| numeric_limits::lowest()); 74| 15.4k| ARDUINOJSON_ASSERT(slot - this <= ------------------ | | 11| 15.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 75| 0| numeric_limits::highest()); 76| 0| next_ = VariantSlotDiff(slot - this); 77| 15.4k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot5clearEv: 96| 18.5k| void clear() { 97| 18.5k| next_ = 0; 98| 18.5k| flags_ = 0; 99| 18.5k| key_ = 0; 100| 18.5k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot6setKeyENS0_10JsonStringE: 79| 2.15k| void setKey(JsonString k) { 80| 2.15k| ARDUINOJSON_ASSERT(k); ------------------ | | 11| 2.15k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 81| 2.15k| if (k.isLinked()) ------------------ | Branch (81:9): [True: 0, False: 2.15k] ------------------ 82| 0| flags_ &= VALUE_MASK; 83| 2.15k| else 84| 2.15k| flags_ |= OWNED_KEY_BIT; 85| 2.15k| key_ = k.c_str(); 86| 2.15k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot4dataEv: 32| 2.15k| VariantData* data() { 33| 2.15k| return reinterpret_cast(&content_); 34| 2.15k| } _ZNK11ArduinoJson8V6213HB46detail11VariantSlot4dataEv: 36| 3.59k| const VariantData* data() const { 37| 3.59k| return reinterpret_cast(&content_); 38| 3.59k| } _ZNK11ArduinoJson8V6213HB46detail11VariantSlot4nextEv: 44| 7.19k| const VariantSlot* next() const { 45| 7.19k| return const_cast(this)->next(); 46| 7.19k| } _ZN11ArduinoJson8V6213HB46detail11VariantSlot4nextEv: 40| 7.19k| VariantSlot* next() { 41| 7.19k| return next_ ? this + next_ : 0; ------------------ | Branch (41:12): [True: 6.05k, False: 1.13k] ------------------ 42| 7.19k| } _ZNK11ArduinoJson8V6213HB46detail11VariantSlot3keyEv: 88| 459| const char* key() const { 89| 459| return key_; 90| 459| } LLVMFuzzerTestOneInput: 3| 1.96k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 1.96k| DynamicJsonDocument doc(4096); 5| 1.96k| DeserializationError error = deserializeMsgPack(doc, data, size); 6| 1.96k| if (!error) { ------------------ | Branch (6:7): [True: 616, False: 1.34k] ------------------ 7| 616| std::string json; 8| 616| serializeMsgPack(doc, json); 9| 616| } 10| 1.96k| return 0; 11| 1.96k|}