_ZNK11ArduinoJson7V6212HB6detail14CollectionData4headEv: 69| 1.09k| VariantSlot* head() const { 70| 1.09k| return head_; 71| 1.09k| } _ZN11ArduinoJson7V6212HB6detail14CollectionData5clearEv: 47| 4.82k|inline void CollectionData::clear() { 48| 4.82k| head_ = 0; 49| 4.82k| tail_ = 0; 50| 4.82k|} _ZN11ArduinoJson7V6212HB6detail14CollectionData7addSlotEPNS1_10MemoryPoolE: 14| 19.3k|inline VariantSlot* CollectionData::addSlot(MemoryPool* pool) { 15| 19.3k| VariantSlot* slot = pool->allocVariant(); 16| 19.3k| if (!slot) ------------------ | Branch (16:7): [True: 5, False: 19.3k] ------------------ 17| 5| return 0; 18| | 19| 19.3k| if (tail_) { ------------------ | Branch (19:7): [True: 16.4k, False: 2.81k] ------------------ 20| 16.4k| ARDUINOJSON_ASSERT(pool->owns(tail_)); // Can't alter a linked array/object ------------------ | | 11| 16.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 21| 0| tail_->setNextNotNull(slot); 22| 16.4k| tail_ = slot; 23| 16.4k| } else { 24| 2.81k| head_ = slot; 25| 2.81k| tail_ = slot; 26| 2.81k| } 27| | 28| 0| slot->clear(); 29| 19.3k| return slot; 30| 19.3k|} _ZN11ArduinoJson7V6212HB6detail14CollectionData10addElementEPNS1_10MemoryPoolE: 32| 16.9k|inline VariantData* CollectionData::addElement(MemoryPool* pool) { 33| 16.9k| return slotData(addSlot(pool)); 34| 16.9k|} _ZNK11ArduinoJson7V6212HB6detail14CollectionData4sizeEv: 176| 1.82k|inline size_t CollectionData::size() const { 177| 1.82k| return slotSize(head_); 178| 1.82k|} _ZNK11ArduinoJson7V6212HB20DeserializationErrorcvbEv: 56| 1.98k| explicit operator bool() const { 57| 1.98k| return code_ != Ok; 58| 1.98k| } _ZN11ArduinoJson7V6212HB20DeserializationErrorC2ENS1_4CodeE: 29| 1.98k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson7V6212HB6detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 1.98k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 1.98k| return {{}, nestingLimit}; 33| 1.98k|} _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilter10allowValueEv: 59| 20.9k| bool allowValue() const { 60| 20.9k| return true; 61| 20.9k| } _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilter11allowObjectEv: 55| 1.83k| bool allowObject() const { 56| 1.83k| return true; 57| 1.83k| } _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilterixIPKcEES2_RKT_: 64| 2.38k| AllowAllFilter operator[](const TKey&) const { 65| 2.38k| return AllowAllFilter(); 66| 2.38k| } _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilter5allowEv: 47| 19.3k| bool allow() const { 48| 19.3k| return true; 49| 19.3k| } _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilter10allowArrayEv: 51| 2.99k| bool allowArray() const { 52| 2.99k| return true; 53| 2.99k| } _ZNK11ArduinoJson7V6212HB6detail14AllowAllFilterixIjEES2_RKT_: 64| 2.99k| AllowAllFilter operator[](const TKey&) const { 65| 2.99k| return AllowAllFilter(); 66| 2.99k| } _ZN11ArduinoJson7V6212HB21DeserializationOption12NestingLimitC2Ev: 15| 1.98k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} _ZNK11ArduinoJson7V6212HB21DeserializationOption12NestingLimit7reachedEv: 23| 4.83k| bool reached() const { 24| 4.83k| return value_ == 0; 25| 4.83k| } _ZNK11ArduinoJson7V6212HB21DeserializationOption12NestingLimit9decrementEv: 18| 19.3k| NestingLimit decrement() const { 19| 19.3k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 19.3k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 0| return NestingLimit(static_cast(value_ - 1)); 21| 19.3k| } _ZN11ArduinoJson7V6212HB21DeserializationOption12NestingLimitC2Eh: 16| 19.3k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson7V6212HB6detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 69| 1.98k|BoundedReader makeReader(TChar* input, size_t inputSize) { 70| 1.98k| return BoundedReader{input, inputSize}; 71| 1.98k|} _ZN11ArduinoJson7V6212HB6detail14IteratorReaderIPKcEC2ES4_S4_: 15| 1.98k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson7V6212HB6detail14IteratorReaderIPKcE4readEv: 17| 29.1k| int read() { 18| 29.1k| if (ptr_ < end_) ------------------ | Branch (18:9): [True: 28.4k, False: 759] ------------------ 19| 28.4k| return static_cast(*ptr_++); 20| 759| else 21| 759| return -1; 22| 29.1k| } _ZN11ArduinoJson7V6212HB6detail14IteratorReaderIPKcE9readBytesEPcm: 24| 13.2k| size_t readBytes(char* buffer, size_t length) { 25| 13.2k| size_t i = 0; 26| 38.4k| while (i < length && ptr_ < end_) ------------------ | Branch (26:12): [True: 25.8k, False: 12.6k] | Branch (26:26): [True: 25.2k, False: 594] ------------------ 27| 25.2k| buffer[i++] = *ptr_++; 28| 13.2k| return i; 29| 13.2k| } _ZN11ArduinoJson7V6212HB6detail13BoundedReaderIPKhvEC2EPKvm: 48| 1.98k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson7V6212HB6detail11deserializeINS1_19MsgPackDeserializerEKhmJEvEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT0_T1_DpT2_: 55| 1.98k| Size inputSize, Args... args) { 56| 1.98k| auto reader = makeReader(input, size_t(inputSize)); 57| 1.98k| auto data = VariantAttorney::getData(doc); 58| 1.98k| auto pool = VariantAttorney::getPool(doc); 59| 1.98k| auto options = makeDeserializationOptions(args...); 60| 1.98k| doc.clear(); 61| 1.98k| return makeDeserializer(pool, reader, 62| 1.98k| makeStringStorage(input, pool)) 63| 1.98k| .parse(*data, options.filter, options.nestingLimit); 64| 1.98k|} _ZN11ArduinoJson7V6212HB6detail16makeDeserializerINS1_19MsgPackDeserializerENS1_13BoundedReaderIPKhvEENS1_12StringCopierEEET_IT0_T1_EPNS1_10MemoryPoolESA_SB_: 30| 1.98k| TWriter writer) { 31| 1.98k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 1.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 0| return TDeserializer(pool, reader, writer); 33| 1.98k|} _ZN11ArduinoJson7V6212HB17BasicJsonDocumentINS0_16DefaultAllocatorEEC2EmS2_: 46| 1.98k| : AllocatorOwner(alloc), JsonDocument(allocPool(capa)) {} _ZN11ArduinoJson7V6212HB14AllocatorOwnerINS0_16DefaultAllocatorEEC2ES2_: 17| 1.98k| AllocatorOwner(TAllocator a) : allocator_(a) {} _ZN11ArduinoJson7V6212HB17BasicJsonDocumentINS0_16DefaultAllocatorEE9allocPoolEm: 137| 1.98k| detail::MemoryPool allocPool(size_t requiredSize) { 138| 1.98k| size_t capa = detail::addPadding(requiredSize); 139| 1.98k| return {reinterpret_cast(this->allocate(capa)), capa}; 140| 1.98k| } _ZN11ArduinoJson7V6212HB14AllocatorOwnerINS0_16DefaultAllocatorEE8allocateEm: 19| 1.98k| void* allocate(size_t size) { 20| 1.98k| return allocator_.allocate(size); 21| 1.98k| } _ZN11ArduinoJson7V6212HB17BasicJsonDocumentINS0_16DefaultAllocatorEED2Ev: 83| 1.98k| ~BasicJsonDocument() { 84| 1.98k| freePool(); 85| 1.98k| } _ZN11ArduinoJson7V6212HB17BasicJsonDocumentINS0_16DefaultAllocatorEE8freePoolEv: 150| 1.98k| void freePool() { 151| 1.98k| this->deallocate(getPool()->buffer()); 152| 1.98k| } _ZN11ArduinoJson7V6212HB14AllocatorOwnerINS0_16DefaultAllocatorEE10deallocateEPv: 23| 1.98k| void deallocate(void* ptr) { 24| 1.98k| if (ptr) ------------------ | Branch (24:9): [True: 1.98k, False: 0] ------------------ 25| 1.98k| allocator_.deallocate(ptr); 26| 1.98k| } _ZN11ArduinoJson7V6212HB16DefaultAllocator8allocateEm: 15| 1.98k| void* allocate(size_t size) { 16| 1.98k| return malloc(size); 17| 1.98k| } _ZN11ArduinoJson7V6212HB16DefaultAllocator10deallocateEPv: 19| 1.98k| void deallocate(void* ptr) { 20| 1.98k| free(ptr); 21| 1.98k| } _ZNK11ArduinoJson7V6212HB12JsonDocumentcvNS0_16JsonVariantConstEEv: 275| 603| FORCE_INLINE operator JsonVariantConst() const { 276| 603| return getVariant(); 277| 603| } _ZNK11ArduinoJson7V6212HB12JsonDocument10getVariantEv: 296| 603| JsonVariantConst getVariant() const { 297| 603| return JsonVariantConst(&data_); 298| 603| } _ZN11ArduinoJson7V6212HB12JsonDocumentC2ENS0_6detail10MemoryPoolE: 282| 1.98k| JsonDocument(detail::MemoryPool pool) : pool_(pool) {} _ZN11ArduinoJson7V6212HB12JsonDocument7getPoolEv: 304| 3.97k| detail::MemoryPool* getPool() { 305| 3.97k| return &pool_; 306| 3.97k| } _ZN11ArduinoJson7V6212HB12JsonDocumentD2Ev: 286| 1.98k| ~JsonDocument() {} _ZN11ArduinoJson7V6212HB12JsonDocument7getDataEv: 308| 1.98k| detail::VariantData* getData() { 309| 1.98k| return &data_; 310| 1.98k| } _ZN11ArduinoJson7V6212HB12JsonDocument5clearEv: 42| 1.98k| void clear() { 43| 1.98k| pool_.clear(); 44| 1.98k| data_.setNull(); 45| 1.98k| } _ZN11ArduinoJson7V6212HB6detail10addPaddingEm: 21| 1.98k|inline size_t addPadding(size_t bytes) { 22| 1.98k| const size_t mask = sizeof(void*) - 1; 23| 1.98k| return (bytes + mask) & ~mask; 24| 1.98k|} _ZN11ArduinoJson7V6212HB6detail9isAlignedIcEEbPT_: 50| 6.76k|inline bool isAligned(T* ptr) { 51| 6.76k| return isAligned(reinterpret_cast(ptr)); 52| 6.76k|} _ZN11ArduinoJson7V6212HB6detail9isAlignedEm: 15| 6.76k|inline bool isAligned(size_t value) { 16| 6.76k| const size_t mask = sizeof(void*) - 1; 17| 6.76k| size_t addr = value; 18| 6.76k| return (addr & mask) == 0; 19| 6.76k|} _ZN11ArduinoJson7V6212HB6detail10MemoryPoolC2EPcm: 44| 1.98k| overflowed_(false) { 45| 1.98k| ARDUINOJSON_ASSERT(isAligned(begin_)); ------------------ | | 11| 1.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 46| 1.98k| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 1.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 1.98k| ARDUINOJSON_ASSERT(isAligned(end_)); ------------------ | | 11| 1.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 1.98k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool6bufferEv: 50| 1.98k| void* buffer() { 51| 1.98k| return begin_; // NOLINT(clang-analyzer-unix.Malloc) 52| | // movePointers() alters this pointer 53| 1.98k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool5clearEv: 116| 1.98k| void clear() { 117| 1.98k| left_ = begin_; 118| 1.98k| right_ = end_; 119| 1.98k| overflowed_ = false; 120| 1.98k| } _ZNK11ArduinoJson7V6212HB6detail10MemoryPool11getFreeZoneEPPcPm: 93| 5.16k| void getFreeZone(char** zoneStart, size_t* zoneSize) const { 94| 5.16k| *zoneStart = left_; 95| 5.16k| *zoneSize = size_t(right_ - left_); 96| 5.16k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool16markAsOverflowedEv: 112| 341| void markAsOverflowed() { 113| 341| overflowed_ = true; 114| 341| } _ZNK11ArduinoJson7V6212HB6detail10MemoryPool10overflowedEv: 64| 4.88k| bool overflowed() const { 65| 4.88k| return overflowed_; 66| 4.88k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool22saveStringFromFreeZoneEm: 98| 4.87k| const char* saveStringFromFreeZone(size_t len) { 99| 4.87k|#if ARDUINOJSON_ENABLE_STRING_DEDUPLICATION 100| 4.87k| const char* dup = findString(adaptString(left_, len)); 101| 4.87k| if (dup) ------------------ | Branch (101:9): [True: 4.06k, False: 811] ------------------ 102| 4.06k| return dup; 103| 811|#endif 104| | 105| 811| const char* str = left_; 106| 811| left_ += len; 107| 811| *left_++ = 0; 108| 811| checkInvariants(); 109| 811| return str; 110| 4.87k| } _ZNK11ArduinoJson7V6212HB6detail10MemoryPool10findStringINS1_14SizedRamStringEEEPKcRKT_: 179| 4.87k| const char* findString(const TAdaptedString& str) const { 180| 4.87k| size_t n = str.size(); 181| 8.21k| for (char* next = begin_; next + n < left_; ++next) { ------------------ | Branch (181:31): [True: 7.40k, False: 811] ------------------ 182| 7.40k| if (next[n] == '\0' && stringEquals(str, adaptString(next, n))) ------------------ | Branch (182:11): [True: 6.64k, False: 757] | Branch (182:11): [True: 4.06k, False: 3.34k] | Branch (182:30): [True: 4.06k, False: 2.58k] ------------------ 183| 4.06k| return next; 184| | 185| | // jump to next terminator 186| 6.90k| while (*next) ------------------ | Branch (186:14): [True: 3.56k, False: 3.34k] ------------------ 187| 3.56k| ++next; 188| 3.34k| } 189| 811| return 0; 190| 4.87k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool15checkInvariantsEv: 170| 811| void checkInvariants() { 171| 811| ARDUINOJSON_ASSERT(begin_ <= left_); ------------------ | | 11| 811|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 172| 811| ARDUINOJSON_ASSERT(left_ <= right_); ------------------ | | 11| 811|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 173| 811| ARDUINOJSON_ASSERT(right_ <= end_); ------------------ | | 11| 811|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 174| 811| ARDUINOJSON_ASSERT(isAligned(right_)); ------------------ | | 11| 811|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 175| 811| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool12allocVariantEv: 68| 19.3k| VariantSlot* allocVariant() { 69| 19.3k| return allocRight(); 70| 19.3k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool10allocRightINS1_11VariantSlotEEEPT_v: 205| 19.3k| T* allocRight() { 206| 19.3k| return reinterpret_cast(allocRight(sizeof(T))); 207| 19.3k| } _ZN11ArduinoJson7V6212HB6detail10MemoryPool10allocRightEm: 209| 19.3k| void* allocRight(size_t bytes) { 210| 19.3k| if (!canAlloc(bytes)) { ------------------ | Branch (210:9): [True: 5, False: 19.3k] ------------------ 211| 5| overflowed_ = true; 212| 5| return 0; 213| 5| } 214| 19.3k| right_ -= bytes; 215| 19.3k| return right_; 216| 19.3k| } _ZNK11ArduinoJson7V6212HB6detail10MemoryPool8canAllocEm: 122| 19.3k| bool canAlloc(size_t bytes) const { 123| 19.3k| return left_ + bytes <= right_; 124| 19.3k| } _ZNK11ArduinoJson7V6212HB6detail10MemoryPool4ownsEPv: 126| 16.4k| bool owns(void* p) const { 127| 16.4k| return begin_ <= p && p < end_; ------------------ | Branch (127:12): [True: 16.4k, False: 0] | Branch (127:27): [True: 16.4k, False: 0] ------------------ 128| 16.4k| } _ZN11ArduinoJson7V6212HB18deserializeMsgPackIKhJRmEEENS0_20DeserializationErrorERNS0_12JsonDocumentEPT_DpOT0_: 579| 1.98k| Args&&... args) { 580| 1.98k| using namespace detail; 581| 1.98k| return deserialize(doc, input, 582| 1.98k| detail::forward(args)...); 583| 1.98k|} _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEEC2EPNS1_10MemoryPoolES6_S7_: 24| 1.98k| foundSomething_(false) {} _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 28| 1.98k| DeserializationOption::NestingLimit nestingLimit) { 29| 1.98k| DeserializationError::Code err; 30| 1.98k| err = parseVariant(&variant, filter, nestingLimit); 31| 1.98k| return foundSomething_ ? err : DeserializationError::EmptyInput; ------------------ | Branch (31:12): [True: 1.98k, False: 0] ------------------ 32| 1.98k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 38| 21.3k| DeserializationOption::NestingLimit nestingLimit) { 39| 21.3k| DeserializationError::Code err; 40| | 41| 21.3k| uint8_t code = 0; // TODO: why do we need to initialize this variable? 42| 21.3k| err = readByte(code); 43| 21.3k| if (err) ------------------ | Branch (43:9): [True: 379, False: 20.9k] ------------------ 44| 379| return err; 45| | 46| 20.9k| foundSomething_ = true; 47| | 48| 20.9k| bool allowValue = filter.allowValue(); 49| | 50| 20.9k| if (allowValue) { ------------------ | Branch (50:9): [True: 20.9k, False: 0] ------------------ 51| | // callers pass a null pointer only when value must be ignored 52| 20.9k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 20.9k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 53| 20.9k| } 54| | 55| 0| switch (code) { ------------------ | Branch (55:13): [True: 13.2k, False: 7.65k] ------------------ 56| 402| case 0xc0: ------------------ | Branch (56:7): [True: 402, False: 20.5k] ------------------ 57| | // already null 58| 402| return DeserializationError::Ok; 59| | 60| 3| case 0xc1: ------------------ | Branch (60:7): [True: 3, False: 20.9k] ------------------ 61| 3| return DeserializationError::InvalidInput; 62| | 63| 389| case 0xc2: ------------------ | Branch (63:7): [True: 389, False: 20.5k] ------------------ 64| 389| if (allowValue) ------------------ | Branch (64:13): [True: 389, False: 0] ------------------ 65| 389| variant->setBoolean(false); 66| 389| return DeserializationError::Ok; 67| | 68| 217| case 0xc3: ------------------ | Branch (68:7): [True: 217, False: 20.7k] ------------------ 69| 217| if (allowValue) ------------------ | Branch (69:13): [True: 217, False: 0] ------------------ 70| 217| variant->setBoolean(true); 71| 217| return DeserializationError::Ok; 72| | 73| 224| case 0xc4: // bin 8 (not supported) ------------------ | Branch (73:7): [True: 224, False: 20.6k] ------------------ 74| 224| return skipString(); 75| | 76| 392| case 0xc5: // bin 16 (not supported) ------------------ | Branch (76:7): [True: 392, False: 20.5k] ------------------ 77| 392| return skipString(); 78| | 79| 309| case 0xc6: // bin 32 (not supported) ------------------ | Branch (79:7): [True: 309, False: 20.6k] ------------------ 80| 309| return skipString(); 81| | 82| 214| case 0xc7: // ext 8 (not supported) ------------------ | Branch (82:7): [True: 214, False: 20.7k] ------------------ 83| 214| return skipExt(); 84| | 85| 244| case 0xc8: // ext 16 (not supported) ------------------ | Branch (85:7): [True: 244, False: 20.6k] ------------------ 86| 244| return skipExt(); 87| | 88| 302| case 0xc9: // ext 32 (not supported) ------------------ | Branch (88:7): [True: 302, False: 20.6k] ------------------ 89| 302| return skipExt(); 90| | 91| 596| case 0xca: ------------------ | Branch (91:7): [True: 596, False: 20.3k] ------------------ 92| 596| if (allowValue) ------------------ | Branch (92:13): [True: 596, False: 0] ------------------ 93| 596| return readFloat(variant); 94| 0| else 95| 0| return skipBytes(4); 96| | 97| 96| case 0xcb: ------------------ | Branch (97:7): [True: 96, False: 20.8k] ------------------ 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| 194| case 0xcc: ------------------ | Branch (103:7): [True: 194, False: 20.7k] ------------------ 104| 194| if (allowValue) ------------------ | Branch (104:13): [True: 194, False: 0] ------------------ 105| 194| return readInteger(variant); 106| 0| else 107| 0| return skipBytes(1); 108| | 109| 346| case 0xcd: ------------------ | Branch (109:7): [True: 346, False: 20.5k] ------------------ 110| 346| if (allowValue) ------------------ | Branch (110:13): [True: 346, False: 0] ------------------ 111| 346| return readInteger(variant); 112| 0| else 113| 0| return skipBytes(2); 114| | 115| 227| case 0xce: ------------------ | Branch (115:7): [True: 227, False: 20.6k] ------------------ 116| 227| if (allowValue) ------------------ | Branch (116:13): [True: 227, False: 0] ------------------ 117| 227| return readInteger(variant); 118| 0| else 119| 0| return skipBytes(4); 120| | 121| 162| case 0xcf: ------------------ | Branch (121:7): [True: 162, False: 20.7k] ------------------ 122| 162|#if ARDUINOJSON_USE_LONG_LONG 123| 162| if (allowValue) ------------------ | Branch (123:13): [True: 162, False: 0] ------------------ 124| 162| return readInteger(variant); 125| 0| else 126| 0| return skipBytes(8); 127| |#else 128| | return skipBytes(8); // not supported 129| |#endif 130| | 131| 181| case 0xd0: ------------------ | Branch (131:7): [True: 181, False: 20.7k] ------------------ 132| 181| if (allowValue) ------------------ | Branch (132:13): [True: 181, False: 0] ------------------ 133| 181| return readInteger(variant); 134| 0| else 135| 0| return skipBytes(1); 136| | 137| 366| case 0xd1: ------------------ | Branch (137:7): [True: 366, False: 20.5k] ------------------ 138| 366| if (allowValue) ------------------ | Branch (138:13): [True: 366, False: 0] ------------------ 139| 366| return readInteger(variant); 140| 0| else 141| 0| return skipBytes(2); 142| | 143| 217| case 0xd2: ------------------ | Branch (143:7): [True: 217, False: 20.7k] ------------------ 144| 217| if (allowValue) ------------------ | Branch (144:13): [True: 217, False: 0] ------------------ 145| 217| return readInteger(variant); 146| 0| else 147| 0| return skipBytes(4); 148| | 149| 107| case 0xd3: ------------------ | Branch (149:7): [True: 107, False: 20.8k] ------------------ 150| 107|#if ARDUINOJSON_USE_LONG_LONG 151| 107| if (allowValue) ------------------ | Branch (151:13): [True: 107, False: 0] ------------------ 152| 107| 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: 20.7k] ------------------ 160| 205| return skipBytes(2); 161| | 162| 172| case 0xd5: // fixext 2 (not supported) ------------------ | Branch (162:7): [True: 172, False: 20.7k] ------------------ 163| 172| return skipBytes(3); 164| | 165| 161| case 0xd6: // fixext 4 (not supported) ------------------ | Branch (165:7): [True: 161, False: 20.7k] ------------------ 166| 161| return skipBytes(5); 167| | 168| 91| case 0xd7: // fixext 8 (not supported) ------------------ | Branch (168:7): [True: 91, False: 20.8k] ------------------ 169| 91| return skipBytes(9); 170| | 171| 53| case 0xd8: // fixext 16 (not supported) ------------------ | Branch (171:7): [True: 53, False: 20.8k] ------------------ 172| 53| return skipBytes(17); 173| | 174| 167| case 0xd9: ------------------ | Branch (174:7): [True: 167, False: 20.7k] ------------------ 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: 20.6k] ------------------ 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| 197| case 0xdb: ------------------ | Branch (186:7): [True: 197, False: 20.7k] ------------------ 187| 197| if (allowValue) ------------------ | Branch (187:13): [True: 197, False: 0] ------------------ 188| 197| return readString(variant); 189| 0| else 190| 0| return skipString(); 191| | 192| 376| case 0xdc: ------------------ | Branch (192:7): [True: 376, False: 20.5k] ------------------ 193| 376| return readArray(variant, filter, nestingLimit); 194| | 195| 197| case 0xdd: ------------------ | Branch (195:7): [True: 197, False: 20.7k] ------------------ 196| 197| return readArray(variant, filter, nestingLimit); 197| | 198| 348| case 0xde: ------------------ | Branch (198:7): [True: 348, False: 20.5k] ------------------ 199| 348| return readObject(variant, filter, nestingLimit); 200| | 201| 197| case 0xdf: ------------------ | Branch (201:7): [True: 197, False: 20.7k] ------------------ 202| 197| return readObject(variant, filter, nestingLimit); 203| 20.9k| } 204| | 205| 13.2k| switch (code & 0xf0) { ------------------ | Branch (205:13): [True: 9.50k, False: 3.76k] ------------------ 206| 1.31k| case 0x80: ------------------ | Branch (206:7): [True: 1.31k, False: 11.9k] ------------------ 207| 1.31k| return readObject(variant, code & 0x0F, filter, nestingLimit); 208| | 209| 2.45k| case 0x90: ------------------ | Branch (209:7): [True: 2.45k, False: 10.8k] ------------------ 210| 2.45k| return readArray(variant, code & 0x0F, filter, nestingLimit); 211| 13.2k| } 212| | 213| 9.50k| if ((code & 0xe0) == 0xa0) { ------------------ | Branch (213:9): [True: 1.93k, False: 7.56k] ------------------ 214| 1.93k| if (allowValue) ------------------ | Branch (214:11): [True: 1.93k, False: 0] ------------------ 215| 1.93k| return readString(variant, code & 0x1f); 216| 0| else 217| 0| return skipBytes(code & 0x1f); 218| 1.93k| } 219| | 220| 7.56k| if (allowValue) ------------------ | Branch (220:9): [True: 7.56k, False: 0] ------------------ 221| 7.56k| variant->setInteger(static_cast(code)); 222| | 223| 7.56k| return DeserializationError::Ok; 224| 9.50k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE8readByteERh: 226| 24.0k| DeserializationError::Code readByte(uint8_t& value) { 227| 24.0k| int c = reader_.read(); 228| 24.0k| if (c < 0) ------------------ | Branch (228:9): [True: 455, False: 23.5k] ------------------ 229| 455| return DeserializationError::IncompleteInput; 230| 23.5k| value = static_cast(c); 231| 23.5k| return DeserializationError::Ok; 232| 24.0k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringIhEENS0_20DeserializationError4CodeEv: 356| 224| DeserializationError::Code skipString() { 357| 224| DeserializationError::Code err; 358| 224| T size; 359| | 360| 224| err = readInteger(size); 361| 224| if (err) ------------------ | Branch (361:9): [True: 7, False: 217] ------------------ 362| 7| return err; 363| | 364| 217| return skipBytes(size); 365| 224| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIhEENS0_20DeserializationError4CodeERT_: 254| 1.04k| DeserializationError::Code readInteger(T& value) { 255| 1.04k| DeserializationError::Code err; 256| | 257| 1.04k| err = readBytes(value); 258| 1.04k| 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.04k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIhEENS0_20DeserializationError4CodeERT_: 241| 7.34k| DeserializationError::Code readBytes(T& value) { 242| 7.34k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 7.34k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_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: 594] ------------------ 236| 12.6k| return DeserializationError::Ok; 237| 594| return DeserializationError::IncompleteInput; 238| 13.2k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringItEENS0_20DeserializationError4CodeEv: 356| 392| DeserializationError::Code skipString() { 357| 392| DeserializationError::Code err; 358| 392| T size; 359| | 360| 392| err = readInteger(size); 361| 392| if (err) ------------------ | Branch (361:9): [True: 13, False: 379] ------------------ 362| 13| return err; 363| | 364| 379| return skipBytes(size); 365| 392| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerItEENS0_20DeserializationError4CodeERT_: 254| 2.41k| DeserializationError::Code readInteger(T& value) { 255| 2.41k| DeserializationError::Code err; 256| | 257| 2.41k| err = readBytes(value); 258| 2.41k| if (err) ------------------ | Branch (258:9): [True: 90, False: 2.32k] ------------------ 259| 90| return err; 260| | 261| 2.32k| fixEndianess(value); 262| | 263| 2.32k| return DeserializationError::Ok; 264| 2.41k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesItEENS0_20DeserializationError4CodeERT_: 241| 2.41k| DeserializationError::Code readBytes(T& value) { 242| 2.41k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 2.41k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10skipStringIjEENS0_20DeserializationError4CodeEv: 356| 309| DeserializationError::Code skipString() { 357| 309| DeserializationError::Code err; 358| 309| T size; 359| | 360| 309| err = readInteger(size); 361| 309| if (err) ------------------ | Branch (361:9): [True: 14, False: 295] ------------------ 362| 14| return err; 363| | 364| 295| return skipBytes(size); 365| 309| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIjEENS0_20DeserializationError4CodeERT_: 254| 1.76k| DeserializationError::Code readInteger(T& value) { 255| 1.76k| DeserializationError::Code err; 256| | 257| 1.76k| err = readBytes(value); 258| 1.76k| if (err) ------------------ | Branch (258:9): [True: 99, False: 1.66k] ------------------ 259| 99| return err; 260| | 261| 1.66k| fixEndianess(value); 262| | 263| 1.66k| return DeserializationError::Ok; 264| 1.76k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIjEENS0_20DeserializationError4CodeERT_: 241| 1.76k| DeserializationError::Code readBytes(T& value) { 242| 1.76k| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 1.76k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtIhEENS0_20DeserializationError4CodeEv: 546| 214| DeserializationError::Code skipExt() { 547| 214| DeserializationError::Code err; 548| 214| T size; 549| | 550| 214| err = readInteger(size); 551| 214| if (err) ------------------ | Branch (551:9): [True: 7, False: 207] ------------------ 552| 7| return err; 553| | 554| 207| return skipBytes(size + 1U); 555| 214| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtItEENS0_20DeserializationError4CodeEv: 546| 244| DeserializationError::Code skipExt() { 547| 244| DeserializationError::Code err; 548| 244| T size; 549| | 550| 244| err = readInteger(size); 551| 244| if (err) ------------------ | Branch (551:9): [True: 12, False: 232] ------------------ 552| 12| return err; 553| | 554| 232| return skipBytes(size + 1U); 555| 244| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7skipExtIjEENS0_20DeserializationError4CodeEv: 546| 302| DeserializationError::Code skipExt() { 547| 302| DeserializationError::Code err; 548| 302| T size; 549| | 550| 302| err = readInteger(size); 551| 302| if (err) ------------------ | Branch (551:9): [True: 14, False: 288] ------------------ 552| 14| return err; 553| | 554| 288| return skipBytes(size + 1U); 555| 302| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readFloatIfEENS1_9enable_ifIXeqstT_Li4EENS0_20DeserializationError4CodeEE4typeEPNS1_11VariantDataE: 282| 596| readFloat(VariantData* variant) { 283| 596| DeserializationError::Code err; 284| 596| T value; 285| | 286| 596| err = readBytes(value); 287| 596| if (err) ------------------ | Branch (287:9): [True: 14, False: 582] ------------------ 288| 14| return err; 289| | 290| 582| fixEndianess(value); 291| 582| variant->setFloat(value); 292| | 293| 582| return DeserializationError::Ok; 294| 596| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIfEENS0_20DeserializationError4CodeERT_: 241| 596| DeserializationError::Code readBytes(T& value) { 242| 596| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 596| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9skipBytesEm: 245| 2.30k| DeserializationError::Code skipBytes(size_t n) { 246| 7.18k| for (; n; --n) { ------------------ | Branch (246:12): [True: 5.18k, False: 1.99k] ------------------ 247| 5.18k| if (reader_.read() < 0) ------------------ | Branch (247:11): [True: 304, False: 4.88k] ------------------ 248| 304| return DeserializationError::IncompleteInput; 249| 5.18k| } 250| 1.99k| return DeserializationError::Ok; 251| 2.30k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIdEENS0_20DeserializationError4CodeERT_: 241| 96| DeserializationError::Code readBytes(T& value) { 242| 96| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 96| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIhEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 194| DeserializationError::Code readInteger(VariantData* variant) { 268| 194| DeserializationError::Code err; 269| 194| T value; 270| | 271| 194| err = readInteger(value); 272| 194| if (err) ------------------ | Branch (272:9): [True: 7, False: 187] ------------------ 273| 7| return err; 274| | 275| 187| variant->setInteger(value); 276| | 277| 187| return DeserializationError::Ok; 278| 194| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerItEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 346| DeserializationError::Code readInteger(VariantData* variant) { 268| 346| DeserializationError::Code err; 269| 346| T value; 270| | 271| 346| err = readInteger(value); 272| 346| if (err) ------------------ | Branch (272:9): [True: 13, False: 333] ------------------ 273| 13| return err; 274| | 275| 333| variant->setInteger(value); 276| | 277| 333| return DeserializationError::Ok; 278| 346| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIjEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 227| DeserializationError::Code readInteger(VariantData* variant) { 268| 227| DeserializationError::Code err; 269| 227| T value; 270| | 271| 227| err = readInteger(value); 272| 227| if (err) ------------------ | Branch (272:9): [True: 14, False: 213] ------------------ 273| 14| return err; 274| | 275| 213| variant->setInteger(value); 276| | 277| 213| return DeserializationError::Ok; 278| 227| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerImEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 162| DeserializationError::Code readInteger(VariantData* variant) { 268| 162| DeserializationError::Code err; 269| 162| T value; 270| | 271| 162| err = readInteger(value); 272| 162| if (err) ------------------ | Branch (272:9): [True: 15, False: 147] ------------------ 273| 15| return err; 274| | 275| 147| variant->setInteger(value); 276| | 277| 147| return DeserializationError::Ok; 278| 162| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerImEENS0_20DeserializationError4CodeERT_: 254| 162| DeserializationError::Code readInteger(T& value) { 255| 162| DeserializationError::Code err; 256| | 257| 162| err = readBytes(value); 258| 162| if (err) ------------------ | Branch (258:9): [True: 15, False: 147] ------------------ 259| 15| return err; 260| | 261| 147| fixEndianess(value); 262| | 263| 147| return DeserializationError::Ok; 264| 162| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesImEENS0_20DeserializationError4CodeERT_: 241| 162| DeserializationError::Code readBytes(T& value) { 242| 162| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 162| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIaEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 181| DeserializationError::Code readInteger(VariantData* variant) { 268| 181| DeserializationError::Code err; 269| 181| T value; 270| | 271| 181| err = readInteger(value); 272| 181| if (err) ------------------ | Branch (272:9): [True: 7, False: 174] ------------------ 273| 7| return err; 274| | 275| 174| variant->setInteger(value); 276| | 277| 174| return DeserializationError::Ok; 278| 181| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIaEENS0_20DeserializationError4CodeERT_: 254| 181| DeserializationError::Code readInteger(T& value) { 255| 181| DeserializationError::Code err; 256| | 257| 181| err = readBytes(value); 258| 181| if (err) ------------------ | Branch (258:9): [True: 7, False: 174] ------------------ 259| 7| return err; 260| | 261| 174| fixEndianess(value); 262| | 263| 174| return DeserializationError::Ok; 264| 181| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIaEENS0_20DeserializationError4CodeERT_: 241| 181| DeserializationError::Code readBytes(T& value) { 242| 181| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 181| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIsEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 366| DeserializationError::Code readInteger(VariantData* variant) { 268| 366| DeserializationError::Code err; 269| 366| T value; 270| | 271| 366| err = readInteger(value); 272| 366| if (err) ------------------ | Branch (272:9): [True: 13, False: 353] ------------------ 273| 13| return err; 274| | 275| 353| variant->setInteger(value); 276| | 277| 353| return DeserializationError::Ok; 278| 366| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIsEENS0_20DeserializationError4CodeERT_: 254| 366| DeserializationError::Code readInteger(T& value) { 255| 366| DeserializationError::Code err; 256| | 257| 366| err = readBytes(value); 258| 366| if (err) ------------------ | Branch (258:9): [True: 13, False: 353] ------------------ 259| 13| return err; 260| | 261| 353| fixEndianess(value); 262| | 263| 353| return DeserializationError::Ok; 264| 366| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIsEENS0_20DeserializationError4CodeERT_: 241| 366| DeserializationError::Code readBytes(T& value) { 242| 366| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 366| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIiEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 217| DeserializationError::Code readInteger(VariantData* variant) { 268| 217| DeserializationError::Code err; 269| 217| T value; 270| | 271| 217| err = readInteger(value); 272| 217| if (err) ------------------ | Branch (272:9): [True: 14, False: 203] ------------------ 273| 14| return err; 274| | 275| 203| variant->setInteger(value); 276| | 277| 203| return DeserializationError::Ok; 278| 217| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIiEENS0_20DeserializationError4CodeERT_: 254| 217| DeserializationError::Code readInteger(T& value) { 255| 217| DeserializationError::Code err; 256| | 257| 217| err = readBytes(value); 258| 217| if (err) ------------------ | Branch (258:9): [True: 14, False: 203] ------------------ 259| 14| return err; 260| | 261| 203| fixEndianess(value); 262| | 263| 203| return DeserializationError::Ok; 264| 217| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIiEENS0_20DeserializationError4CodeERT_: 241| 217| DeserializationError::Code readBytes(T& value) { 242| 217| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 217| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIlEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 267| 107| DeserializationError::Code readInteger(VariantData* variant) { 268| 107| DeserializationError::Code err; 269| 107| T value; 270| | 271| 107| err = readInteger(value); 272| 107| if (err) ------------------ | Branch (272:9): [True: 16, False: 91] ------------------ 273| 16| return err; 274| | 275| 91| variant->setInteger(value); 276| | 277| 91| return DeserializationError::Ok; 278| 107| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE11readIntegerIlEENS0_20DeserializationError4CodeERT_: 254| 107| DeserializationError::Code readInteger(T& value) { 255| 107| DeserializationError::Code err; 256| | 257| 107| err = readBytes(value); 258| 107| if (err) ------------------ | Branch (258:9): [True: 16, False: 91] ------------------ 259| 16| return err; 260| | 261| 91| fixEndianess(value); 262| | 263| 91| return DeserializationError::Ok; 264| 107| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readBytesIlEENS0_20DeserializationError4CodeERT_: 241| 107| DeserializationError::Code readBytes(T& value) { 242| 107| return readBytes(reinterpret_cast(&value), sizeof(value)); 243| 107| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIjEENS0_20DeserializationError4CodeEPNS1_11VariantDataE: 332| 197| DeserializationError::Code readString(VariantData* variant) { 333| 197| DeserializationError::Code err; 334| 197| T size; 335| | 336| 197| err = readInteger(size); 337| 197| if (err) ------------------ | Branch (337:9): [True: 15, False: 182] ------------------ 338| 15| return err; 339| | 340| 182| return readString(variant, size); 341| 197| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayItNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 401| 376| DeserializationOption::NestingLimit nestingLimit) { 402| 376| DeserializationError::Code err; 403| 376| TSize size; 404| | 405| 376| err = readInteger(size); 406| 376| if (err) ------------------ | Branch (406:9): [True: 13, False: 363] ------------------ 407| 13| return err; 408| | 409| 363| return readArray(variant, size, filter, nestingLimit); 410| 376| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayIjNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 401| 197| DeserializationOption::NestingLimit nestingLimit) { 402| 197| DeserializationError::Code err; 403| 197| TSize size; 404| | 405| 197| err = readInteger(size); 406| 197| if (err) ------------------ | Branch (406:9): [True: 14, False: 183] ------------------ 407| 14| return err; 408| | 409| 183| return readArray(variant, size, filter, nestingLimit); 410| 197| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectItNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 456| 348| DeserializationOption::NestingLimit nestingLimit) { 457| 348| DeserializationError::Code err; 458| 348| TSize size; 459| | 460| 348| err = readInteger(size); 461| 348| if (err) ------------------ | Branch (461:9): [True: 13, False: 335] ------------------ 462| 13| return err; 463| | 464| 335| return readObject(variant, size, filter, nestingLimit); 465| 348| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectIjNS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataET0_NS0_21DeserializationOption12NestingLimitE: 456| 197| DeserializationOption::NestingLimit nestingLimit) { 457| 197| DeserializationError::Code err; 458| 197| TSize size; 459| | 460| 197| err = readInteger(size); 461| 197| if (err) ------------------ | Branch (461:9): [True: 14, False: 183] ------------------ 462| 14| return err; 463| | 464| 183| return readObject(variant, size, filter, nestingLimit); 465| 197| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 470| 1.83k| DeserializationOption::NestingLimit nestingLimit) { 471| 1.83k| DeserializationError::Code err; 472| | 473| 1.83k| if (nestingLimit.reached()) ------------------ | Branch (473:9): [True: 1, False: 1.83k] ------------------ 474| 1| return DeserializationError::TooDeep; 475| | 476| 1.83k| CollectionData* object; 477| 1.83k| if (filter.allowObject()) { ------------------ | Branch (477:9): [True: 1.83k, False: 0] ------------------ 478| 1.83k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 1.83k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 479| 0| object = &variant->toObject(); 480| 1.83k| } else { 481| 0| object = 0; 482| 0| } 483| | 484| 3.80k| for (; n; --n) { ------------------ | Branch (484:12): [True: 2.71k, False: 1.09k] ------------------ 485| 2.71k| err = readKey(); 486| 2.71k| if (err) ------------------ | Branch (486:11): [True: 331, False: 2.38k] ------------------ 487| 331| return err; 488| | 489| 2.38k| JsonString key = stringStorage_.str(); 490| 2.38k| TFilter memberFilter = filter[key.c_str()]; 491| 2.38k| VariantData* member; 492| | 493| 2.38k| if (memberFilter.allow()) { ------------------ | Branch (493:11): [True: 2.38k, False: 0] ------------------ 494| 2.38k| ARDUINOJSON_ASSERT(object != 0); ------------------ | | 11| 2.38k|# 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.38k| VariantSlot* slot = object->addSlot(pool_); 501| 2.38k| if (!slot) ------------------ | Branch (501:13): [True: 2, False: 2.37k] ------------------ 502| 2| return DeserializationError::NoMemory; 503| | 504| 2.37k| slot->setKey(key); 505| | 506| 2.37k| member = slot->data(); 507| 2.37k| } else { 508| 0| member = 0; 509| 0| } 510| | 511| 2.37k| err = parseVariant(member, memberFilter, nestingLimit.decrement()); 512| 2.37k| if (err) ------------------ | Branch (512:11): [True: 409, False: 1.97k] ------------------ 513| 409| return err; 514| 2.37k| } 515| | 516| 1.09k| return DeserializationError::Ok; 517| 1.83k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE7readKeyEv: 519| 2.71k| DeserializationError::Code readKey() { 520| 2.71k| DeserializationError::Code err; 521| 2.71k| uint8_t code; 522| | 523| 2.71k| err = readByte(code); 524| 2.71k| if (err) ------------------ | Branch (524:9): [True: 76, False: 2.63k] ------------------ 525| 76| return err; 526| | 527| 2.63k| if ((code & 0xe0) == 0xa0) ------------------ | Branch (527:9): [True: 1.63k, False: 1.00k] ------------------ 528| 1.63k| return readString(code & 0x1f); 529| | 530| 1.00k| switch (code) { 531| 247| case 0xd9: ------------------ | Branch (531:7): [True: 247, False: 753] ------------------ 532| 247| return readString(); 533| | 534| 411| case 0xda: ------------------ | Branch (534:7): [True: 411, False: 589] ------------------ 535| 411| return readString(); 536| | 537| 336| case 0xdb: ------------------ | Branch (537:7): [True: 336, False: 664] ------------------ 538| 336| return readString(); 539| | 540| 6| default: ------------------ | Branch (540:7): [True: 6, False: 994] ------------------ 541| 6| return DeserializationError::InvalidInput; 542| 1.00k| } 543| 1.00k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringEm: 378| 5.16k| DeserializationError::Code readString(size_t n) { 379| 5.16k| DeserializationError::Code err; 380| | 381| 5.16k| stringStorage_.startString(); 382| 11.1k| for (; n; --n) { ------------------ | Branch (382:12): [True: 6.29k, False: 4.88k] ------------------ 383| 6.29k| uint8_t c; 384| | 385| 6.29k| err = readBytes(c); 386| 6.29k| if (err) ------------------ | Branch (386:11): [True: 276, False: 6.01k] ------------------ 387| 276| return err; 388| | 389| 6.01k| stringStorage_.append(static_cast(c)); 390| 6.01k| } 391| | 392| 4.88k| if (!stringStorage_.isValid()) ------------------ | Branch (392:9): [True: 11, False: 4.87k] ------------------ 393| 11| return DeserializationError::NoMemory; 394| | 395| 4.87k| return DeserializationError::Ok; 396| 4.88k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIhEENS0_20DeserializationError4CodeEv: 344| 247| DeserializationError::Code readString() { 345| 247| DeserializationError::Code err; 346| 247| T size; 347| | 348| 247| err = readInteger(size); 349| 247| if (err) ------------------ | Branch (349:9): [True: 7, False: 240] ------------------ 350| 7| return err; 351| | 352| 240| return readString(size); 353| 247| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringIjEENS0_20DeserializationError4CodeEv: 344| 336| DeserializationError::Code readString() { 345| 336| DeserializationError::Code err; 346| 336| T size; 347| | 348| 336| err = readInteger(size); 349| 336| if (err) ------------------ | Branch (349:9): [True: 14, False: 322] ------------------ 350| 14| return err; 351| | 352| 322| return readString(size); 353| 336| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE9readArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeEPNS1_11VariantDataEmT_NS0_21DeserializationOption12NestingLimitE: 415| 2.99k| DeserializationOption::NestingLimit nestingLimit) { 416| 2.99k| DeserializationError::Code err; 417| | 418| 2.99k| if (nestingLimit.reached()) ------------------ | Branch (418:9): [True: 4, False: 2.99k] ------------------ 419| 4| return DeserializationError::TooDeep; 420| | 421| 2.99k| bool allowArray = filter.allowArray(); 422| | 423| 2.99k| CollectionData* array; 424| 2.99k| if (allowArray) { ------------------ | Branch (424:9): [True: 2.99k, False: 0] ------------------ 425| 2.99k| ARDUINOJSON_ASSERT(variant != 0); ------------------ | | 11| 2.99k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 426| 0| array = &variant->toArray(); 427| 2.99k| } else { 428| 0| array = 0; 429| 0| } 430| | 431| 0| TFilter memberFilter = filter[0U]; 432| | 433| 18.7k| for (; n; --n) { ------------------ | Branch (433:12): [True: 16.9k, False: 1.80k] ------------------ 434| 16.9k| VariantData* value; 435| | 436| 16.9k| if (memberFilter.allow()) { ------------------ | Branch (436:11): [True: 16.9k, False: 0] ------------------ 437| 16.9k| ARDUINOJSON_ASSERT(array != 0); ------------------ | | 11| 16.9k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 438| 0| value = array->addElement(pool_); 439| 16.9k| if (!value) ------------------ | Branch (439:13): [True: 3, False: 16.9k] ------------------ 440| 3| return DeserializationError::NoMemory; 441| 16.9k| } else { 442| 0| value = 0; 443| 0| } 444| | 445| 16.9k| err = parseVariant(value, memberFilter, nestingLimit.decrement()); 446| 16.9k| if (err) ------------------ | Branch (446:11): [True: 1.18k, False: 15.7k] ------------------ 447| 1.18k| return err; 448| 16.9k| } 449| | 450| 1.80k| return DeserializationError::Ok; 451| 2.99k| } _ZN11ArduinoJson7V6212HB6detail19MsgPackDeserializerINS1_13BoundedReaderIPKhvEENS1_12StringCopierEE10readStringEPNS1_11VariantDataEm: 367| 2.56k| DeserializationError::Code readString(VariantData* variant, size_t n) { 368| 2.56k| DeserializationError::Code err; 369| | 370| 2.56k| err = readString(n); 371| 2.56k| if (err) ------------------ | Branch (371:9): [True: 72, False: 2.49k] ------------------ 372| 72| return err; 373| | 374| 2.49k| variant->setString(stringStorage_.save()); 375| 2.49k| return DeserializationError::Ok; 376| 2.56k| } _ZN11ArduinoJson7V6212HB16serializeMsgPackINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT_: 207| 603|inline size_t serializeMsgPack(JsonVariantConst source, TDestination& output) { 208| 603| using namespace ArduinoJson::detail; 209| 603| return serialize(source, output); 210| 603|} _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 22| 603| MsgPackSerializer(TWriter writer) : writer_(writer) {} _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitFloatIdEENS1_9enable_ifIXeqstT_Li8EEmE4typeESF_: 38| 482| typename enable_if::type visitFloat(T value64) { 39| 482| float value32 = float(value64); 40| 482| if (value32 == value64) ------------------ | Branch (40:9): [True: 413, False: 69] ------------------ 41| 413| return visitFloat(value32); 42| 69| writeByte(0xCB); 43| 69| writeInteger(value64); 44| 69| return bytesWritten(); 45| 482| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitFloatIfEENS1_9enable_ifIXeqstT_Li4EEmE4typeESF_: 25| 413| typename enable_if::type visitFloat(T value32) { 26| 413| if (canConvertNumber(value32)) { ------------------ | Branch (26:9): [True: 347, False: 66] ------------------ 27| 347| JsonInteger truncatedValue = JsonInteger(value32); 28| 347| if (value32 == T(truncatedValue)) ------------------ | Branch (28:11): [True: 281, False: 66] ------------------ 29| 281| return visitSignedInteger(truncatedValue); 30| 347| } 31| 132| writeByte(0xCA); 32| 132| writeInteger(value32); 33| 132| return bytesWritten(); 34| 413| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeBytesEPKhm: 187| 4.11k| void writeBytes(const uint8_t* p, size_t n) { 188| 4.11k| writer_.write(p, n); 189| 4.11k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeByteEh: 183| 4.03k| void writeByte(uint8_t c) { 184| 4.03k| writer_.write(c); 185| 4.03k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIdEEvT_: 192| 69| void writeInteger(T value) { 193| 69| fixEndianess(value); 194| 69| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 69| } _ZNK11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 179| 6.44k| size_t bytesWritten() const { 180| 6.44k| return writer_.count(); 181| 6.44k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10visitArrayERKNS1_14CollectionDataE: 47| 768| size_t visitArray(const CollectionData& array) { 48| 768| size_t n = array.size(); 49| 768| if (n < 0x10) { ------------------ | Branch (49:9): [True: 735, False: 33] ------------------ 50| 735| writeByte(uint8_t(0x90 + array.size())); 51| 735| } else if (n < 0x10000) { ------------------ | Branch (51:16): [True: 33, False: 0] ------------------ 52| 33| writeByte(0xDC); 53| 33| writeInteger(uint16_t(n)); 54| 33| } else { 55| 0| writeByte(0xDD); 56| 0| writeInteger(uint32_t(n)); 57| 0| } 58| 4.46k| for (const VariantSlot* slot = array.head(); slot; slot = slot->next()) { ------------------ | Branch (58:50): [True: 3.69k, False: 768] ------------------ 59| 3.69k| slot->data()->accept(*this); 60| 3.69k| } 61| 768| return bytesWritten(); 62| 768| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEEvT_: 192| 144| void writeInteger(T value) { 193| 144| fixEndianess(value); 194| 144| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 144| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_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| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitObjectERKNS1_14CollectionDataE: 64| 326| size_t visitObject(const CollectionData& object) { 65| 326| size_t n = object.size(); 66| 326| if (n < 0x10) { ------------------ | Branch (66:9): [True: 311, False: 15] ------------------ 67| 311| writeByte(uint8_t(0x80 + n)); 68| 311| } else if (n < 0x10000) { ------------------ | Branch (68:16): [True: 15, False: 0] ------------------ 69| 15| writeByte(0xDE); 70| 15| writeInteger(uint16_t(n)); 71| 15| } else { 72| 0| writeByte(0xDF); 73| 0| writeInteger(uint32_t(n)); 74| 0| } 75| 980| for (const VariantSlot* slot = object.head(); slot; slot = slot->next()) { ------------------ | Branch (75:51): [True: 654, False: 326] ------------------ 76| 654| visitString(slot->key()); 77| 654| slot->data()->accept(*this); 78| 654| } 79| 326| return bytesWritten(); 80| 326| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitStringEPKc: 82| 654| size_t visitString(const char* value) { 83| 654| return visitString(value, strlen(value)); 84| 654| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11visitStringEPKcm: 86| 1.42k| size_t visitString(const char* value, size_t n) { 87| 1.42k| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 1.42k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 88| | 89| 1.42k| if (n < 0x20) { ------------------ | Branch (89:9): [True: 1.40k, False: 24] ------------------ 90| 1.40k| writeByte(uint8_t(0xA0 + n)); 91| 1.40k| } 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| 1.42k| writeBytes(reinterpret_cast(value), n); 102| 1.42k| return bytesWritten(); 103| 1.42k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIhEEvT_: 192| 857| void writeInteger(T value) { 193| 857| fixEndianess(value); 194| 857| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 857| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE18visitSignedIntegerEl: 110| 2.07k| size_t visitSignedInteger(JsonInteger value) { 111| 2.07k| if (value > 0) { ------------------ | Branch (111:9): [True: 841, False: 1.23k] ------------------ 112| 841| visitUnsignedInteger(static_cast(value)); 113| 1.23k| } else if (value >= -0x20) { ------------------ | Branch (113:16): [True: 810, False: 421] ------------------ 114| 810| writeInteger(int8_t(value)); 115| 810| } else if (value >= -0x80) { ------------------ | Branch (115:16): [True: 75, False: 346] ------------------ 116| 75| writeByte(0xD0); 117| 75| writeInteger(int8_t(value)); 118| 346| } else if (value >= -0x8000) { ------------------ | Branch (118:16): [True: 91, False: 255] ------------------ 119| 91| writeByte(0xD1); 120| 91| writeInteger(int16_t(value)); 121| 91| } 122| 255|#if ARDUINOJSON_USE_LONG_LONG 123| 255| else if (value >= -0x80000000LL) ------------------ | Branch (123:14): [True: 102, False: 153] ------------------ 124| |#else 125| | else 126| |#endif 127| 102| { 128| 102| writeByte(0xD2); 129| 102| writeInteger(int32_t(value)); 130| 102| } 131| 153|#if ARDUINOJSON_USE_LONG_LONG 132| 153| else { 133| 153| writeByte(0xD3); 134| 153| writeInteger(int64_t(value)); 135| 153| } 136| 2.07k|#endif 137| 2.07k| return bytesWritten(); 138| 2.07k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIaEEvT_: 192| 885| void writeInteger(T value) { 193| 885| fixEndianess(value); 194| 885| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 885| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEEvT_: 192| 91| void writeInteger(T value) { 193| 91| fixEndianess(value); 194| 91| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 91| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIiEEvT_: 192| 102| void writeInteger(T value) { 193| 102| fixEndianess(value); 194| 102| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 102| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEEvT_: 192| 153| void writeInteger(T value) { 193| 153| fixEndianess(value); 194| 153| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 153| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE20visitUnsignedIntegerEm: 140| 1.18k| size_t visitUnsignedInteger(JsonUInt value) { 141| 1.18k| if (value <= 0x7F) { ------------------ | Branch (141:9): [True: 757, False: 423] ------------------ 142| 757| writeInteger(uint8_t(value)); 143| 757| } else if (value <= 0xFF) { ------------------ | Branch (143:16): [True: 76, False: 347] ------------------ 144| 76| writeByte(0xCC); 145| 76| writeInteger(uint8_t(value)); 146| 347| } else if (value <= 0xFFFF) { ------------------ | Branch (146:16): [True: 96, False: 251] ------------------ 147| 96| writeByte(0xCD); 148| 96| writeInteger(uint16_t(value)); 149| 96| } 150| 251|#if ARDUINOJSON_USE_LONG_LONG 151| 251| else if (value <= 0xFFFFFFFF) ------------------ | Branch (151:14): [True: 116, False: 135] ------------------ 152| |#else 153| | else 154| |#endif 155| 116| { 156| 116| writeByte(0xCE); 157| 116| writeInteger(uint32_t(value)); 158| 116| } 159| 135|#if ARDUINOJSON_USE_LONG_LONG 160| 135| else { 161| 135| writeByte(0xCF); 162| 135| writeInteger(uint64_t(value)); 163| 135| } 164| 1.18k|#endif 165| 1.18k| return bytesWritten(); 166| 1.18k| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEEvT_: 192| 135| void writeInteger(T value) { 193| 135| fixEndianess(value); 194| 135| writeBytes(reinterpret_cast(&value), sizeof(value)); 195| 135| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12visitBooleanEb: 168| 215| size_t visitBoolean(bool value) { 169| 215| writeByte(value ? 0xC3 : 0xC2); ------------------ | Branch (169:15): [True: 48, False: 167] ------------------ 170| 215| return bytesWritten(); 171| 215| } _ZN11ArduinoJson7V6212HB6detail17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9visitNullEv: 173| 256| size_t visitNull() { 174| 256| writeByte(0xC0); 175| 256| return bytesWritten(); 176| 256| } _ZN11ArduinoJson7V6212HB6detail12fixEndianessIhEEvRT_: 37| 1.86k|inline void fixEndianess(T& value) { 38| 1.86k| fixEndianess(reinterpret_cast(&value), 39| 1.86k| integral_constant()); 40| 1.86k|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessEPhNS1_17integral_constantImLm1EEE: 34| 2.92k|inline void fixEndianess(uint8_t*, integral_constant) {} _ZN11ArduinoJson7V6212HB6detail12fixEndianessItEEvRT_: 37| 2.46k|inline void fixEndianess(T& value) { 38| 2.46k| fixEndianess(reinterpret_cast(&value), 39| 2.46k| integral_constant()); 40| 2.46k|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessEPhNS1_17integral_constantImLm2EEE: 30| 2.91k|inline void fixEndianess(uint8_t* p, integral_constant) { 31| 2.91k| swapBytes(p[0], p[1]); 32| 2.91k|} _ZN11ArduinoJson7V6212HB6detail9swapBytesERhS2_: 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|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIjEEvRT_: 37| 1.78k|inline void fixEndianess(T& value) { 38| 1.78k| fixEndianess(reinterpret_cast(&value), 39| 1.78k| integral_constant()); 40| 1.78k|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessEPhNS1_17integral_constantImLm4EEE: 25| 2.80k|inline void fixEndianess(uint8_t* p, integral_constant) { 26| 2.80k| swapBytes(p[0], p[3]); 27| 2.80k| swapBytes(p[1], p[2]); 28| 2.80k|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIfEEvRT_: 37| 714|inline void fixEndianess(T& value) { 38| 714| fixEndianess(reinterpret_cast(&value), 39| 714| integral_constant()); 40| 714|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIdEEvRT_: 37| 150|inline void fixEndianess(T& value) { 38| 150| fixEndianess(reinterpret_cast(&value), 39| 150| integral_constant()); 40| 150|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessEPhNS1_17integral_constantImLm8EEE: 18| 676|inline void fixEndianess(uint8_t* p, integral_constant) { 19| 676| swapBytes(p[0], p[7]); 20| 676| swapBytes(p[1], p[6]); 21| 676| swapBytes(p[2], p[5]); 22| 676| swapBytes(p[3], p[4]); 23| 676|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessImEEvRT_: 37| 282|inline void fixEndianess(T& value) { 38| 282| fixEndianess(reinterpret_cast(&value), 39| 282| integral_constant()); 40| 282|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIaEEvRT_: 37| 1.05k|inline void fixEndianess(T& value) { 38| 1.05k| fixEndianess(reinterpret_cast(&value), 39| 1.05k| integral_constant()); 40| 1.05k|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIsEEvRT_: 37| 444|inline void fixEndianess(T& value) { 38| 444| fixEndianess(reinterpret_cast(&value), 39| 444| integral_constant()); 40| 444|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIiEEvRT_: 37| 305|inline void fixEndianess(T& value) { 38| 305| fixEndianess(reinterpret_cast(&value), 39| 305| integral_constant()); 40| 305|} _ZN11ArduinoJson7V6212HB6detail12fixEndianessIlEEvRT_: 37| 244|inline void fixEndianess(T& value) { 38| 244| fixEndianess(reinterpret_cast(&value), 39| 244| integral_constant()); 40| 244|} _ZN11ArduinoJson7V6212HB6detail11FloatTraitsIfLm4EE11highest_forIlEEfPNS1_9enable_ifIXaaaasr11is_integralIT_EE5valuesr9is_signedIS6_EE5valueeqstS6_Li8EEiE4typeE: 178| 347| signed>::type* = 0) { 179| 347| return forge(0x5EFFFFFF); // 9.22337148709896192E18 180| 347| } _ZN11ArduinoJson7V6212HB6detail11FloatTraitsIfLm4EE5forgeEj: 142| 347| static T forge(uint32_t bits) { 143| 347| return alias_cast(bits); 144| 347| } _ZN11ArduinoJson7V6212HB6detail16canConvertNumberIlfEENS1_9enable_ifIXaaaasr17is_floating_pointIT0_EE5valuesr11is_integralIT_EE5valuegestS5_stS4_EbE4typeES4_: 118| 413|canConvertNumber(TIn value) { 119| | // Avoid error "9.22337e+18 is outside the range of representable values of 120| | // type 'long'" 121| 413| return value >= numeric_limits::lowest() && ------------------ | Branch (121:10): [True: 347, False: 66] ------------------ 122| 413| value <= FloatTraits::template highest_for(); ------------------ | Branch (122:10): [True: 347, False: 0] ------------------ 123| 413|} _ZN11ArduinoJson7V6212HB6detail10alias_castIfjEET_T0_: 24| 347|T alias_cast(F raw_data) { 25| 347| alias_cast_t ac; 26| 347| ac.raw = raw_data; 27| 347| return ac.data; 28| 347|} _ZN11ArduinoJson7V6212HB6detail14numeric_limitsIivE6lowestEv: 33| 32.9k| static T lowest() { 34| 32.9k| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 32.9k| } _ZN11ArduinoJson7V6212HB6detail14numeric_limitsIivE7highestEv: 36| 16.4k| static T highest() { 37| 16.4k| return T(~lowest()); 38| 16.4k| } _ZN11ArduinoJson7V6212HB6detail14numeric_limitsIlvE6lowestEv: 33| 413| static T lowest() { 34| 413| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 413| } _ZN11ArduinoJson7V6212HB6detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 12| 1.98k|T&& forward(typename remove_reference::type& t) noexcept { 13| 1.98k| return static_cast(t); 14| 1.98k|} _ZN11ArduinoJson7V6212HB6detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 603| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson7V6212HB6detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 4.11k| void write(const uint8_t* s, size_t n) { 21| 4.11k| count_ += writer_.write(s, n); 22| 4.11k| } _ZN11ArduinoJson7V6212HB6detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 4.03k| void write(uint8_t c) { 17| 4.03k| count_ += writer_.write(c); 18| 4.03k| } _ZNK11ArduinoJson7V6212HB6detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 6.44k| size_t count() const { 25| 6.44k| return count_; 26| 6.44k| } _ZN11ArduinoJson7V6212HB6detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 27| 603| Writer(TDestination& str) : str_(&str) {} _ZN11ArduinoJson7V6212HB6detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 34| 4.11k| size_t write(const uint8_t* s, size_t n) { 35| 4.11k| str_->append(reinterpret_cast(s), n); 36| 4.11k| return n; 37| 4.11k| } _ZN11ArduinoJson7V6212HB6detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 29| 4.03k| size_t write(uint8_t c) { 30| 4.03k| str_->push_back(static_cast(c)); 31| 4.03k| return 1; 32| 4.03k| } _ZN11ArduinoJson7V6212HB6detail9serializeINS1_17MsgPackSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 20| 603| TDestination& destination) { 21| 603| Writer writer(destination); 22| 603| return doSerialize(source, writer); 23| 603|} _ZN11ArduinoJson7V6212HB6detail11doSerializeINS1_17MsgPackSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 13| 603|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 14| 603| TSerializer serializer(writer); 15| 603| return variantAccept(VariantAttorney::getData(source), serializer); 16| 603|} _ZN11ArduinoJson7V6212HB6detail12StringCopierC2EPNS1_10MemoryPoolE: 13| 1.98k| StringCopier(MemoryPool* pool) : pool_(pool) {} _ZN11ArduinoJson7V6212HB6detail12StringCopier11startStringEv: 15| 5.16k| void startString() { 16| 5.16k| pool_->getFreeZone(&ptr_, &capacity_); 17| 5.16k| size_ = 0; 18| 5.16k| if (capacity_ == 0) ------------------ | Branch (18:9): [True: 39, False: 5.12k] ------------------ 19| 39| pool_->markAsOverflowed(); 20| 5.16k| } _ZN11ArduinoJson7V6212HB6detail12StringCopier6appendEc: 39| 6.01k| void append(char c) { 40| 6.01k| if (size_ + 1 < capacity_) ------------------ | Branch (40:9): [True: 5.71k, False: 302] ------------------ 41| 5.71k| ptr_[size_++] = c; 42| 302| else 43| 302| pool_->markAsOverflowed(); 44| 6.01k| } _ZNK11ArduinoJson7V6212HB6detail12StringCopier7isValidEv: 46| 4.88k| bool isValid() const { 47| 4.88k| return !pool_->overflowed(); 48| 4.88k| } _ZNK11ArduinoJson7V6212HB6detail12StringCopier3strEv: 54| 2.38k| JsonString str() const { 55| 2.38k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 2.38k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 56| 2.38k| ARDUINOJSON_ASSERT(size_ < capacity_); ------------------ | | 11| 2.38k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 57| 0| ptr_[size_] = 0; 58| 2.38k| return JsonString(ptr_, size_, JsonString::Copied); 59| 2.38k| } _ZN11ArduinoJson7V6212HB6detail12StringCopier4saveEv: 22| 4.87k| JsonString save() { 23| 4.87k| ARDUINOJSON_ASSERT(ptr_); ------------------ | | 11| 4.87k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 24| 4.87k| ARDUINOJSON_ASSERT(size_ < capacity_); // needs room for the terminator ------------------ | | 11| 4.87k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 25| 0| return JsonString(pool_->saveStringFromFreeZone(size_), size_, 26| 4.87k| JsonString::Copied); 27| 4.87k| } _ZN11ArduinoJson7V6212HB6detail17makeStringStorageIPKhEENS1_12StringCopierERT_PNS1_10MemoryPoolE: 13| 1.98k|StringCopier makeStringStorage(TInput&, MemoryPool* pool) { 14| 1.98k| ARDUINOJSON_ASSERT(pool != 0); ------------------ | | 11| 1.98k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 15| 0| return StringCopier(pool); 16| 1.98k|} _ZNK11ArduinoJson7V6212HB6detail14SizedRamString4sizeEv: 110| 24.9k| size_t size() const { 111| 24.9k| return size_; 112| 24.9k| } _ZNK11ArduinoJson7V6212HB6detail14SizedRamString6isNullEv: 106| 13.2k| bool isNull() const { 107| 13.2k| return !str_; 108| 13.2k| } _ZNK11ArduinoJson7V6212HB6detail14SizedRamStringixEm: 114| 6.74k| char operator[](size_t i) const { 115| 6.74k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 6.74k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 116| 6.74k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 6.74k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 117| 0| return str_[i]; 118| 6.74k| } _ZN11ArduinoJson7V6212HB6detail18SizedStringAdapterIPcvE5adaptEPKcm: 138| 11.5k| static AdaptedString adapt(const TChar* p, size_t n) { 139| 11.5k| return AdaptedString(reinterpret_cast(p), n); 140| 11.5k| } _ZN11ArduinoJson7V6212HB6detail14SizedRamStringC2EPKcm: 104| 11.5k| SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {} _ZN11ArduinoJson7V6212HB10JsonStringC2EPKcmNS1_9OwnershipE: 25| 7.25k| : data_(data), size_(sz), ownership_(ownership) {} _ZNK11ArduinoJson7V6212HB10JsonString5c_strEv: 28| 7.25k| const char* c_str() const { 29| 7.25k| return data_; 30| 7.25k| } _ZNK11ArduinoJson7V6212HB10JsonStringcvbEv: 49| 4.87k| explicit operator bool() const { 50| 4.87k| return data_ != 0; 51| 4.87k| } _ZNK11ArduinoJson7V6212HB10JsonString8isLinkedEv: 39| 4.87k| bool isLinked() const { 40| 4.87k| return ownership_ == Linked; 41| 4.87k| } _ZNK11ArduinoJson7V6212HB10JsonString4sizeEv: 44| 2.49k| size_t size() const { 45| 2.49k| return size_; 46| 2.49k| } _ZN11ArduinoJson7V6212HB6detail11adaptStringIcEENS1_18SizedStringAdapterIPT_vE13AdaptedStringES5_m: 27| 11.5k| size_t n) { 28| 11.5k| return SizedStringAdapter::adapt(p, n); 29| 11.5k|} _ZN11ArduinoJson7V6212HB6detail12stringEqualsINS1_14SizedRamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 48| 6.64k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 49| 6.64k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 6.64k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 50| 6.64k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 6.64k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 51| 0| size_t size1 = s1.size(); 52| 6.64k| size_t size2 = s2.size(); 53| 6.64k| if (size1 != size2) ------------------ | Branch (53:7): [True: 0, False: 6.64k] ------------------ 54| 0| return false; 55| 7.43k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (55:22): [True: 3.37k, False: 4.06k] ------------------ 56| 3.37k| if (s1[i] != s2[i]) ------------------ | Branch (56:9): [True: 2.58k, False: 789] ------------------ 57| 2.58k| return false; 58| 3.37k| } 59| 4.06k| return true; 60| 6.64k|} _ZN11ArduinoJson7V6212HB16JsonVariantConstC2EPKNS0_6detail11VariantDataE: 36| 603| explicit JsonVariantConst(const detail::VariantData* data) : data_(data) {} _ZNK11ArduinoJson7V6212HB16JsonVariantConst7getDataEv: 136| 603| const detail::VariantData* getData() const { 137| 603| return data_; 138| 603| } _ZN11ArduinoJson7V6212HB6detail8slotDataEPNS1_11VariantSlotE: 42| 16.9k|inline VariantData* slotData(VariantSlot* slot) { 43| 16.9k| return reinterpret_cast(slot); 44| 16.9k|} _ZN11ArduinoJson7V6212HB6detail8slotSizeEPKNS1_11VariantSlotE: 33| 1.82k|inline size_t slotSize(const VariantSlot* var) { 34| 1.82k| size_t n = 0; 35| 8.24k| while (var) { ------------------ | Branch (35:10): [True: 6.41k, False: 1.82k] ------------------ 36| 6.41k| n++; 37| 6.41k| var = var->next(); 38| 6.41k| } 39| 1.82k| return n; 40| 1.82k|} _ZN11ArduinoJson7V6212HB6detail15VariantAttorney7getDataINS0_12JsonDocumentEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 1.98k| TClient& client) { 39| 1.98k| return client.getData(); 40| 1.98k| } _ZN11ArduinoJson7V6212HB6detail15VariantAttorney7getPoolINS0_12JsonDocumentEEEPNS1_10MemoryPoolERT_: 32| 1.98k| FORCE_INLINE static MemoryPool* getPool(TClient& client) { 33| 1.98k| return client.getPool(); 34| 1.98k| } _ZN11ArduinoJson7V6212HB6detail15VariantAttorney7getDataINS0_16JsonVariantConstEEENS2_15ResultOfGetDataIT_E4typeERS6_: 38| 603| TClient& client) { 39| 603| return client.getData(); 40| 603| } _ZN11ArduinoJson7V6212HB6detail11VariantDataC2Ev: 21| 1.98k| VariantData() : flags_(VALUE_IS_NULL) {} _ZN11ArduinoJson7V6212HB6detail11VariantData7setNullEv: 199| 1.98k| void setNull() { 200| 1.98k| setType(VALUE_IS_NULL); 201| 1.98k| } _ZN11ArduinoJson7V6212HB6detail11VariantData7setTypeEh: 302| 19.8k| void setType(uint8_t t) { 303| 19.8k| flags_ &= OWNED_KEY_BIT; 304| 19.8k| flags_ |= t; 305| 19.8k| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setBooleanEb: 153| 606| void setBoolean(bool value) { 154| 606| setType(VALUE_IS_BOOLEAN); 155| 606| content_.asBoolean = value; 156| 606| } _ZN11ArduinoJson7V6212HB6detail11VariantData8setFloatEd: 158| 663| void setFloat(JsonFloat value) { 159| 663| setType(VALUE_IS_FLOAT); 160| 663| content_.asFloat = value; 161| 663| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIhEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 187| typename enable_if::value>::type setInteger(T value) { 189| 187| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 187| content_.asUnsignedInteger = static_cast(value); 191| 187| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerItEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 333| typename enable_if::value>::type setInteger(T value) { 189| 333| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 333| content_.asUnsignedInteger = static_cast(value); 191| 333| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIjEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 213| typename enable_if::value>::type setInteger(T value) { 189| 213| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 213| content_.asUnsignedInteger = static_cast(value); 191| 213| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeES5_: 188| 147| typename enable_if::value>::type setInteger(T value) { 189| 147| setType(VALUE_IS_UNSIGNED_INTEGER); 190| 147| content_.asUnsignedInteger = static_cast(value); 191| 147| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIsEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 353| typename enable_if::value>::type setInteger(T value) { 195| 353| setType(VALUE_IS_SIGNED_INTEGER); 196| 353| content_.asSignedInteger = value; 197| 353| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIiEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 203| typename enable_if::value>::type setInteger(T value) { 195| 203| setType(VALUE_IS_SIGNED_INTEGER); 196| 203| content_.asSignedInteger = value; 197| 203| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 91| typename enable_if::value>::type setInteger(T value) { 195| 91| setType(VALUE_IS_SIGNED_INTEGER); 196| 91| content_.asSignedInteger = value; 197| 91| } _ZN11ArduinoJson7V6212HB6detail11VariantData8toObjectEv: 219| 1.83k| CollectionData& toObject() { 220| 1.83k| setType(VALUE_IS_OBJECT); 221| 1.83k| content_.asCollection.clear(); 222| 1.83k| return content_.asCollection; 223| 1.83k| } _ZN11ArduinoJson7V6212HB6detail11VariantData7toArrayEv: 213| 2.99k| CollectionData& toArray() { 214| 2.99k| setType(VALUE_IS_ARRAY); 215| 2.99k| content_.asCollection.clear(); 216| 2.99k| return content_.asCollection; 217| 2.99k| } _ZN11ArduinoJson7V6212HB6detail11VariantData9setStringENS0_10JsonStringE: 203| 2.49k| void setString(JsonString s) { 204| 2.49k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 2.49k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 205| 2.49k| if (s.isLinked()) ------------------ | Branch (205:9): [True: 0, False: 2.49k] ------------------ 206| 0| setType(VALUE_IS_LINKED_STRING); 207| 2.49k| else 208| 2.49k| setType(VALUE_IS_OWNED_STRING); 209| 2.49k| content_.asString.data = s.c_str(); 210| 2.49k| content_.asString.size = s.size(); 211| 2.49k| } _ZN11ArduinoJson7V6212HB6detail11VariantData10setIntegerIaEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeES5_: 194| 7.74k| typename enable_if::value>::type setInteger(T value) { 195| 7.74k| setType(VALUE_IS_SIGNED_INTEGER); 196| 7.74k| content_.asSignedInteger = value; 197| 7.74k| } _ZNK11ArduinoJson7V6212HB6detail11VariantData6acceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_: 29| 4.94k| typename TVisitor::result_type accept(TVisitor& visitor) const { 30| 4.94k| switch (type()) { 31| 482| case VALUE_IS_FLOAT: ------------------ | Branch (31:7): [True: 482, False: 4.46k] ------------------ 32| 482| return visitor.visitFloat(content_.asFloat); 33| | 34| 768| case VALUE_IS_ARRAY: ------------------ | Branch (34:7): [True: 768, False: 4.18k] ------------------ 35| 768| return visitor.visitArray(content_.asCollection); 36| | 37| 326| case VALUE_IS_OBJECT: ------------------ | Branch (37:7): [True: 326, False: 4.62k] ------------------ 38| 326| return visitor.visitObject(content_.asCollection); 39| | 40| 0| case VALUE_IS_LINKED_STRING: ------------------ | Branch (40:7): [True: 0, False: 4.94k] ------------------ 41| 772| case VALUE_IS_OWNED_STRING: ------------------ | Branch (41:7): [True: 772, False: 4.17k] ------------------ 42| 772| return visitor.visitString(content_.asString.data, 43| 772| content_.asString.size); 44| | 45| 0| case VALUE_IS_OWNED_RAW: ------------------ | Branch (45:7): [True: 0, False: 4.94k] ------------------ 46| 0| case VALUE_IS_LINKED_RAW: ------------------ | Branch (46:7): [True: 0, False: 4.94k] ------------------ 47| 0| return visitor.visitRawJson(content_.asString.data, 48| 0| content_.asString.size); 49| | 50| 1.79k| case VALUE_IS_SIGNED_INTEGER: ------------------ | Branch (50:7): [True: 1.79k, False: 3.15k] ------------------ 51| 1.79k| return visitor.visitSignedInteger(content_.asSignedInteger); 52| | 53| 339| case VALUE_IS_UNSIGNED_INTEGER: ------------------ | Branch (53:7): [True: 339, False: 4.61k] ------------------ 54| 339| return visitor.visitUnsignedInteger(content_.asUnsignedInteger); 55| | 56| 215| case VALUE_IS_BOOLEAN: ------------------ | Branch (56:7): [True: 215, False: 4.73k] ------------------ 57| 215| return visitor.visitBoolean(content_.asBoolean != 0); 58| | 59| 256| default: ------------------ | Branch (59:7): [True: 256, False: 4.69k] ------------------ 60| 256| return visitor.visitNull(); 61| 4.94k| } 62| 4.94k| } _ZNK11ArduinoJson7V6212HB6detail11VariantData4typeEv: 287| 4.94k| uint8_t type() const { 288| 4.94k| return flags_ & VALUE_MASK; 289| 4.94k| } _ZN11ArduinoJson7V6212HB6detail13variantAcceptINS1_17MsgPackSerializerINS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEEENT_11result_typeEPKNS1_11VariantDataERSE_: 16| 603| TVisitor& visitor) { 17| 603| if (var != 0) ------------------ | Branch (17:7): [True: 603, False: 0] ------------------ 18| 603| return var->accept(visitor); 19| 0| else 20| 0| return visitor.visitNull(); 21| 603|} _ZN11ArduinoJson7V6212HB6detail11VariantSlot14setNextNotNullEPS2_: 70| 16.4k| void setNextNotNull(VariantSlot* slot) { 71| 16.4k| ARDUINOJSON_ASSERT(slot != 0); ------------------ | | 11| 16.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 72| 16.4k| ARDUINOJSON_ASSERT(slot - this >= ------------------ | | 11| 16.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 73| 0| numeric_limits::lowest()); 74| 16.4k| ARDUINOJSON_ASSERT(slot - this <= ------------------ | | 11| 16.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 75| 0| numeric_limits::highest()); 76| 0| next_ = VariantSlotDiff(slot - this); 77| 16.4k| } _ZN11ArduinoJson7V6212HB6detail11VariantSlot5clearEv: 96| 19.3k| void clear() { 97| 19.3k| next_ = 0; 98| 19.3k| flags_ = 0; 99| 19.3k| key_ = 0; 100| 19.3k| } _ZN11ArduinoJson7V6212HB6detail11VariantSlot6setKeyENS0_10JsonStringE: 79| 2.37k| void setKey(JsonString k) { 80| 2.37k| ARDUINOJSON_ASSERT(k); ------------------ | | 11| 2.37k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 81| 2.37k| if (k.isLinked()) ------------------ | Branch (81:9): [True: 0, False: 2.37k] ------------------ 82| 0| flags_ &= VALUE_MASK; 83| 2.37k| else 84| 2.37k| flags_ |= OWNED_KEY_BIT; 85| 2.37k| key_ = k.c_str(); 86| 2.37k| } _ZN11ArduinoJson7V6212HB6detail11VariantSlot4dataEv: 32| 2.37k| VariantData* data() { 33| 2.37k| return reinterpret_cast(&content_); 34| 2.37k| } _ZNK11ArduinoJson7V6212HB6detail11VariantSlot4dataEv: 36| 4.34k| const VariantData* data() const { 37| 4.34k| return reinterpret_cast(&content_); 38| 4.34k| } _ZNK11ArduinoJson7V6212HB6detail11VariantSlot4nextEv: 44| 10.7k| const VariantSlot* next() const { 45| 10.7k| return const_cast(this)->next(); 46| 10.7k| } _ZN11ArduinoJson7V6212HB6detail11VariantSlot4nextEv: 40| 10.7k| VariantSlot* next() { 41| 10.7k| return next_ ? this + next_ : 0; ------------------ | Branch (41:12): [True: 9.51k, False: 1.25k] ------------------ 42| 10.7k| } _ZNK11ArduinoJson7V6212HB6detail11VariantSlot3keyEv: 88| 654| const char* key() const { 89| 654| return key_; 90| 654| } LLVMFuzzerTestOneInput: 3| 1.98k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 1.98k| DynamicJsonDocument doc(4096); 5| 1.98k| DeserializationError error = deserializeMsgPack(doc, data, size); 6| 1.98k| if (!error) { ------------------ | Branch (6:7): [True: 603, False: 1.38k] ------------------ 7| 603| std::string json; 8| 603| serializeMsgPack(doc, json); 9| 603| } 10| 1.98k| return 0; 11| 1.98k|}