LLVMFuzzerTestOneInput: 3| 2.40k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 4| 2.40k| JsonDocument doc; 5| 2.40k| DeserializationError error = deserializeJson(doc, data, size); 6| 2.40k| if (!error) { ------------------ | Branch (6:7): [True: 926, False: 1.47k] ------------------ 7| 926| std::string json; 8| 926| serializeJson(doc, json); 9| 926| } 10| 2.40k| return 0; 11| 2.40k|} _ZN11ArduinoJson8V710HB426detail9ArrayData10addElementEPNS1_15ResourceManagerE: 23| 8.29k|inline VariantData* ArrayData::addElement(ResourceManager* resources) { 24| 8.29k| auto slot = resources->allocVariant(); 25| 8.29k| if (!slot) ------------------ | Branch (25:7): [True: 0, False: 8.29k] ------------------ 26| 0| return nullptr; 27| 8.29k| CollectionData::appendOne(slot, resources); 28| 8.29k| return slot.ptr(); 29| 8.29k|} _ZNK11ArduinoJson8V710HB426detail14CollectionData4headEv: 95| 705| SlotId head() const { 96| 705| return head_; 97| 705| } _ZN11ArduinoJson8V710HB426detail14CollectionDatanwEmPv: 74| 3.86k| static void* operator new(size_t, void* p) noexcept { 75| 3.86k| return p; 76| 3.86k| } _ZN11ArduinoJson8V710HB426detail18CollectionIteratorC2Ev: 22| 2.46k| CollectionIterator() : slot_(nullptr), currentId_(NULL_SLOT) {} _ZN11ArduinoJson8V710HB426detail18CollectionIteratorptEv: 38| 5.02k| VariantData* operator->() { 39| 5.02k| ARDUINOJSON_ASSERT(slot_ != nullptr); ------------------ | | 11| 5.02k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 40| 5.02k| return data(); 41| 5.02k| } _ZNK11ArduinoJson8V710HB426detail18CollectionIterator4doneEv: 26| 14.9k| bool done() const { 27| 14.9k| return slot_ == nullptr; 28| 14.9k| } _ZN11ArduinoJson8V710HB426detail18CollectionIterator4dataEv: 53| 5.53k| VariantData* data() { 54| 5.53k| return reinterpret_cast(slot_); 55| 5.53k| } _ZN11ArduinoJson8V710HB426detail14CollectionData9appendOneENS1_4SlotINS1_11VariantDataEEEPKNS1_15ResourceManagerE: 34| 8.29k| const ResourceManager* resources) { 35| 8.29k| if (tail_ != NULL_SLOT) { ------------------ | Branch (35:7): [True: 6.48k, False: 1.80k] ------------------ 36| 6.48k| auto tail = resources->getVariant(tail_); 37| 6.48k| tail->setNext(slot.id()); 38| 6.48k| tail_ = slot.id(); 39| 6.48k| } else { 40| 1.80k| head_ = slot.id(); 41| 1.80k| tail_ = slot.id(); 42| 1.80k| } 43| 8.29k|} _ZNK11ArduinoJson8V710HB426detail14CollectionData14createIteratorEPKNS1_15ResourceManagerE: 29| 2.96k| const ResourceManager* resources) const { 30| 2.96k| return iterator(resources->getVariant(head_), head_); 31| 2.96k|} _ZN11ArduinoJson8V710HB426detail18CollectionIteratorC2EPNS1_11VariantDataEj: 16| 2.96k| : slot_(slot), currentId_(slotId) { 17| 2.96k| nextId_ = slot_ ? slot_->next() : NULL_SLOT; ------------------ | Branch (17:13): [True: 1.62k, False: 1.34k] ------------------ 18| 2.96k|} _ZN11ArduinoJson8V710HB426detail18CollectionIterator4nextEPKNS1_15ResourceManagerE: 20| 9.55k|inline void CollectionIterator::next(const ResourceManager* resources) { 21| 9.55k| ARDUINOJSON_ASSERT(currentId_ != NULL_SLOT); ------------------ | | 11| 9.55k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 22| 9.55k| slot_ = resources->getVariant(nextId_); 23| 9.55k| currentId_ = nextId_; 24| 9.55k| if (slot_) ------------------ | Branch (24:7): [True: 8.43k, False: 1.11k] ------------------ 25| 8.43k| nextId_ = slot_->next(); 26| 9.55k|} _ZN11ArduinoJson8V710HB426detail14CollectionData10appendPairENS1_4SlotINS1_11VariantDataEEES5_PKNS1_15ResourceManagerE: 47| 2.46k| const ResourceManager* resources) { 48| 2.46k| key->setNext(value.id()); 49| | 50| 2.46k| if (tail_ != NULL_SLOT) { ------------------ | Branch (50:7): [True: 1.11k, False: 1.34k] ------------------ 51| 1.11k| auto tail = resources->getVariant(tail_); 52| 1.11k| tail->setNext(key.id()); 53| 1.11k| tail_ = value.id(); 54| 1.34k| } else { 55| 1.34k| head_ = key.id(); 56| 1.34k| tail_ = value.id(); 57| 1.34k| } 58| 2.46k|} _ZN11ArduinoJson8V710HB426detail14CollectionData5clearEPNS1_15ResourceManagerE: 60| 413|inline void CollectionData::clear(ResourceManager* resources) { 61| 413| auto next = head_; 62| 1.42k| while (next != NULL_SLOT) { ------------------ | Branch (62:10): [True: 1.01k, False: 413] ------------------ 63| 1.01k| auto currId = next; 64| 1.01k| auto slot = resources->getVariant(next); 65| 1.01k| next = slot->next(); 66| 1.01k| resources->freeVariant({slot, currId}); 67| 1.01k| } 68| | 69| 413| head_ = NULL_SLOT; 70| 413| tail_ = NULL_SLOT; 71| 413|} _ZNK11ArduinoJson8V710HB4220DeserializationErrorcvbEv: 56| 2.40k| explicit operator bool() const { 57| 2.40k| return code_ != Ok; 58| 2.40k| } _ZN11ArduinoJson8V710HB4220DeserializationErrorC2ENS1_4CodeE: 29| 2.40k| DeserializationError(Code c) : code_(c) {} _ZN11ArduinoJson8V710HB426detail26makeDeserializationOptionsENS0_21DeserializationOption12NestingLimitE: 31| 2.40k| DeserializationOption::NestingLimit nestingLimit = {}) { 32| 2.40k| return {{}, nestingLimit}; 33| 2.40k|} _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter10allowArrayEv: 58| 2.03k| bool allowArray() const { 59| 2.03k| return true; 60| 2.03k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilterixImEES2_RKT_: 71| 1.80k| AllowAllFilter operator[](const TKey&) const { 72| 1.80k| return AllowAllFilter(); 73| 1.80k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter5allowEv: 54| 11.2k| bool allow() const { 55| 11.2k| return true; 56| 11.2k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter11allowObjectEv: 62| 1.83k| bool allowObject() const { 63| 1.83k| return true; 64| 1.83k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilterixIPKcEES2_RKT_: 71| 2.96k| AllowAllFilter operator[](const TKey&) const { 72| 2.96k| return AllowAllFilter(); 73| 2.96k| } _ZNK11ArduinoJson8V710HB426detail14AllowAllFilter10allowValueEv: 66| 9.23k| bool allowValue() const { 67| 9.23k| return true; 68| 9.23k| } _ZNK11ArduinoJson8V710HB4221DeserializationOption12NestingLimit7reachedEv: 23| 3.86k| bool reached() const { 24| 3.86k| return value_ == 0; 25| 3.86k| } _ZNK11ArduinoJson8V710HB4221DeserializationOption12NestingLimit9decrementEv: 18| 11.2k| NestingLimit decrement() const { 19| 11.2k| ARDUINOJSON_ASSERT(value_ > 0); ------------------ | | 11| 11.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 20| 11.2k| return NestingLimit(static_cast(value_ - 1)); 21| 11.2k| } _ZN11ArduinoJson8V710HB4221DeserializationOption12NestingLimitC2Eh: 16| 11.2k| explicit NestingLimit(uint8_t n) : value_(n) {} _ZN11ArduinoJson8V710HB4221DeserializationOption12NestingLimitC2Ev: 15| 2.40k| NestingLimit() : value_(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} _ZN11ArduinoJson8V710HB426detail10makeReaderIKhEENS1_13BoundedReaderIPT_vEES6_m: 70| 2.40k|BoundedReader makeReader(TChar* input, size_t inputSize) { 71| 2.40k| return BoundedReader{input, inputSize}; 72| 2.40k|} _ZN11ArduinoJson8V710HB426detail14IteratorReaderIPKcE4readEv: 19| 71.9k| int read() { 20| 71.9k| if (ptr_ < end_) ------------------ | Branch (20:9): [True: 70.1k, False: 1.87k] ------------------ 21| 70.1k| return static_cast(*ptr_++); 22| 1.87k| else 23| 1.87k| return -1; 24| 71.9k| } _ZN11ArduinoJson8V710HB426detail14IteratorReaderIPKcEC2ES4_S4_: 17| 2.40k| : ptr_(begin), end_(end) {} _ZN11ArduinoJson8V710HB426detail13BoundedReaderIPKhvEC2EPKvm: 46| 2.40k| reinterpret_cast(ptr) + len) {} _ZN11ArduinoJson8V710HB426detail11deserializeINS1_16JsonDeserializerERNS0_12JsonDocumentEKhmJEvEENS0_20DeserializationErrorEOT0_PT1_T2_DpT3_: 77| 2.40k| Size inputSize, Args... args) { 78| 2.40k| return doDeserialize(dst, makeReader(input, size_t(inputSize)), 79| 2.40k| makeDeserializationOptions(args...)); 80| 2.40k|} _ZN11ArduinoJson8V710HB426detail13doDeserializeINS1_16JsonDeserializerERNS0_12JsonDocumentENS1_13BoundedReaderIPKhvEENS1_22DeserializationOptionsINS1_14AllowAllFilterEEEEENS0_20DeserializationErrorEOT0_T1_T2_: 50| 2.40k| TOptions options) { 51| 2.40k| auto data = VariantAttorney::getOrCreateData(dst); 52| 2.40k| if (!data) ------------------ | Branch (52:7): [True: 0, False: 2.40k] ------------------ 53| 0| return DeserializationError::NoMemory; 54| 2.40k| auto resources = VariantAttorney::getResourceManager(dst); 55| 2.40k| dst.clear(); 56| 2.40k| auto err = TDeserializer(resources, reader) 57| 2.40k| .parse(*data, options.filter, options.nestingLimit); 58| 2.40k| shrinkJsonDocument(dst); 59| 2.40k| return err; 60| 2.40k|} _ZN11ArduinoJson8V710HB426detail18shrinkJsonDocumentERNS0_12JsonDocumentE: 42| 2.40k|inline void shrinkJsonDocument(JsonDocument& doc) { 43| 2.40k| doc.shrinkToFit(); 44| 2.40k|} _ZN11ArduinoJson8V710HB4212JsonDocumentC2EPNS0_9AllocatorE: 25| 2.40k| : resources_(alloc) {} _ZNK11ArduinoJson8V710HB4212JsonDocumentcvNS0_16JsonVariantConstEEv: 312| 926| operator JsonVariantConst() const { 313| 926| return getVariant(); 314| 926| } _ZNK11ArduinoJson8V710HB4212JsonDocument10getVariantEv: 378| 926| JsonVariantConst getVariant() const { 379| 926| return JsonVariantConst(&data_, &resources_); 380| 926| } _ZN11ArduinoJson8V710HB4212JsonDocument15getOrCreateDataEv: 394| 2.40k| detail::VariantData* getOrCreateData() { 395| 2.40k| return &data_; 396| 2.40k| } _ZN11ArduinoJson8V710HB4212JsonDocument18getResourceManagerEv: 382| 2.40k| detail::ResourceManager* getResourceManager() { 383| 2.40k| return &resources_; 384| 2.40k| } _ZN11ArduinoJson8V710HB4212JsonDocument5clearEv: 88| 2.40k| void clear() { 89| 2.40k| resources_.clear(); 90| 2.40k| data_.reset(); 91| 2.40k| } _ZN11ArduinoJson8V710HB4212JsonDocument11shrinkToFitEv: 68| 2.40k| void shrinkToFit() { 69| 2.40k| resources_.shrinkToFit(); 70| 2.40k| } _ZN11ArduinoJson8V710HB426detail14EscapeSequence10escapeCharEc: 14| 1.16k| static char escapeChar(char c) { 15| 1.16k| const char* p = escapeTable(true); 16| 7.97k| while (p[0] && p[1] != c) { ------------------ | Branch (16:12): [True: 7.22k, False: 745] | Branch (16:20): [True: 6.80k, False: 419] ------------------ 17| 6.80k| p += 2; 18| 6.80k| } 19| 1.16k| return p[0]; 20| 1.16k| } _ZN11ArduinoJson8V710HB426detail14EscapeSequence11escapeTableEb: 35| 1.27k| static const char* escapeTable(bool excludeSolidus) { 36| 1.27k| return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; ------------------ | Branch (36:41): [True: 1.16k, False: 112] ------------------ 37| 1.27k| } _ZN11ArduinoJson8V710HB426detail14EscapeSequence12unescapeCharEc: 23| 112| static char unescapeChar(char c) { 24| 112| const char* p = escapeTable(false); 25| 620| for (;;) { 26| 620| if (p[0] == '\0') ------------------ | Branch (26:11): [True: 11, False: 609] ------------------ 27| 11| return 0; 28| 609| if (p[0] == c) ------------------ | Branch (28:11): [True: 101, False: 508] ------------------ 29| 101| return p[1]; 30| 508| p += 2; 31| 508| } 32| 112| } _ZN11ArduinoJson8V710HB4215deserializeJsonIRNS0_12JsonDocumentEKhJRmEEENS0_6detail9enable_ifIXsr6detail26is_deserialize_destinationIT_EE5valueENS0_20DeserializationErrorEE4typeEOS8_PT0_DpOT1_: 714| 2.40k|deserializeJson(TDestination&& dst, TChar* input, Args&&... args) { 715| 2.40k| using namespace detail; 716| 2.40k| return deserialize(detail::forward(dst), 717| 2.40k| input, detail::forward(args)...); 718| 2.40k|} _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEEC2EPNS1_15ResourceManagerES6_: 28| 2.40k| resources_(resources) {} _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE5parseINS1_14AllowAllFilterEEENS0_20DeserializationErrorERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 32| 2.40k| DeserializationOption::NestingLimit nestingLimit) { 33| 2.40k| DeserializationError::Code err; 34| | 35| 2.40k| err = parseVariant(variant, filter, nestingLimit); 36| | 37| 2.40k| if (!err && latch_.last() != 0 && variant.isFloat()) { ------------------ | Branch (37:9): [True: 935, False: 1.46k] | Branch (37:17): [True: 276, False: 659] | Branch (37:39): [True: 9, False: 267] ------------------ 38| | // We don't detect trailing characters earlier, so we need to check now 39| 9| return DeserializationError::InvalidInput; 40| 9| } 41| | 42| 2.39k| return err; 43| 2.40k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE12parseVariantINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_11VariantDataET_NS0_21DeserializationOption12NestingLimitE: 64| 13.6k| DeserializationOption::NestingLimit nestingLimit) { 65| 13.6k| DeserializationError::Code err; 66| | 67| 13.6k| err = skipSpacesAndComments(); 68| 13.6k| if (err) ------------------ | Branch (68:9): [True: 282, False: 13.3k] ------------------ 69| 282| return err; 70| | 71| 13.3k| switch (current()) { 72| 2.03k| case '[': ------------------ | Branch (72:7): [True: 2.03k, False: 11.3k] ------------------ 73| 2.03k| if (filter.allowArray()) ------------------ | Branch (73:13): [True: 2.03k, False: 0] ------------------ 74| 2.03k| return parseArray(variant.toArray(), filter, nestingLimit); 75| 0| else 76| 0| return skipArray(nestingLimit); 77| | 78| 1.83k| case '{': ------------------ | Branch (78:7): [True: 1.83k, False: 11.5k] ------------------ 79| 1.83k| if (filter.allowObject()) ------------------ | Branch (79:13): [True: 1.83k, False: 0] ------------------ 80| 1.83k| return parseObject(variant.toObject(), filter, nestingLimit); 81| 0| else 82| 0| return skipObject(nestingLimit); 83| | 84| 910| case '\"': ------------------ | Branch (84:7): [True: 910, False: 12.4k] ------------------ 85| 1.30k| case '\'': ------------------ | Branch (85:7): [True: 393, False: 12.9k] ------------------ 86| 1.30k| if (filter.allowValue()) ------------------ | Branch (86:13): [True: 1.30k, False: 0] ------------------ 87| 1.30k| return parseStringValue(variant); 88| 0| else 89| 0| return skipQuotedString(); 90| | 91| 278| case 't': ------------------ | Branch (91:7): [True: 278, False: 13.0k] ------------------ 92| 278| if (filter.allowValue()) ------------------ | Branch (92:13): [True: 278, False: 0] ------------------ 93| 278| variant.setBoolean(true); 94| 278| return skipKeyword("true"); 95| | 96| 247| case 'f': ------------------ | Branch (96:7): [True: 247, False: 13.1k] ------------------ 97| 247| if (filter.allowValue()) ------------------ | Branch (97:13): [True: 247, False: 0] ------------------ 98| 247| variant.setBoolean(false); 99| 247| return skipKeyword("false"); 100| | 101| 281| case 'n': ------------------ | Branch (101:7): [True: 281, False: 13.0k] ------------------ 102| | // the variant should already by null, except if the same object key was 103| | // used twice, as in {"a":1,"a":null} 104| 281| return skipKeyword("null"); 105| | 106| 7.40k| default: ------------------ | Branch (106:7): [True: 7.40k, False: 5.97k] ------------------ 107| 7.40k| if (filter.allowValue()) ------------------ | Branch (107:13): [True: 7.40k, False: 0] ------------------ 108| 7.40k| return parseNumericValue(variant); 109| 0| else 110| 0| return skipNumericValue(); 111| 13.3k| } 112| 13.3k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE21skipSpacesAndCommentsEv: 606| 32.1k| DeserializationError::Code skipSpacesAndComments() { 607| 38.2k| for (;;) { 608| 38.2k| switch (current()) { 609| | // end of string 610| 860| case '\0': ------------------ | Branch (610:9): [True: 860, False: 37.3k] ------------------ 611| 860| return foundSomething_ ? DeserializationError::IncompleteInput ------------------ | Branch (611:18): [True: 827, False: 33] ------------------ 612| 860| : DeserializationError::EmptyInput; 613| | 614| | // spaces 615| 1.56k| case ' ': ------------------ | Branch (615:9): [True: 1.56k, False: 36.6k] ------------------ 616| 3.14k| case '\t': ------------------ | Branch (616:9): [True: 1.58k, False: 36.6k] ------------------ 617| 4.56k| case '\r': ------------------ | Branch (617:9): [True: 1.42k, False: 36.8k] ------------------ 618| 6.06k| case '\n': ------------------ | Branch (618:9): [True: 1.50k, False: 36.7k] ------------------ 619| 6.06k| move(); 620| 6.06k| continue; 621| | 622| |#if ARDUINOJSON_ENABLE_COMMENTS 623| | // comments 624| | case '/': 625| | move(); // skip '/' 626| | switch (current()) { 627| | // block comment 628| | case '*': { 629| | move(); // skip '*' 630| | bool wasStar = false; 631| | for (;;) { 632| | char c = current(); 633| | if (c == '\0') 634| | return DeserializationError::IncompleteInput; 635| | if (c == '/' && wasStar) { 636| | move(); 637| | break; 638| | } 639| | wasStar = c == '*'; 640| | move(); 641| | } 642| | break; 643| | } 644| | 645| | // trailing comment 646| | case '/': 647| | // no need to skip "//" 648| | for (;;) { 649| | move(); 650| | char c = current(); 651| | if (c == '\0') 652| | return DeserializationError::IncompleteInput; 653| | if (c == '\n') 654| | break; 655| | } 656| | break; 657| | 658| | // not a comment, just a '/' 659| | default: 660| | return DeserializationError::InvalidInput; 661| | } 662| | break; 663| |#endif 664| | 665| 31.3k| default: ------------------ | Branch (665:9): [True: 31.3k, False: 6.92k] ------------------ 666| 31.3k| foundSomething_ = true; 667| 31.3k| return DeserializationError::Ok; 668| 38.2k| } 669| 38.2k| } 670| 32.1k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE4moveEv: 50| 70.0k| void move() { 51| 70.0k| latch_.clear(); 52| 70.0k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE7currentEv: 46| 140k| char current() { 47| 140k| return latch_.current(); 48| 140k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE10parseArrayINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_9ArrayDataET_NS0_21DeserializationOption12NestingLimitE: 150| 2.03k| DeserializationOption::NestingLimit nestingLimit) { 151| 2.03k| DeserializationError::Code err; 152| | 153| 2.03k| if (nestingLimit.reached()) ------------------ | Branch (153:9): [True: 4, False: 2.02k] ------------------ 154| 4| return DeserializationError::TooDeep; 155| | 156| | // Skip opening braket 157| 2.02k| ARDUINOJSON_ASSERT(current() == '['); ------------------ | | 11| 2.02k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 158| 2.02k| move(); 159| | 160| | // Skip spaces 161| 2.02k| err = skipSpacesAndComments(); 162| 2.02k| if (err) ------------------ | Branch (162:9): [True: 42, False: 1.98k] ------------------ 163| 42| return err; 164| | 165| | // Empty array? 166| 1.98k| if (eat(']')) ------------------ | Branch (166:9): [True: 177, False: 1.80k] ------------------ 167| 177| return DeserializationError::Ok; 168| | 169| 1.80k| TFilter elementFilter = filter[0UL]; 170| | 171| | // Read each value 172| 8.29k| for (;;) { 173| 8.29k| if (elementFilter.allow()) { ------------------ | Branch (173:11): [True: 8.29k, False: 0] ------------------ 174| | // Allocate slot in array 175| 8.29k| VariantData* value = array.addElement(resources_); 176| 8.29k| if (!value) ------------------ | Branch (176:13): [True: 0, False: 8.29k] ------------------ 177| 0| return DeserializationError::NoMemory; 178| | 179| | // 1 - Parse value 180| 8.29k| err = parseVariant(*value, elementFilter, nestingLimit.decrement()); 181| 8.29k| if (err) ------------------ | Branch (181:13): [True: 592, False: 7.70k] ------------------ 182| 592| return err; 183| 8.29k| } else { 184| 0| err = skipVariant(nestingLimit.decrement()); 185| 0| if (err) ------------------ | Branch (185:13): [True: 0, False: 0] ------------------ 186| 0| return err; 187| 0| } 188| | 189| | // 2 - Skip spaces 190| 7.70k| err = skipSpacesAndComments(); 191| 7.70k| if (err) ------------------ | Branch (191:11): [True: 246, False: 7.45k] ------------------ 192| 246| return err; 193| | 194| | // 3 - More values? 195| 7.45k| if (eat(']')) ------------------ | Branch (195:11): [True: 949, False: 6.50k] ------------------ 196| 949| return DeserializationError::Ok; 197| 6.50k| if (!eat(',')) ------------------ | Branch (197:11): [True: 21, False: 6.48k] ------------------ 198| 21| return DeserializationError::InvalidInput; 199| 6.50k| } 200| 1.80k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE3eatEc: 54| 24.5k| bool eat(char charToSkip) { 55| 24.5k| if (current() != charToSkip) ------------------ | Branch (55:9): [True: 11.6k, False: 12.9k] ------------------ 56| 11.6k| return false; 57| 12.9k| move(); 58| 12.9k| return true; 59| 24.5k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE11parseObjectINS1_14AllowAllFilterEEENS0_20DeserializationError4CodeERNS1_10ObjectDataET_NS0_21DeserializationOption12NestingLimitE: 236| 1.83k| DeserializationOption::NestingLimit nestingLimit) { 237| 1.83k| DeserializationError::Code err; 238| | 239| 1.83k| if (nestingLimit.reached()) ------------------ | Branch (239:9): [True: 2, False: 1.83k] ------------------ 240| 2| return DeserializationError::TooDeep; 241| | 242| | // Skip opening brace 243| 1.83k| ARDUINOJSON_ASSERT(current() == '{'); ------------------ | | 11| 1.83k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 244| 1.83k| move(); 245| | 246| | // Skip spaces 247| 1.83k| err = skipSpacesAndComments(); 248| 1.83k| if (err) ------------------ | Branch (248:9): [True: 42, False: 1.78k] ------------------ 249| 42| return err; 250| | 251| | // Empty object? 252| 1.78k| if (eat('}')) ------------------ | Branch (252:9): [True: 249, False: 1.53k] ------------------ 253| 249| return DeserializationError::Ok; 254| | 255| | // Read each key value pair 256| 3.17k| for (;;) { 257| | // Parse key 258| 3.17k| err = parseKey(); 259| 3.17k| if (err) ------------------ | Branch (259:11): [True: 55, False: 3.12k] ------------------ 260| 55| return err; 261| | 262| | // Skip spaces 263| 3.12k| err = skipSpacesAndComments(); 264| 3.12k| if (err) ------------------ | Branch (264:11): [True: 133, False: 2.98k] ------------------ 265| 133| return err; 266| | 267| | // Colon 268| 2.98k| if (!eat(':')) ------------------ | Branch (268:11): [True: 23, False: 2.96k] ------------------ 269| 23| return DeserializationError::InvalidInput; 270| | 271| 2.96k| JsonString key = stringBuilder_.str(); 272| | 273| 2.96k| TFilter memberFilter = filter[key.c_str()]; 274| | 275| 2.96k| if (memberFilter.allow()) { ------------------ | Branch (275:11): [True: 2.96k, False: 0] ------------------ 276| 2.96k| auto member = object.getMember(adaptString(key.c_str()), resources_); 277| 2.96k| if (!member) { ------------------ | Branch (277:13): [True: 2.46k, False: 506] ------------------ 278| | // Save key in memory pool. 279| 2.46k| auto savedKey = stringBuilder_.save(); 280| | 281| | // Allocate slot in object 282| 2.46k| member = object.addMember(savedKey, resources_); 283| 2.46k| if (!member) ------------------ | Branch (283:15): [True: 0, False: 2.46k] ------------------ 284| 0| return DeserializationError::NoMemory; 285| 2.46k| } else { 286| 506| member->clear(resources_); 287| 506| } 288| | 289| | // Parse value 290| 2.96k| err = parseVariant(*member, memberFilter, nestingLimit.decrement()); 291| 2.96k| if (err) ------------------ | Branch (291:13): [True: 792, False: 2.17k] ------------------ 292| 792| return err; 293| 2.96k| } else { 294| 0| err = skipVariant(nestingLimit.decrement()); 295| 0| if (err) ------------------ | Branch (295:13): [True: 0, False: 0] ------------------ 296| 0| return err; 297| 0| } 298| | 299| | // Skip spaces 300| 2.17k| err = skipSpacesAndComments(); 301| 2.17k| if (err) ------------------ | Branch (301:11): [True: 75, False: 2.09k] ------------------ 302| 75| return err; 303| | 304| | // More keys/values? 305| 2.09k| if (eat('}')) ------------------ | Branch (305:11): [True: 397, False: 1.70k] ------------------ 306| 397| return DeserializationError::Ok; 307| 1.70k| if (!eat(',')) ------------------ | Branch (307:11): [True: 24, False: 1.67k] ------------------ 308| 24| return DeserializationError::InvalidInput; 309| | 310| | // Skip spaces 311| 1.67k| err = skipSpacesAndComments(); 312| 1.67k| if (err) ------------------ | Branch (312:11): [True: 40, False: 1.63k] ------------------ 313| 40| return err; 314| 1.67k| } 315| 1.53k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE8parseKeyEv: 375| 3.17k| DeserializationError::Code parseKey() { 376| 3.17k| stringBuilder_.startString(); 377| 3.17k| if (isQuote(current())) { ------------------ | Branch (377:9): [True: 212, False: 2.96k] ------------------ 378| 212| return parseQuotedString(); 379| 2.96k| } else { 380| 2.96k| return parseNonQuotedString(); 381| 2.96k| } 382| 3.17k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE7isQuoteEc: 595| 3.17k| static inline bool isQuote(char c) { 596| 3.17k| return c == '\'' || c == '\"'; ------------------ | Branch (596:12): [True: 152, False: 3.02k] | Branch (596:25): [True: 60, False: 2.96k] ------------------ 597| 3.17k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE17parseQuotedStringEv: 398| 1.51k| DeserializationError::Code parseQuotedString() { 399| 1.51k|#if ARDUINOJSON_DECODE_UNICODE 400| 1.51k| Utf16::Codepoint codepoint; 401| 1.51k| DeserializationError::Code err; 402| 1.51k|#endif 403| 1.51k| const char stopChar = current(); 404| | 405| 1.51k| move(); 406| 6.27k| for (;;) { 407| 6.27k| char c = current(); 408| 6.27k| move(); 409| 6.27k| if (c == stopChar) ------------------ | Branch (409:11): [True: 1.27k, False: 4.99k] ------------------ 410| 1.27k| break; 411| | 412| 4.99k| if (c == '\0') ------------------ | Branch (412:11): [True: 200, False: 4.79k] ------------------ 413| 200| return DeserializationError::IncompleteInput; 414| | 415| 4.79k| if (c == '\\') { ------------------ | Branch (415:11): [True: 755, False: 4.04k] ------------------ 416| 755| c = current(); 417| | 418| 755| if (c == '\0') ------------------ | Branch (418:13): [True: 2, False: 753] ------------------ 419| 2| return DeserializationError::IncompleteInput; 420| | 421| 753| if (c == 'u') { ------------------ | Branch (421:13): [True: 641, False: 112] ------------------ 422| 641|#if ARDUINOJSON_DECODE_UNICODE 423| 641| move(); 424| 641| uint16_t codeunit; 425| 641| err = parseHex4(codeunit); 426| 641| if (err) ------------------ | Branch (426:15): [True: 26, False: 615] ------------------ 427| 26| return err; 428| 615| if (codepoint.append(codeunit)) ------------------ | Branch (428:15): [True: 538, False: 77] ------------------ 429| 538| Utf8::encodeCodepoint(codepoint.value(), stringBuilder_); 430| |#else 431| | stringBuilder_.append('\\'); 432| |#endif 433| 615| continue; 434| 641| } 435| | 436| | // replace char 437| 112| c = EscapeSequence::unescapeChar(c); 438| 112| if (c == '\0') ------------------ | Branch (438:13): [True: 11, False: 101] ------------------ 439| 11| return DeserializationError::InvalidInput; 440| 101| move(); 441| 101| } 442| | 443| 4.14k| stringBuilder_.append(c); 444| 4.14k| } 445| | 446| 1.27k| if (!stringBuilder_.isValid()) ------------------ | Branch (446:9): [True: 0, False: 1.27k] ------------------ 447| 0| return DeserializationError::NoMemory; 448| | 449| 1.27k| return DeserializationError::Ok; 450| 1.27k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9parseHex4ERt: 562| 641| DeserializationError::Code parseHex4(uint16_t& result) { 563| 641| result = 0; 564| 3.12k| for (uint8_t i = 0; i < 4; ++i) { ------------------ | Branch (564:25): [True: 2.51k, False: 615] ------------------ 565| 2.51k| char digit = current(); 566| 2.51k| if (!digit) ------------------ | Branch (566:11): [True: 18, False: 2.49k] ------------------ 567| 18| return DeserializationError::IncompleteInput; 568| 2.49k| uint8_t value = decodeHex(digit); 569| 2.49k| if (value > 0x0F) ------------------ | Branch (569:11): [True: 8, False: 2.48k] ------------------ 570| 8| return DeserializationError::InvalidInput; 571| 2.48k| result = uint16_t((result << 4) | value); 572| 2.48k| move(); 573| 2.48k| } 574| 615| return DeserializationError::Ok; 575| 641| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9decodeHexEc: 599| 2.49k| static inline uint8_t decodeHex(char c) { 600| 2.49k| if (c < 'A') ------------------ | Branch (600:9): [True: 1.87k, False: 623] ------------------ 601| 1.87k| return uint8_t(c - '0'); 602| 623| c = char(c & ~0x20); // uppercase 603| 623| return uint8_t(c - 'A' + 10); 604| 2.49k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE20parseNonQuotedStringEv: 452| 2.96k| DeserializationError::Code parseNonQuotedString() { 453| 2.96k| char c = current(); 454| 2.96k| ARDUINOJSON_ASSERT(c); ------------------ | | 11| 2.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 455| | 456| 2.96k| if (canBeInNonQuotedString(c)) { // no quotes ------------------ | Branch (456:9): [True: 2.91k, False: 47] ------------------ 457| 5.10k| do { 458| 5.10k| move(); 459| 5.10k| stringBuilder_.append(c); 460| 5.10k| c = current(); 461| 5.10k| } while (canBeInNonQuotedString(c)); ------------------ | Branch (461:16): [True: 2.18k, False: 2.91k] ------------------ 462| 2.91k| } else { 463| 47| return DeserializationError::InvalidInput; 464| 47| } 465| | 466| 2.91k| if (!stringBuilder_.isValid()) ------------------ | Branch (466:9): [True: 0, False: 2.91k] ------------------ 467| 0| return DeserializationError::NoMemory; 468| | 469| 2.91k| return DeserializationError::Ok; 470| 2.91k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE22canBeInNonQuotedStringEc: 590| 8.06k| static inline bool canBeInNonQuotedString(char c) { 591| 8.06k| return isBetween(c, '0', '9') || isBetween(c, '_', 'z') || ------------------ | Branch (591:12): [True: 1.82k, False: 6.23k] | Branch (591:38): [True: 1.46k, False: 4.76k] ------------------ 592| 8.06k| isBetween(c, 'A', 'Z'); ------------------ | Branch (592:12): [True: 1.80k, False: 2.96k] ------------------ 593| 8.06k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE9isBetweenEccc: 577| 54.3k| static inline bool isBetween(char c, char min, char max) { 578| 54.3k| return min <= c && c <= max; ------------------ | Branch (578:12): [True: 34.3k, False: 20.0k] | Branch (578:24): [True: 25.6k, False: 8.69k] ------------------ 579| 54.3k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE16parseStringValueERNS1_11VariantDataE: 384| 1.30k| DeserializationError::Code parseStringValue(VariantData& variant) { 385| 1.30k| DeserializationError::Code err; 386| | 387| 1.30k| stringBuilder_.startString(); 388| | 389| 1.30k| err = parseQuotedString(); 390| 1.30k| if (err) ------------------ | Branch (390:9): [True: 231, False: 1.07k] ------------------ 391| 231| return err; 392| | 393| 1.07k| variant.setOwnedString(stringBuilder_.save()); 394| | 395| 1.07k| return DeserializationError::Ok; 396| 1.30k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE11skipKeywordEPKc: 672| 806| DeserializationError::Code skipKeyword(const char* s) { 673| 4.02k| while (*s) { ------------------ | Branch (673:12): [True: 3.30k, False: 722] ------------------ 674| 3.30k| char c = current(); 675| 3.30k| if (c == '\0') ------------------ | Branch (675:11): [True: 39, False: 3.26k] ------------------ 676| 39| return DeserializationError::IncompleteInput; 677| 3.26k| if (*s != c) ------------------ | Branch (677:11): [True: 45, False: 3.22k] ------------------ 678| 45| return DeserializationError::InvalidInput; 679| 3.22k| ++s; 680| 3.22k| move(); 681| 3.22k| } 682| 722| return DeserializationError::Ok; 683| 806| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE17parseNumericValueERNS1_11VariantDataE: 509| 7.40k| DeserializationError::Code parseNumericValue(VariantData& result) { 510| 7.40k| uint8_t n = 0; 511| | 512| 7.40k| char c = current(); 513| 35.2k| while (canBeInNumber(c) && n < 63) { ------------------ | Branch (513:12): [True: 27.8k, False: 7.40k] | Branch (513:32): [True: 27.8k, False: 2] ------------------ 514| 27.8k| move(); 515| 27.8k| buffer_[n++] = c; 516| 27.8k| c = current(); 517| 27.8k| } 518| 7.40k| buffer_[n] = 0; 519| | 520| 7.40k| auto number = parseNumber(buffer_); 521| 7.40k| switch (number.type()) { 522| 1.67k| case NumberType::UnsignedInteger: ------------------ | Branch (522:7): [True: 1.67k, False: 5.73k] ------------------ 523| 1.67k| if (result.setInteger(number.asUnsignedInteger(), resources_)) ------------------ | Branch (523:13): [True: 1.67k, False: 0] ------------------ 524| 1.67k| return DeserializationError::Ok; 525| 0| else 526| 0| return DeserializationError::NoMemory; 527| | 528| 600| case NumberType::SignedInteger: ------------------ | Branch (528:7): [True: 600, False: 6.80k] ------------------ 529| 600| if (result.setInteger(number.asSignedInteger(), resources_)) ------------------ | Branch (529:13): [True: 600, False: 0] ------------------ 530| 600| return DeserializationError::Ok; 531| 0| else 532| 0| return DeserializationError::NoMemory; 533| | 534| 3.88k| case NumberType::Float: ------------------ | Branch (534:7): [True: 3.88k, False: 3.51k] ------------------ 535| 3.88k| if (result.setFloat(number.asFloat(), resources_)) ------------------ | Branch (535:13): [True: 3.88k, False: 0] ------------------ 536| 3.88k| return DeserializationError::Ok; 537| 0| else 538| 0| return DeserializationError::NoMemory; 539| | 540| 0|#if ARDUINOJSON_USE_DOUBLE 541| 1.08k| case NumberType::Double: ------------------ | Branch (541:7): [True: 1.08k, False: 6.32k] ------------------ 542| 1.08k| if (result.setFloat(number.asDouble(), resources_)) ------------------ | Branch (542:13): [True: 1.08k, False: 0] ------------------ 543| 1.08k| return DeserializationError::Ok; 544| 0| else 545| 0| return DeserializationError::NoMemory; 546| 0|#endif 547| | 548| 161| default: ------------------ | Branch (548:7): [True: 161, False: 7.24k] ------------------ 549| 161| return DeserializationError::InvalidInput; 550| 7.40k| } 551| 7.40k| } _ZN11ArduinoJson8V710HB426detail16JsonDeserializerINS1_13BoundedReaderIPKhvEEE13canBeInNumberEc: 581| 35.2k| static inline bool canBeInNumber(char c) { 582| 35.2k| return isBetween(c, '0', '9') || c == '+' || c == '-' || c == '.' || ------------------ | Branch (582:12): [True: 20.5k, False: 14.7k] | Branch (582:38): [True: 355, False: 14.3k] | Branch (582:50): [True: 1.51k, False: 12.8k] | Branch (582:62): [True: 3.39k, False: 9.49k] ------------------ 583| |#if ARDUINOJSON_ENABLE_NAN || ARDUINOJSON_ENABLE_INFINITY 584| | isBetween(c, 'A', 'Z') || isBetween(c, 'a', 'z'); 585| |#else 586| 35.2k| c == 'e' || c == 'E'; ------------------ | Branch (586:12): [True: 817, False: 8.67k] | Branch (586:24): [True: 1.27k, False: 7.40k] ------------------ 587| 35.2k|#endif 588| 35.2k| } _ZN11ArduinoJson8V710HB4213serializeJsonINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEENS0_6detail9enable_ifIXntsr6detail10is_pointerIT_EE5valueEmE4typeENS0_16JsonVariantConstERSB_: 134| 926|serializeJson(JsonVariantConst source, TDestination& destination) { 135| 926| using namespace detail; 136| 926| return serialize(source, destination); 137| 926|} _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_PKNS1_15ResourceManagerE: 20| 926| : formatter_(writer), resources_(resources) {} _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIfEENS1_9enable_ifIXsr17is_floating_pointIT_EE5valueEmE4typeESF_: 66| 1.23k| enable_if_t::value, size_t> visit(T value) { 67| 1.23k| formatter_.writeFloat(value); 68| 1.23k| return bytesWritten(); 69| 1.23k| } _ZNK11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 107| 3.82k| size_t bytesWritten() const { 108| 3.82k| return formatter_.bytesWritten(); 109| 3.82k| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitIdEENS1_9enable_ifIXsr17is_floating_pointIT_EE5valueEmE4typeESF_: 66| 419| enable_if_t::value, size_t> visit(T value) { 67| 419| formatter_.writeFloat(value); 68| 419| return bytesWritten(); 69| 419| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_9ArrayDataE: 22| 516| size_t visit(const ArrayData& array) { 23| 516| write('['); 24| | 25| 516| auto slotId = array.head(); 26| | 27| 2.97k| while (slotId != NULL_SLOT) { ------------------ | Branch (27:12): [True: 2.46k, False: 516] ------------------ 28| 2.46k| auto slot = resources_->getVariant(slotId); 29| | 30| 2.46k| slot->accept(*this, resources_); 31| | 32| 2.46k| slotId = slot->next(); 33| | 34| 2.46k| if (slotId != NULL_SLOT) ------------------ | Branch (34:11): [True: 2.02k, False: 440] ------------------ 35| 2.02k| write(','); 36| 2.46k| } 37| | 38| 516| write(']'); 39| 516| return bytesWritten(); 40| 516| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEc: 111| 3.74k| void write(char c) { 112| 3.74k| formatter_.writeRaw(c); 113| 3.74k| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitERKNS1_10ObjectDataE: 42| 189| size_t visit(const ObjectData& object) { 43| 189| write('{'); 44| | 45| 189| auto slotId = object.head(); 46| | 47| 189| bool isKey = true; 48| | 49| 621| while (slotId != NULL_SLOT) { ------------------ | Branch (49:12): [True: 432, False: 189] ------------------ 50| 432| auto slot = resources_->getVariant(slotId); 51| 432| slot->accept(*this, resources_); 52| | 53| 432| slotId = slot->next(); 54| | 55| 432| if (slotId != NULL_SLOT) ------------------ | Branch (55:11): [True: 310, False: 122] ------------------ 56| 310| write(isKey ? ':' : ','); ------------------ | Branch (56:15): [True: 216, False: 94] ------------------ 57| | 58| 432| isKey = !isKey; 59| 432| } 60| | 61| 189| write('}'); 62| 189| return bytesWritten(); 63| 189| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitENS0_10JsonStringE: 76| 352| size_t visit(JsonString value) { 77| 352| formatter_.writeString(value.c_str(), value.size()); 78| 352| return bytesWritten(); 79| 352| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEl: 86| 439| size_t visit(JsonInteger value) { 87| 439| formatter_.writeInteger(value); 88| 439| return bytesWritten(); 89| 439| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEm: 91| 475| size_t visit(JsonUInt value) { 92| 475| formatter_.writeInteger(value); 93| 475| return bytesWritten(); 94| 475| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEb: 96| 132| size_t visit(bool value) { 97| 132| formatter_.writeBoolean(value); 98| 132| return bytesWritten(); 99| 132| } _ZN11ArduinoJson8V710HB426detail14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5visitEDn: 101| 66| size_t visit(nullptr_t) { 102| 66| formatter_.writeRaw("null"); 103| 66| return bytesWritten(); 104| 66| } _ZN11ArduinoJson8V710HB426detail5LatchINS1_13BoundedReaderIPKhvEEEC2ES6_: 14| 2.40k| Latch(TReader reader) : reader_(reader), loaded_(false) { 15| 2.40k|#if ARDUINOJSON_DEBUG 16| 2.40k| ended_ = false; 17| 2.40k|#endif 18| 2.40k| } _ZN11ArduinoJson8V710HB426detail5LatchINS1_13BoundedReaderIPKhvEEE5clearEv: 20| 70.0k| void clear() { 21| 70.0k| loaded_ = false; 22| 70.0k| } _ZN11ArduinoJson8V710HB426detail5LatchINS1_13BoundedReaderIPKhvEEE7currentEv: 28| 140k| FORCE_INLINE char current() { 29| 140k| if (!loaded_) { ------------------ | Branch (29:9): [True: 71.9k, False: 68.9k] ------------------ 30| 71.9k| load(); 31| 71.9k| } 32| 140k| return current_; 33| 140k| } _ZN11ArduinoJson8V710HB426detail5LatchINS1_13BoundedReaderIPKhvEEE4loadEv: 36| 71.9k| void load() { 37| 71.9k| ARDUINOJSON_ASSERT(!ended_); ------------------ | | 11| 71.9k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 38| 71.9k| int c = reader_.read(); 39| 71.9k|#if ARDUINOJSON_DEBUG 40| 71.9k| if (c <= 0) ------------------ | Branch (40:9): [True: 1.88k, False: 70.0k] ------------------ 41| 1.88k| ended_ = true; 42| 71.9k|#endif 43| 71.9k| current_ = static_cast(c > 0 ? c : 0); ------------------ | Branch (43:34): [True: 70.0k, False: 1.88k] ------------------ 44| 71.9k| loaded_ = true; 45| 71.9k| } _ZNK11ArduinoJson8V710HB426detail5LatchINS1_13BoundedReaderIPKhvEEE4lastEv: 24| 935| int last() const { 25| 935| return current_; 26| 935| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ESB_: 23| 926| explicit TextFormatter(TWriter writer) : writer_(writer) {} _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatIfEEvT_: 68| 1.23k| void writeFloat(T value) { 69| 1.23k| writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6); ------------------ | Branch (69:34): [Folded - Ignored] ------------------ 70| 1.23k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatEda: 72| 1.65k| void writeFloat(JsonFloat value, int8_t decimalPlaces) { 73| 1.65k| if (isnan(value)) ------------------ | Branch (73:9): [True: 0, False: 1.65k] ------------------ 74| 0| return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null"); ------------------ | | 219| 0|# define ARDUINOJSON_ENABLE_NAN 0 | | ------------------ | | | Branch (219:34): [Folded - Ignored] | | ------------------ ------------------ 75| | 76| |#if ARDUINOJSON_ENABLE_INFINITY 77| | if (value < 0.0) { 78| | writeRaw('-'); 79| | value = -value; 80| | } 81| | 82| | if (isinf(value)) 83| | return writeRaw("Infinity"); 84| |#else 85| 1.65k| if (isinf(value)) ------------------ | Branch (85:9): [True: 70, False: 1.58k] ------------------ 86| 70| return writeRaw("null"); 87| | 88| 1.58k| if (value < 0.0) { ------------------ | Branch (88:9): [True: 71, False: 1.51k] ------------------ 89| 71| writeRaw('-'); 90| 71| value = -value; 91| 71| } 92| 1.58k|#endif 93| | 94| 1.58k| auto parts = decomposeFloat(value, decimalPlaces); 95| | 96| 1.58k| writeInteger(parts.integral); 97| 1.58k| if (parts.decimalPlaces) ------------------ | Branch (97:9): [True: 257, False: 1.32k] ------------------ 98| 257| writeDecimals(parts.decimal, parts.decimalPlaces); 99| | 100| 1.58k| if (parts.exponent) { ------------------ | Branch (100:9): [True: 582, False: 1.00k] ------------------ 101| 582| writeRaw('e'); 102| 582| writeInteger(parts.exponent); 103| 582| } 104| 1.58k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKc: 152| 334| void writeRaw(const char* s) { 153| 334| writer_.write(reinterpret_cast(s), strlen(s)); 154| 334| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEc: 169| 7.10k| void writeRaw(char c) { 170| 7.10k| writer_.write(static_cast(c)); 171| 7.10k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIjEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 1.58k| enable_if_t::value> writeInteger(T value) { 121| 1.58k| char buffer[22]; 122| 1.58k| char* end = buffer + sizeof(buffer); 123| 1.58k| char* begin = end; 124| | 125| | // write the string in reverse order 126| 2.71k| do { 127| 2.71k| *--begin = char(value % 10 + '0'); 128| 2.71k| value = T(value / 10); 129| 2.71k| } while (value); ------------------ | Branch (129:14): [True: 1.13k, False: 1.58k] ------------------ 130| | 131| | // and dump it in the right order 132| 1.58k| writeRaw(begin, end); 133| 1.58k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE8writeRawEPKcSE_: 160| 3.33k| void writeRaw(const char* begin, const char* end) { 161| 3.33k| writer_.write(reinterpret_cast(begin), 162| 3.33k| static_cast(end - begin)); 163| 3.33k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE13writeDecimalsEja: 135| 257| void writeDecimals(uint32_t value, int8_t width) { 136| | // buffer should be big enough for all digits and the dot 137| 257| char buffer[16]; 138| 257| char* end = buffer + sizeof(buffer); 139| 257| char* begin = end; 140| | 141| | // write the string in reverse order 142| 1.57k| while (width--) { ------------------ | Branch (142:12): [True: 1.31k, False: 257] ------------------ 143| 1.31k| *--begin = char(value % 10 + '0'); 144| 1.31k| value /= 10; 145| 1.31k| } 146| 257| *--begin = '.'; 147| | 148| | // and dump it in the right order 149| 257| writeRaw(begin, end); 150| 257| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIsEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 107| 582| enable_if_t::value> writeInteger(T value) { 108| 582| typedef make_unsigned_t unsigned_type; 109| 582| unsigned_type unsigned_value; 110| 582| if (value < 0) { ------------------ | Branch (110:9): [True: 116, False: 466] ------------------ 111| 116| writeRaw('-'); 112| 116| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 113| 466| } else { 114| 466| unsigned_value = unsigned_type(value); 115| 466| } 116| 582| writeInteger(unsigned_value); 117| 582| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerItEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 582| enable_if_t::value> writeInteger(T value) { 121| 582| char buffer[22]; 122| 582| char* end = buffer + sizeof(buffer); 123| 582| char* begin = end; 124| | 125| | // write the string in reverse order 126| 1.08k| do { 127| 1.08k| *--begin = char(value % 10 + '0'); 128| 1.08k| value = T(value / 10); 129| 1.08k| } while (value); ------------------ | Branch (129:14): [True: 498, False: 582] ------------------ 130| | 131| | // and dump it in the right order 132| 582| writeRaw(begin, end); 133| 582| } _ZNK11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12bytesWrittenEv: 28| 3.82k| size_t bytesWritten() const { 29| 3.82k| return writer_.count(); 30| 3.82k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE10writeFloatIdEEvT_: 68| 419| void writeFloat(T value) { 69| 419| writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6); ------------------ | Branch (69:34): [Folded - Ignored] ------------------ 70| 419| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE11writeStringEPKcm: 47| 352| void writeString(const char* value, size_t n) { 48| 352| ARDUINOJSON_ASSERT(value != NULL); ------------------ | | 11| 352|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 49| 352| writeRaw('\"'); 50| 1.51k| while (n--) ------------------ | Branch (50:12): [True: 1.16k, False: 352] ------------------ 51| 1.16k| writeChar(*value++); 52| 352| writeRaw('\"'); 53| 352| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE9writeCharEc: 55| 1.16k| void writeChar(char c) { 56| 1.16k| char specialChar = EscapeSequence::escapeChar(c); 57| 1.16k| if (specialChar) { ------------------ | Branch (57:9): [True: 419, False: 745] ------------------ 58| 419| writeRaw('\\'); 59| 419| writeRaw(specialChar); 60| 745| } else if (c) { ------------------ | Branch (60:16): [True: 679, False: 66] ------------------ 61| 679| writeRaw(c); 62| 679| } else { 63| 66| writeRaw("\\u0000"); 64| 66| } 65| 1.16k| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEvE4typeESF_: 107| 439| enable_if_t::value> writeInteger(T value) { 108| 439| typedef make_unsigned_t unsigned_type; 109| 439| unsigned_type unsigned_value; 110| 439| if (value < 0) { ------------------ | Branch (110:9): [True: 371, False: 68] ------------------ 111| 371| writeRaw('-'); 112| 371| unsigned_value = unsigned_type(unsigned_type(~value) + 1); 113| 371| } else { 114| 68| unsigned_value = unsigned_type(value); 115| 68| } 116| 439| writeInteger(unsigned_value); 117| 439| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEvE4typeESF_: 120| 914| enable_if_t::value> writeInteger(T value) { 121| 914| char buffer[22]; 122| 914| char* end = buffer + sizeof(buffer); 123| 914| char* begin = end; 124| | 125| | // write the string in reverse order 126| 7.39k| do { 127| 7.39k| *--begin = char(value % 10 + '0'); 128| 7.39k| value = T(value / 10); 129| 7.39k| } while (value); ------------------ | Branch (129:14): [True: 6.48k, False: 914] ------------------ 130| | 131| | // and dump it in the right order 132| 914| writeRaw(begin, end); 133| 914| } _ZN11ArduinoJson8V710HB426detail13TextFormatterINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE12writeBooleanEb: 32| 132| void writeBoolean(bool value) { 33| 132| if (value) ------------------ | Branch (33:9): [True: 66, False: 66] ------------------ 34| 66| writeRaw("true"); 35| 66| else 36| 66| writeRaw("false"); 37| 132| } _ZN11ArduinoJson8V710HB426detail5Utf169CodepointC2Ev: 34| 1.51k| Codepoint() : highSurrogate_(0), codepoint_(0) {} _ZN11ArduinoJson8V710HB426detail5Utf169Codepoint6appendEt: 36| 615| bool append(uint16_t codeunit) { 37| 615| if (isHighSurrogate(codeunit)) { ------------------ | Branch (37:9): [True: 77, False: 538] ------------------ 38| 77| highSurrogate_ = codeunit & 0x3FF; 39| 77| return false; 40| 77| } 41| | 42| 538| if (isLowSurrogate(codeunit)) { ------------------ | Branch (42:9): [True: 163, False: 375] ------------------ 43| 163| codepoint_ = 44| 163| uint32_t(0x10000 + ((highSurrogate_ << 10) | (codeunit & 0x3FF))); 45| 163| return true; 46| 163| } 47| | 48| 375| codepoint_ = codeunit; 49| 375| return true; 50| 538| } _ZN11ArduinoJson8V710HB426detail5Utf1615isHighSurrogateEt: 24| 615|inline bool isHighSurrogate(uint16_t codeunit) { 25| 615| return codeunit >= 0xD800 && codeunit < 0xDC00; ------------------ | Branch (25:10): [True: 271, False: 344] | Branch (25:32): [True: 77, False: 194] ------------------ 26| 615|} _ZN11ArduinoJson8V710HB426detail5Utf1614isLowSurrogateEt: 28| 538|inline bool isLowSurrogate(uint16_t codeunit) { 29| 538| return codeunit >= 0xDC00 && codeunit < 0xE000; ------------------ | Branch (29:10): [True: 194, False: 344] | Branch (29:32): [True: 163, False: 31] ------------------ 30| 538|} _ZNK11ArduinoJson8V710HB426detail5Utf169Codepoint5valueEv: 52| 538| uint32_t value() const { 53| 538| return codepoint_; 54| 538| } _ZN11ArduinoJson8V710HB426detail4Utf815encodeCodepointINS1_13StringBuilderEEEvjRT_: 13| 538|inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { 14| | // this function was optimize for code size on AVR 15| | 16| 538| if (codepoint32 < 0x80) { ------------------ | Branch (16:7): [True: 202, False: 336] ------------------ 17| 202| str.append(char(codepoint32)); 18| 336| } else { 19| | // a buffer to store the string in reverse 20| 336| char buf[5]; 21| 336| char* p = buf; 22| | 23| 336| *(p++) = 0; 24| 336| *(p++) = char((codepoint32 | 0x80) & 0xBF); 25| 336| uint16_t codepoint16 = uint16_t(codepoint32 >> 6); 26| 336| if (codepoint16 < 0x20) { // 0x800 ------------------ | Branch (26:9): [True: 72, False: 264] ------------------ 27| 72| *(p++) = char(codepoint16 | 0xC0); 28| 264| } else { 29| 264| *(p++) = char((codepoint16 | 0x80) & 0xBF); 30| 264| codepoint16 = uint16_t(codepoint16 >> 6); 31| 264| if (codepoint16 < 0x10) { // 0x10000 ------------------ | Branch (31:11): [True: 101, False: 163] ------------------ 32| 101| *(p++) = char(codepoint16 | 0xE0); 33| 163| } else { 34| 163| *(p++) = char((codepoint16 | 0x80) & 0xBF); 35| 163| codepoint16 = uint16_t(codepoint16 >> 6); 36| 163| *(p++) = char(codepoint16 | 0xF0); 37| 163| } 38| 264| } 39| | 40| 1.43k| while (*(--p)) { ------------------ | Branch (40:12): [True: 1.09k, False: 336] ------------------ 41| 1.09k| str.append(*p); 42| 1.09k| } 43| 336| } 44| 538|} _ZN11ArduinoJson8V710HB426detail16DefaultAllocator8instanceEv: 38| 2.40k| static Allocator* instance() { 39| 2.40k| static DefaultAllocator allocator; 40| 2.40k| return &allocator; 41| 2.40k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator8allocateEm: 26| 4.03k| void* allocate(size_t size) override { 27| 4.03k| return malloc(size); 28| 4.03k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator10deallocateEPv: 30| 4.03k| void deallocate(void* ptr) override { 31| 4.03k| free(ptr); 32| 4.03k| } _ZN11ArduinoJson8V710HB426detail16DefaultAllocator10reallocateEPvm: 34| 3.56k| void* reallocate(void* ptr, size_t new_size) override { 35| 3.56k| return realloc(ptr, new_size); 36| 3.56k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7destroyEPNS0_9AllocatorE: 57| 1.51k| void destroy(Allocator* allocator) { 58| 1.51k| if (slots_) ------------------ | Branch (58:9): [True: 1.51k, False: 0] ------------------ 59| 1.51k| allocator->deallocate(slots_); 60| 1.51k| slots_ = nullptr; 61| 1.51k| capacity_ = 0; 62| 1.51k| usage_ = 0; 63| 1.51k| } _ZNK11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE7getSlotEj: 74| 22.6k| T* getSlot(SlotId id) const { 75| 22.6k| ARDUINOJSON_ASSERT(id < usage_); ------------------ | | 11| 22.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 76| 22.6k| return slots_ + id; 77| 22.6k| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEC2EPS4_j: 21| 29.8k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 29.8k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 29.8k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 29.8k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE9allocSlotEv: 65| 14.2k| Slot allocSlot() { 66| 14.2k| if (!slots_) ------------------ | Branch (66:9): [True: 0, False: 14.2k] ------------------ 67| 0| return {}; 68| 14.2k| if (usage_ >= capacity_) ------------------ | Branch (68:9): [True: 0, False: 14.2k] ------------------ 69| 0| return {}; 70| 14.2k| auto index = usage_++; 71| 14.2k| return {slots_ + index, SlotId(index)}; 72| 14.2k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEE3ptrEv: 33| 15.3k| T* ptr() const { 34| 15.3k| return ptr_; 35| 15.3k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE6createEjPNS0_9AllocatorE: 50| 1.51k| void create(SlotCount cap, Allocator* allocator) { 51| 1.51k| ARDUINOJSON_ASSERT(cap > 0); ------------------ | | 11| 1.51k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 1.51k| slots_ = reinterpret_cast(allocator->allocate(slotsToBytes(cap))); 53| 1.51k| capacity_ = slots_ ? cap : 0; ------------------ | Branch (53:17): [True: 1.51k, False: 0] ------------------ 54| 1.51k| usage_ = 0; 55| 1.51k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE12slotsToBytesEj: 100| 3.03k| static size_t slotsToBytes(SlotCount n) { 101| 3.03k| return n * sizeof(T); 102| 3.03k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEcvbEv: 25| 41.5k| explicit operator bool() const { 26| 41.5k| return ptr_ != nullptr; 27| 41.5k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEEptEv: 37| 14.4k| T* operator->() const { 38| 14.4k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 14.4k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 14.4k| return ptr_; 40| 14.4k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_15ResourceManager8SlotDataEE2idEv: 29| 29.8k| SlotId id() const { 30| 29.8k| return id_; 31| 29.8k| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEC2EPS3_j: 21| 14.2k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 14.2k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 14.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 14.2k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEcvbEv: 25| 13.2k| explicit operator bool() const { 26| 13.2k| return ptr_ != nullptr; 27| 13.2k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEE2idEv: 29| 24.9k| SlotId id() const { 30| 24.9k| return id_; 31| 24.9k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEE3ptrEv: 33| 11.7k| T* ptr() const { 34| 11.7k| return ptr_; 35| 11.7k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_11VariantDataEEptEv: 37| 5.93k| T* operator->() const { 38| 5.93k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 5.93k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 5.93k| return ptr_; 40| 5.93k| } _ZN11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEC2EPS3_j: 21| 1.24k| Slot(T* p, SlotId id) : ptr_(p), id_(id) { 22| 1.24k| ARDUINOJSON_ASSERT((p == nullptr) == (id == NULL_SLOT)); ------------------ | | 11| 1.24k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 1.24k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEcvbEv: 25| 1.24k| explicit operator bool() const { 26| 1.24k| return ptr_ != nullptr; 27| 1.24k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEE2idEv: 29| 1.24k| SlotId id() const { 30| 1.24k| return id_; 31| 1.24k| } _ZNK11ArduinoJson8V710HB426detail4SlotINS1_16VariantExtensionEEptEv: 37| 1.24k| T* operator->() const { 38| 1.24k| ARDUINOJSON_ASSERT(ptr_ != nullptr); ------------------ | | 11| 1.24k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 39| 1.24k| return ptr_; 40| 1.24k| } _ZN11ArduinoJson8V710HB426detail10MemoryPoolINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 83| 1.51k| void shrinkToFit(Allocator* allocator) { 84| 1.51k| auto newSlots = reinterpret_cast( 85| 1.51k| allocator->reallocate(slots_, slotsToBytes(usage_))); 86| 1.51k| if (newSlots) { ------------------ | Branch (86:9): [True: 1.51k, False: 0] ------------------ 87| 1.51k| slots_ = newSlots; 88| 1.51k| capacity_ = usage_; 89| 1.51k| } 90| 1.51k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEEC2Ev: 28| 2.40k| MemoryPoolList() = default; _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE5clearEPNS0_9AllocatorE: 117| 4.80k| void clear(Allocator* allocator) { 118| 6.31k| for (PoolCount i = 0; i < count_; i++) ------------------ | Branch (118:27): [True: 1.51k, False: 4.80k] ------------------ 119| 1.51k| pools_[i].destroy(allocator); 120| 4.80k| count_ = 0; 121| 4.80k| freeList_ = NULL_SLOT; 122| 4.80k| if (pools_ != preallocatedPools_) { ------------------ | Branch (122:9): [True: 0, False: 4.80k] ------------------ 123| 0| allocator->deallocate(pools_); 124| 0| pools_ = preallocatedPools_; 125| 0| capacity_ = ARDUINOJSON_INITIAL_POOL_COUNT; ------------------ | | 124| 0|# define ARDUINOJSON_INITIAL_POOL_COUNT 4 ------------------ 126| 0| } 127| 4.80k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEED2Ev: 30| 2.40k| ~MemoryPoolList() { 31| 2.40k| ARDUINOJSON_ASSERT(count_ == 0); ------------------ | | 11| 2.40k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 32| 2.40k| } _ZNK11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7getSlotEj: 108| 25.0k| T* getSlot(SlotId id) const { 109| 25.0k| if (id == NULL_SLOT) ------------------ | Branch (109:9): [True: 2.46k, False: 22.6k] ------------------ 110| 2.46k| return nullptr; 111| 22.6k| auto poolIndex = SlotId(id / ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 22.6k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 112| 22.6k| auto indexInPool = SlotId(id % ARDUINOJSON_POOL_CAPACITY); ------------------ | | 118| 22.6k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 113| 22.6k| ARDUINOJSON_ASSERT(poolIndex < count_); ------------------ | | 11| 22.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 114| 22.6k| return pools_[poolIndex].getSlot(indexInPool); 115| 22.6k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE9allocSlotEPNS0_9AllocatorE: 82| 14.4k| Slot allocSlot(Allocator* allocator) { 83| | // try to allocate from free list 84| 14.4k| if (freeList_ != NULL_SLOT) { ------------------ | Branch (84:9): [True: 163, False: 14.2k] ------------------ 85| 163| return allocFromFreeList(); 86| 163| } 87| | 88| | // try to allocate from last pool (other pools are full) 89| 14.2k| if (count_) { ------------------ | Branch (89:9): [True: 12.7k, False: 1.51k] ------------------ 90| 12.7k| auto slot = allocFromLastPool(); 91| 12.7k| if (slot) ------------------ | Branch (91:11): [True: 12.7k, False: 0] ------------------ 92| 12.7k| return slot; 93| 12.7k| } 94| | 95| | // create a new pool and try again 96| 1.51k| auto pool = addPool(allocator); 97| 1.51k| if (!pool) ------------------ | Branch (97:9): [True: 0, False: 1.51k] ------------------ 98| 0| return {}; 99| | 100| 1.51k| return allocFromLastPool(); 101| 1.51k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE17allocFromFreeListEv: 152| 163| Slot allocFromFreeList() { 153| 163| ARDUINOJSON_ASSERT(freeList_ != NULL_SLOT); ------------------ | | 11| 163|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 154| 163| auto id = freeList_; 155| 163| auto slot = getSlot(freeList_); 156| 163| freeList_ = reinterpret_cast(slot)->next; 157| 163| return {slot, id}; 158| 163| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE17allocFromLastPoolEv: 160| 14.2k| Slot allocFromLastPool() { 161| 14.2k| ARDUINOJSON_ASSERT(count_ > 0); ------------------ | | 11| 14.2k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 162| 14.2k| auto poolIndex = SlotId(count_ - 1); 163| 14.2k| auto slot = pools_[poolIndex].allocSlot(); 164| 14.2k| if (!slot) ------------------ | Branch (164:9): [True: 0, False: 14.2k] ------------------ 165| 0| return {}; 166| 14.2k| return {slot.ptr(), 167| 14.2k| SlotId(poolIndex * ARDUINOJSON_POOL_CAPACITY + slot.id())}; ------------------ | | 118| 14.2k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 168| 14.2k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE7addPoolEPNS0_9AllocatorE: 170| 1.51k| Pool* addPool(Allocator* allocator) { 171| 1.51k| if (count_ == capacity_ && !increaseCapacity(allocator)) ------------------ | Branch (171:9): [True: 0, False: 1.51k] | Branch (171:32): [True: 0, False: 0] ------------------ 172| 0| return nullptr; 173| 1.51k| auto pool = &pools_[count_++]; 174| 1.51k| SlotCount poolCapacity = ARDUINOJSON_POOL_CAPACITY; ------------------ | | 118| 1.51k|# define ARDUINOJSON_POOL_CAPACITY 256 // 4096 bytes ------------------ 175| 1.51k| if (count_ == maxPools) // last pool is smaller because of NULL_SLOT ------------------ | Branch (175:9): [True: 0, False: 1.51k] ------------------ 176| 0| poolCapacity--; 177| 1.51k| pool->create(poolCapacity, allocator); 178| 1.51k| return pool; 179| 1.51k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE8freeSlotENS1_4SlotIS4_EE: 103| 1.10k| void freeSlot(Slot slot) { 104| 1.10k| reinterpret_cast(slot.ptr())->next = freeList_; 105| 1.10k| freeList_ = slot.id(); 106| 1.10k| } _ZN11ArduinoJson8V710HB426detail14MemoryPoolListINS1_15ResourceManager8SlotDataEE11shrinkToFitEPNS0_9AllocatorE: 140| 2.40k| void shrinkToFit(Allocator* allocator) { 141| 2.40k| if (count_ > 0) ------------------ | Branch (141:9): [True: 1.51k, False: 885] ------------------ 142| 1.51k| pools_[count_ - 1].shrinkToFit(allocator); 143| 2.40k| if (pools_ != preallocatedPools_ && count_ != capacity_) { ------------------ | Branch (143:9): [True: 0, False: 2.40k] | Branch (143:41): [True: 0, False: 0] ------------------ 144| 0| pools_ = static_cast( 145| 0| allocator->reallocate(pools_, count_ * sizeof(Pool))); 146| 0| ARDUINOJSON_ASSERT(pools_ != nullptr); // realloc to smaller can't fail ------------------ | | 11| 0|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 147| 0| capacity_ = count_; 148| 0| } 149| 2.40k| } _ZN11ArduinoJson8V710HB426detail15ResourceManagerC2EPNS0_9AllocatorE: 30| 2.40k| : allocator_(allocator), overflowed_(false) {} _ZN11ArduinoJson8V710HB426detail15ResourceManagerD2Ev: 32| 2.40k| ~ResourceManager() { 33| 2.40k| stringPool_.clear(allocator_); 34| 2.40k| variantPools_.clear(allocator_); 35| 2.40k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager5clearEv: 112| 2.40k| void clear() { 113| 2.40k| variantPools_.clear(allocator_); 114| 2.40k| overflowed_ = false; 115| 2.40k| stringPool_.clear(allocator_); 116| 2.40k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager13destroyStringEPNS1_10StringNodeE: 104| 635| void destroyString(StringNode* node) { 105| 635| StringNode::destroy(node, allocator_); 106| 635| } _ZN11ArduinoJson8V710HB426detail15ResourceManager12createStringEm: 90| 2.51k| StringNode* createString(size_t length) { 91| 2.51k| auto node = StringNode::create(length, allocator_); 92| 2.51k| if (!node) ------------------ | Branch (92:9): [True: 0, False: 2.51k] ------------------ 93| 0| overflowed_ = true; 94| 2.51k| return node; 95| 2.51k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager12resizeStringEPNS1_10StringNodeEm: 97| 2.04k| StringNode* resizeString(StringNode* node, size_t length) { 98| 2.04k| node = StringNode::resize(node, length, allocator_); 99| 2.04k| if (!node) ------------------ | Branch (99:9): [True: 0, False: 2.04k] ------------------ 100| 0| overflowed_ = true; 101| 2.04k| return node; 102| 2.04k| } _ZNK11ArduinoJson8V710HB426detail15ResourceManager9getStringINS1_14SizedRamStringEEEPNS1_10StringNodeERKT_: 86| 3.53k| StringNode* getString(const TAdaptedString& str) const { 87| 3.53k| return stringPool_.get(str); 88| 3.53k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager10saveStringEPNS1_10StringNodeE: 81| 1.88k| void saveString(StringNode* node) { 82| 1.88k| stringPool_.add(node); 83| 1.88k| } _ZN11ArduinoJson8V710HB426detail15ResourceManager17dereferenceStringEPKc: 108| 343| void dereferenceString(const char* s) { 109| 343| stringPool_.dereference(s, allocator_); 110| 343| } _ZN11ArduinoJson8V710HB426detail15ResourceManager11shrinkToFitEv: 118| 2.40k| void shrinkToFit() { 119| 2.40k| variantPools_.shrinkToFit(allocator_); 120| 2.40k| } _ZNK11ArduinoJson8V710HB426detail15ResourceManager12getExtensionEj: 47| 887|inline VariantExtension* ResourceManager::getExtension(SlotId id) const { 48| 887| return &variantPools_.getSlot(id)->extension; 49| 887|} _ZNK11ArduinoJson8V710HB426detail15ResourceManager10getVariantEj: 28| 24.0k|inline VariantData* ResourceManager::getVariant(SlotId id) const { 29| 24.0k| return reinterpret_cast(variantPools_.getSlot(id)); 30| 24.0k|} _ZN11ArduinoJson8V710HB426detail15ResourceManager12allocVariantEv: 14| 13.2k|inline Slot ResourceManager::allocVariant() { 15| 13.2k| auto p = variantPools_.allocSlot(allocator_); 16| 13.2k| if (!p) { ------------------ | Branch (16:7): [True: 0, False: 13.2k] ------------------ 17| 0| overflowed_ = true; 18| 0| return {}; 19| 0| } 20| 13.2k| return {new (&p->variant) VariantData, p.id()}; 21| 13.2k|} _ZN11ArduinoJson8V710HB426detail15ResourceManager13freeExtensionEj: 42| 86|inline void ResourceManager::freeExtension(SlotId id) { 43| 86| auto p = getExtension(id); 44| 86| variantPools_.freeSlot({reinterpret_cast(p), id}); 45| 86|} _ZN11ArduinoJson8V710HB426detail15ResourceManager11freeVariantENS1_4SlotINS1_11VariantDataEEE: 23| 1.01k|inline void ResourceManager::freeVariant(Slot variant) { 24| 1.01k| variant->clear(this); 25| 1.01k| variantPools_.freeSlot({alias_cast(variant.ptr()), variant.id()}); 26| 1.01k|} _ZN11ArduinoJson8V710HB426detail15ResourceManager14allocExtensionEv: 33| 1.24k|inline Slot ResourceManager::allocExtension() { 34| 1.24k| auto p = variantPools_.allocSlot(allocator_); 35| 1.24k| if (!p) { ------------------ | Branch (35:7): [True: 0, False: 1.24k] ------------------ 36| 0| overflowed_ = true; 37| 0| return {}; 38| 0| } 39| 1.24k| return {&p->extension, p.id()}; 40| 1.24k|} _ZN11ArduinoJson8V710HB426detail13StringBuilderC2EPNS1_15ResourceManagerE: 15| 2.40k| StringBuilder(ResourceManager* resources) : resources_(resources) {} _ZN11ArduinoJson8V710HB426detail13StringBuilderD2Ev: 17| 2.40k| ~StringBuilder() { 18| 2.40k| if (node_) ------------------ | Branch (18:9): [True: 635, False: 1.76k] ------------------ 19| 635| resources_->destroyString(node_); 20| 2.40k| } _ZN11ArduinoJson8V710HB426detail13StringBuilder11startStringEv: 22| 4.48k| void startString() { 23| 4.48k| size_ = 0; 24| 4.48k| if (!node_) ------------------ | Branch (24:9): [True: 2.51k, False: 1.96k] ------------------ 25| 2.51k| node_ = resources_->createString(initialCapacity); 26| 4.48k| } _ZN11ArduinoJson8V710HB426detail13StringBuilder6appendEc: 53| 10.5k| void append(char c) { 54| 10.5k| if (node_ && size_ == node_->length) ------------------ | Branch (54:9): [True: 10.5k, False: 0] | Branch (54:18): [True: 161, False: 10.3k] ------------------ 55| 161| node_ = resources_->resizeString(node_, size_ * 2U + 1); 56| 10.5k| if (node_) ------------------ | Branch (56:9): [True: 10.5k, False: 0] ------------------ 57| 10.5k| node_->data[size_++] = c; 58| 10.5k| } _ZNK11ArduinoJson8V710HB426detail13StringBuilder7isValidEv: 60| 4.19k| bool isValid() const { 61| 4.19k| return node_ != nullptr; 62| 4.19k| } _ZNK11ArduinoJson8V710HB426detail13StringBuilder3strEv: 68| 2.96k| JsonString str() const { 69| 2.96k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 2.96k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 70| 2.96k| node_->data[size_] = 0; 71| 2.96k| return JsonString(node_->data, size_, JsonString::Copied); 72| 2.96k| } _ZN11ArduinoJson8V710HB426detail13StringBuilder4saveEv: 28| 3.53k| StringNode* save() { 29| 3.53k| ARDUINOJSON_ASSERT(node_ != nullptr); ------------------ | | 11| 3.53k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 30| 3.53k| node_->data[size_] = 0; 31| 3.53k| StringNode* node = resources_->getString(adaptString(node_->data, size_)); 32| 3.53k| if (!node) { ------------------ | Branch (32:9): [True: 1.88k, False: 1.64k] ------------------ 33| 1.88k| node = resources_->resizeString(node_, size_); 34| 1.88k| ARDUINOJSON_ASSERT(node != nullptr); // realloc to smaller can't fail ------------------ | | 11| 1.88k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 35| 1.88k| resources_->saveString(node); 36| 1.88k| node_ = nullptr; // next time we need a new string 37| 1.88k| } else { 38| 1.64k| node->references++; 39| 1.64k| } 40| 3.53k| return node; 41| 3.53k| } _ZN11ArduinoJson8V710HB426detail10StringNode7destroyEPS2_PNS0_9AllocatorE: 65| 2.51k| static void destroy(StringNode* node, Allocator* allocator) { 66| 2.51k| allocator->deallocate(node); 67| 2.51k| } _ZN11ArduinoJson8V710HB426detail10StringNode6createEmPNS0_9AllocatorE: 35| 2.51k| static StringNode* create(size_t length, Allocator* allocator) { 36| 2.51k| if (length > maxLength) ------------------ | Branch (36:9): [True: 0, False: 2.51k] ------------------ 37| 0| return nullptr; 38| 2.51k| auto size = sizeForLength(length); 39| 2.51k| if (size < length) // integer overflow ------------------ | Branch (39:9): [True: 0, False: 2.51k] ------------------ 40| 0| return nullptr; // (not testable on 64-bit) 41| 2.51k| auto node = reinterpret_cast(allocator->allocate(size)); 42| 2.51k| if (node) { ------------------ | Branch (42:9): [True: 2.51k, False: 0] ------------------ 43| 2.51k| node->length = length_type(length); 44| 2.51k| node->references = 1; 45| 2.51k| } 46| 2.51k| return node; 47| 2.51k| } _ZN11ArduinoJson8V710HB426detail10StringNode13sizeForLengthEm: 31| 4.56k| static constexpr size_t sizeForLength(size_t n) { 32| 4.56k| return n + 1 + offsetof(StringNode, data); 33| 4.56k| } _ZN11ArduinoJson8V710HB426detail10StringNode6resizeEPS2_mPNS0_9AllocatorE: 50| 2.04k| Allocator* allocator) { 51| 2.04k| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 2.04k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 52| 2.04k| StringNode* newNode; 53| 2.04k| if (length <= maxLength) ------------------ | Branch (53:9): [True: 2.04k, False: 0] ------------------ 54| 2.04k| newNode = reinterpret_cast( 55| 2.04k| allocator->reallocate(node, sizeForLength(length))); 56| 0| else 57| 0| newNode = nullptr; 58| 2.04k| if (newNode) ------------------ | Branch (58:9): [True: 2.04k, False: 0] ------------------ 59| 2.04k| newNode->length = length_type(length); 60| 0| else 61| 0| allocator->deallocate(node); 62| 2.04k| return newNode; 63| 2.04k| } _ZN11ArduinoJson8V710HB426detail10StringPoolC2Ev: 17| 2.40k| StringPool() = default; _ZN11ArduinoJson8V710HB426detail10StringPool5clearEPNS0_9AllocatorE: 29| 4.80k| void clear(Allocator* allocator) { 30| 6.49k| while (strings_) { ------------------ | Branch (30:12): [True: 1.69k, False: 4.80k] ------------------ 31| 1.69k| auto node = strings_; 32| 1.69k| strings_ = node->next; 33| 1.69k| StringNode::destroy(node, allocator); 34| 1.69k| } 35| 4.80k| } _ZN11ArduinoJson8V710HB426detail10StringPoolD2Ev: 21| 2.40k| ~StringPool() { 22| 2.40k| ARDUINOJSON_ASSERT(strings_ == nullptr); ------------------ | | 11| 2.40k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 23| 2.40k| } _ZNK11ArduinoJson8V710HB426detail10StringPool3getINS1_14SizedRamStringEEEPNS1_10StringNodeERKT_: 73| 3.53k| StringNode* get(const TAdaptedString& str) const { 74| 15.5k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (74:32): [True: 13.6k, False: 1.88k] ------------------ 75| 13.6k| if (stringEquals(str, adaptString(node->data, node->length))) ------------------ | Branch (75:11): [True: 1.64k, False: 12.0k] ------------------ 76| 1.64k| return node; 77| 13.6k| } 78| 1.88k| return nullptr; 79| 3.53k| } _ZN11ArduinoJson8V710HB426detail10StringPool3addEPNS1_10StringNodeE: 66| 1.88k| void add(StringNode* node) { 67| 1.88k| ARDUINOJSON_ASSERT(node != nullptr); ------------------ | | 11| 1.88k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 68| 1.88k| node->next = strings_; 69| 1.88k| strings_ = node; 70| 1.88k| } _ZN11ArduinoJson8V710HB426detail10StringPool11dereferenceEPKcPNS0_9AllocatorE: 81| 343| void dereference(const char* s, Allocator* allocator) { 82| 343| StringNode* prev = nullptr; 83| 1.72k| for (auto node = strings_; node; node = node->next) { ------------------ | Branch (83:32): [True: 1.72k, False: 0] ------------------ 84| 1.72k| if (node->data == s) { ------------------ | Branch (84:11): [True: 343, False: 1.38k] ------------------ 85| 343| if (--node->references == 0) { ------------------ | Branch (85:13): [True: 194, False: 149] ------------------ 86| 194| if (prev) ------------------ | Branch (86:15): [True: 110, False: 84] ------------------ 87| 110| prev->next = node->next; 88| 84| else 89| 84| strings_ = node->next; 90| 194| StringNode::destroy(node, allocator); 91| 194| } 92| 343| return; 93| 343| } 94| 1.38k| prev = node; 95| 1.38k| } 96| 343| } _ZN11ArduinoJson8V710HB426detail14decomposeFloatEda: 56| 1.58k|inline FloatParts decomposeFloat(JsonFloat value, int8_t decimalPlaces) { 57| 1.58k| uint32_t maxDecimalPart = pow10(decimalPlaces); 58| | 59| 1.58k| int16_t exponent = normalize(value); 60| | 61| 1.58k| uint32_t integral = uint32_t(value); 62| | // reduce number of decimal places by the number of integral places 63| 2.71k| for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) { ------------------ | Branch (63:33): [True: 1.13k, False: 1.58k] ------------------ 64| 1.13k| maxDecimalPart /= 10; 65| 1.13k| decimalPlaces--; 66| 1.13k| } 67| | 68| 1.58k| JsonFloat remainder = 69| 1.58k| (value - JsonFloat(integral)) * JsonFloat(maxDecimalPart); 70| | 71| 1.58k| uint32_t decimal = uint32_t(remainder); 72| 1.58k| remainder = remainder - JsonFloat(decimal); 73| | 74| | // rounding: 75| | // increment by 1 if remainder >= 0.5 76| 1.58k| decimal += uint32_t(remainder * 2); 77| 1.58k| if (decimal >= maxDecimalPart) { ------------------ | Branch (77:7): [True: 304, False: 1.27k] ------------------ 78| 304| decimal = 0; 79| 304| integral++; 80| 304| if (exponent && integral >= 10) { ------------------ | Branch (80:9): [True: 270, False: 34] | Branch (80:21): [True: 99, False: 171] ------------------ 81| 99| exponent++; 82| 99| integral = 1; 83| 99| } 84| 304| } 85| | 86| | // remove trailing zeros 87| 9.88k| while (decimal % 10 == 0 && decimalPlaces > 0) { ------------------ | Branch (87:10): [True: 9.62k, False: 257] | Branch (87:31): [True: 8.29k, False: 1.32k] ------------------ 88| 8.29k| decimal /= 10; 89| 8.29k| decimalPlaces--; 90| 8.29k| } 91| | 92| 1.58k| return {integral, decimal, exponent, decimalPlaces}; 93| 1.58k|} _ZN11ArduinoJson8V710HB426detail5pow10Ei: 52| 12.3k|constexpr uint32_t pow10(int exponent) { 53| 12.3k| return (exponent == 0) ? 1 : 10 * pow10(exponent - 1); ------------------ | Branch (53:10): [True: 1.58k, False: 10.7k] ------------------ 54| 12.3k|} _ZN11ArduinoJson8V710HB426detail9normalizeIdEEsRT_: 22| 1.58k|inline int16_t normalize(TFloat& value) { 23| 1.58k| typedef FloatTraits traits; 24| 1.58k| int16_t powersOf10 = 0; 25| | 26| 1.58k| int8_t index = sizeof(TFloat) == 8 ? 8 : 5; ------------------ | Branch (26:18): [Folded - Ignored] ------------------ 27| 1.58k| int bit = 1 << index; 28| | 29| 1.58k| if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 232| 1.58k|# define ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD 1e7 ------------------ | Branch (29:7): [True: 466, False: 1.11k] ------------------ 30| 4.66k| for (; index >= 0; index--) { ------------------ | Branch (30:12): [True: 4.19k, False: 466] ------------------ 31| 4.19k| if (value >= traits::positiveBinaryPowersOfTen()[index]) { ------------------ | Branch (31:11): [True: 1.40k, False: 2.78k] ------------------ 32| 1.40k| value *= traits::negativeBinaryPowersOfTen()[index]; 33| 1.40k| powersOf10 = int16_t(powersOf10 + bit); 34| 1.40k| } 35| 4.19k| bit >>= 1; 36| 4.19k| } 37| 466| } 38| | 39| 1.58k| if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) { ------------------ | | 238| 998|# define ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD 1e-5 ------------------ | Branch (39:7): [True: 998, False: 584] | Branch (39:20): [True: 116, False: 882] ------------------ 40| 1.16k| for (; index >= 0; index--) { ------------------ | Branch (40:12): [True: 1.04k, False: 116] ------------------ 41| 1.04k| if (value < traits::negativeBinaryPowersOfTen()[index] * 10) { ------------------ | Branch (41:11): [True: 353, False: 691] ------------------ 42| 353| value *= traits::positiveBinaryPowersOfTen()[index]; 43| 353| powersOf10 = int16_t(powersOf10 - bit); 44| 353| } 45| 1.04k| bit >>= 1; 46| 1.04k| } 47| 116| } 48| | 49| 1.58k| return powersOf10; 50| 1.58k|} _ZN11ArduinoJson8V710HB426detail11FloatTraitsIdLm8EE25positiveBinaryPowersOfTenEv: 32| 5.13k| static pgm_ptr positiveBinaryPowersOfTen() { 33| 5.13k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 44| 5.13k| static type const name[] = __VA_ARGS__; ------------------ 34| 5.13k| uint64_t, factors, 35| 5.13k| { 36| 5.13k| 0x4024000000000000, // 1e1 37| 5.13k| 0x4059000000000000, // 1e2 38| 5.13k| 0x40C3880000000000, // 1e4 39| 5.13k| 0x4197D78400000000, // 1e8 40| 5.13k| 0x4341C37937E08000, // 1e16 41| 5.13k| 0x4693B8B5B5056E17, // 1e32 42| 5.13k| 0x4D384F03E93FF9F5, // 1e64 43| 5.13k| 0x5A827748F9301D32, // 1e128 44| 5.13k| 0x75154FDD7F73BF3C, // 1e256 45| 5.13k| }); 46| 5.13k| return pgm_ptr(reinterpret_cast(factors)); 47| 5.13k| } _ZN11ArduinoJson8V710HB426detail11FloatTraitsIdLm8EE25negativeBinaryPowersOfTenEv: 49| 2.74k| static pgm_ptr negativeBinaryPowersOfTen() { 50| 2.74k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY( // ------------------ | | 44| 2.74k| static type const name[] = __VA_ARGS__; ------------------ 51| 2.74k| uint64_t, factors, 52| 2.74k| { 53| 2.74k| 0x3FB999999999999A, // 1e-1 54| 2.74k| 0x3F847AE147AE147B, // 1e-2 55| 2.74k| 0x3F1A36E2EB1C432D, // 1e-4 56| 2.74k| 0x3E45798EE2308C3A, // 1e-8 57| 2.74k| 0x3C9CD2B297D889BC, // 1e-16 58| 2.74k| 0x3949F623D5A8A733, // 1e-32 59| 2.74k| 0x32A50FFD44F4A73D, // 1e-64 60| 2.74k| 0x255BBA08CF8C979D, // 1e-128 61| 2.74k| 0x0AC8062864AC6F43 // 1e-256 62| 2.74k| }); 63| 2.74k| return pgm_ptr(reinterpret_cast(factors)); 64| 2.74k| } _ZN11ArduinoJson8V710HB426detail11FloatTraitsIdLm8EE3infEv: 70| 206| static T inf() { 71| 206| return forge(0x7ff0000000000000); 72| 206| } _ZN11ArduinoJson8V710HB426detail11FloatTraitsIdLm8EE5forgeEm: 101| 206| static T forge(uint64_t bits) { 102| 206| return alias_cast(bits); 103| 206| } _ZN11ArduinoJson8V710HB426detail10make_floatIdiEET_S3_T0_: 196| 878|inline TFloat make_float(TFloat m, TExponent e) { 197| 878| using traits = FloatTraits; 198| | 199| 878| auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen() ------------------ | Branch (199:22): [True: 584, False: 294] ------------------ 200| 878| : traits::negativeBinaryPowersOfTen(); 201| 878| if (e <= 0) ------------------ | Branch (201:7): [True: 294, False: 584] ------------------ 202| 294| e = TExponent(-e); 203| | 204| 5.52k| for (uint8_t index = 0; e != 0; index++) { ------------------ | Branch (204:27): [True: 4.64k, False: 878] ------------------ 205| 4.64k| if (e & 1) ------------------ | Branch (205:9): [True: 2.69k, False: 1.94k] ------------------ 206| 2.69k| m *= powersOfTen[index]; 207| 4.64k| e >>= 1; 208| 4.64k| } 209| 878| return m; 210| 878|} _ZN11ArduinoJson8V710HB426detail10make_floatIfiEET_S3_T0_: 196| 3.82k|inline TFloat make_float(TFloat m, TExponent e) { 197| 3.82k| using traits = FloatTraits; 198| | 199| 3.82k| auto powersOfTen = e > 0 ? traits::positiveBinaryPowersOfTen() ------------------ | Branch (199:22): [True: 399, False: 3.42k] ------------------ 200| 3.82k| : traits::negativeBinaryPowersOfTen(); 201| 3.82k| if (e <= 0) ------------------ | Branch (201:7): [True: 3.42k, False: 399] ------------------ 202| 3.42k| e = TExponent(-e); 203| | 204| 5.91k| for (uint8_t index = 0; e != 0; index++) { ------------------ | Branch (204:27): [True: 2.09k, False: 3.82k] ------------------ 205| 2.09k| if (e & 1) ------------------ | Branch (205:9): [True: 1.15k, False: 945] ------------------ 206| 1.15k| m *= powersOfTen[index]; 207| 2.09k| e >>= 1; 208| 2.09k| } 209| 3.82k| return m; 210| 3.82k|} _ZN11ArduinoJson8V710HB426detail11FloatTraitsIfLm4EE25positiveBinaryPowersOfTenEv: 116| 399| static pgm_ptr positiveBinaryPowersOfTen() { 117| 399| ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors, ------------------ | | 44| 399| static type const name[] = __VA_ARGS__; ------------------ 118| 399| { 119| 399| 0x41200000, // 1e1f 120| 399| 0x42c80000, // 1e2f 121| 399| 0x461c4000, // 1e4f 122| 399| 0x4cbebc20, // 1e8f 123| 399| 0x5a0e1bca, // 1e16f 124| 399| 0x749dc5ae // 1e32f 125| 399| }); 126| 399| return pgm_ptr(reinterpret_cast(factors)); 127| 399| } _ZN11ArduinoJson8V710HB426detail11FloatTraitsIfLm4EE25negativeBinaryPowersOfTenEv: 129| 3.42k| static pgm_ptr negativeBinaryPowersOfTen() { 130| 3.42k| ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors, ------------------ | | 44| 3.42k| static type const name[] = __VA_ARGS__; ------------------ 131| 3.42k| { 132| 3.42k| 0x3dcccccd, // 1e-1f 133| 3.42k| 0x3c23d70a, // 1e-2f 134| 3.42k| 0x38d1b717, // 1e-4f 135| 3.42k| 0x322bcc77, // 1e-8f 136| 3.42k| 0x24e69595, // 1e-16f 137| 3.42k| 0x0a4fb11f // 1e-32f 138| 3.42k| }); 139| 3.42k| return pgm_ptr(reinterpret_cast(factors)); 140| 3.42k| } _ZN11ArduinoJson8V710HB426detail16canConvertNumberIjmEENS1_9enable_ifIXaaaaaasr11is_integralIT0_EE5valuesr11is_unsignedIS4_EE5valuesr11is_integralIT_EE5valuelestS5_stS4_EbE4typeES4_: 28| 1.67k|canConvertNumber(TIn value) { 29| 1.67k| return value <= TIn(numeric_limits::highest()); 30| 1.67k|} _ZN11ArduinoJson8V710HB426detail16canConvertNumberIilEENS1_9enable_ifIXaaaaaaaasr11is_integralIT0_EE5valuesr9is_signedIS4_EE5valuesr11is_integralIT_EE5valuesr9is_signedIS5_EE5valueltstS5_stS4_EbE4typeES4_: 55| 600|canConvertNumber(TIn value) { 56| 600| return value >= TIn(numeric_limits::lowest()) && ------------------ | Branch (56:10): [True: 340, False: 260] ------------------ 57| 600| value <= TIn(numeric_limits::highest()); ------------------ | Branch (57:10): [True: 340, False: 0] ------------------ 58| 600|} _ZN11ArduinoJson8V710HB426detail11parseNumberEPKc: 105| 7.40k|inline Number parseNumber(const char* s) { 106| 7.40k| typedef FloatTraits traits; 107| 7.40k| typedef largest_type mantissa_t; 108| 7.40k| typedef traits::exponent_type exponent_t; 109| | 110| 7.40k| ARDUINOJSON_ASSERT(s != 0); ------------------ | | 11| 7.40k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 111| | 112| 7.40k| bool is_negative = false; 113| 7.40k| switch (*s) { ------------------ | Branch (113:11): [True: 6.42k, False: 976] ------------------ 114| 902| case '-': ------------------ | Branch (114:5): [True: 902, False: 6.50k] ------------------ 115| 902| is_negative = true; 116| 902| s++; 117| 902| break; 118| 74| case '+': ------------------ | Branch (118:5): [True: 74, False: 7.33k] ------------------ 119| 74| s++; 120| 74| break; 121| 7.40k| } 122| | 123| |#if ARDUINOJSON_ENABLE_NAN 124| | if (*s == 'n' || *s == 'N') { 125| | return Number(traits::nan()); 126| | } 127| |#endif 128| | 129| |#if ARDUINOJSON_ENABLE_INFINITY 130| | if (*s == 'i' || *s == 'I') { 131| | return Number(is_negative ? -traits::inf() : traits::inf()); 132| | } 133| |#endif 134| | 135| 7.40k| if (!isdigit(*s) && *s != '.') ------------------ | Branch (135:7): [True: 3.12k, False: 4.28k] | Branch (135:23): [True: 98, False: 3.02k] ------------------ 136| 98| return Number(); 137| | 138| 7.30k| mantissa_t mantissa = 0; 139| 7.30k| exponent_t exponent_offset = 0; 140| 7.30k| const mantissa_t maxUint = JsonUInt(-1); 141| | 142| 23.3k| while (isdigit(*s)) { ------------------ | Branch (142:10): [True: 16.1k, False: 7.22k] ------------------ 143| 16.1k| uint8_t digit = uint8_t(*s - '0'); 144| 16.1k| if (mantissa > maxUint / 10) ------------------ | Branch (144:9): [True: 65, False: 16.0k] ------------------ 145| 65| break; 146| 16.0k| mantissa *= 10; 147| 16.0k| if (mantissa > maxUint - digit) ------------------ | Branch (147:9): [True: 18, False: 16.0k] ------------------ 148| 18| break; 149| 16.0k| mantissa += digit; 150| 16.0k| s++; 151| 16.0k| } 152| | 153| 7.30k| if (*s == '\0') { ------------------ | Branch (153:7): [True: 2.28k, False: 5.01k] ------------------ 154| 2.28k| if (is_negative) { ------------------ | Branch (154:9): [True: 618, False: 1.67k] ------------------ 155| 618| const mantissa_t sintMantissaMax = mantissa_t(1) 156| 618| << (sizeof(JsonInteger) * 8 - 1); 157| 618| if (mantissa <= sintMantissaMax) { ------------------ | Branch (157:11): [True: 600, False: 18] ------------------ 158| 600| return Number(JsonInteger(~mantissa + 1)); 159| 600| } 160| 1.67k| } else { 161| 1.67k| return Number(JsonUInt(mantissa)); 162| 1.67k| } 163| 2.28k| } 164| | 165| | // avoid mantissa overflow 166| 5.50k| while (mantissa > traits::mantissa_max) { ------------------ | Branch (166:10): [True: 465, False: 5.03k] ------------------ 167| 465| mantissa /= 10; 168| 465| exponent_offset++; 169| 465| } 170| | 171| | // remaing digits can't fit in the mantissa 172| 5.49k| while (isdigit(*s)) { ------------------ | Branch (172:10): [True: 455, False: 5.03k] ------------------ 173| 455| exponent_offset++; 174| 455| s++; 175| 455| } 176| | 177| 5.03k| if (*s == '.') { ------------------ | Branch (177:7): [True: 3.18k, False: 1.85k] ------------------ 178| 3.18k| s++; 179| 4.40k| while (isdigit(*s)) { ------------------ | Branch (179:12): [True: 1.22k, False: 3.18k] ------------------ 180| 1.22k| if (mantissa < traits::mantissa_max / 10) { ------------------ | Branch (180:11): [True: 978, False: 248] ------------------ 181| 978| mantissa = mantissa * 10 + uint8_t(*s - '0'); 182| 978| exponent_offset--; 183| 978| } 184| 1.22k| s++; 185| 1.22k| } 186| 3.18k| } 187| | 188| 5.03k| int exponent = 0; 189| 5.03k| if (*s == 'e' || *s == 'E') { ------------------ | Branch (189:7): [True: 623, False: 4.41k] | Branch (189:20): [True: 1.09k, False: 3.32k] ------------------ 190| 1.71k| s++; 191| 1.71k| bool negative_exponent = false; 192| 1.71k| if (*s == '-') { ------------------ | Branch (192:9): [True: 319, False: 1.39k] ------------------ 193| 319| negative_exponent = true; 194| 319| s++; 195| 1.39k| } else if (*s == '+') { ------------------ | Branch (195:16): [True: 67, False: 1.33k] ------------------ 196| 67| s++; 197| 67| } 198| | 199| 4.23k| while (isdigit(*s)) { ------------------ | Branch (199:12): [True: 2.79k, False: 1.44k] ------------------ 200| 2.79k| exponent = exponent * 10 + (*s - '0'); 201| 2.79k| if (exponent + exponent_offset > traits::exponent_max) { ------------------ | Branch (201:11): [True: 272, False: 2.52k] ------------------ 202| 272| if (negative_exponent) ------------------ | Branch (202:13): [True: 66, False: 206] ------------------ 203| 66| return Number(is_negative ? -0.0f : 0.0f); ------------------ | Branch (203:25): [True: 0, False: 66] ------------------ 204| 206| else 205| 206| return Number(is_negative ? -traits::inf() : traits::inf()); ------------------ | Branch (205:25): [True: 66, False: 140] ------------------ 206| 272| } 207| 2.52k| s++; 208| 2.52k| } 209| 1.44k| if (negative_exponent) ------------------ | Branch (209:9): [True: 253, False: 1.19k] ------------------ 210| 253| exponent = -exponent; 211| 1.44k| } 212| 4.76k| exponent += exponent_offset; 213| | 214| | // we should be at the end of the string, otherwise it's an error 215| 4.76k| if (*s != '\0') ------------------ | Branch (215:7): [True: 63, False: 4.70k] ------------------ 216| 63| return Number(); 217| | 218| 4.70k|#if ARDUINOJSON_USE_DOUBLE 219| 4.70k| bool isDouble = exponent < -FloatTraits::exponent_max || ------------------ | Branch (219:19): [True: 111, False: 4.59k] ------------------ 220| 4.70k| exponent > FloatTraits::exponent_max || ------------------ | Branch (220:19): [True: 460, False: 4.13k] ------------------ 221| 4.70k| mantissa > FloatTraits::mantissa_max; ------------------ | Branch (221:19): [True: 307, False: 3.82k] ------------------ 222| 4.70k| if (isDouble) { ------------------ | Branch (222:7): [True: 878, False: 3.82k] ------------------ 223| 878| auto final_result = make_float(double(mantissa), exponent); 224| 878| return Number(is_negative ? -final_result : final_result); ------------------ | Branch (224:19): [True: 87, False: 791] ------------------ 225| 878| } else 226| 3.82k|#endif 227| 3.82k| { 228| 3.82k| auto final_result = make_float(float(mantissa), exponent); 229| 3.82k| return Number(is_negative ? -final_result : final_result); ------------------ | Branch (229:19): [True: 132, False: 3.69k] ------------------ 230| 3.82k| } 231| 4.70k|} _ZN11ArduinoJson8V710HB426detail6NumberC2Ev: 52| 161| Number() : type_(NumberType::Invalid) {} _ZN11ArduinoJson8V710HB426detail11NumberValueC2Ev: 31| 161| NumberValue() {} _ZN11ArduinoJson8V710HB426detail6NumberC2El: 54| 600| Number(JsonInteger value) : type_(NumberType::SignedInteger), value_(value) {} _ZN11ArduinoJson8V710HB426detail11NumberValueC2El: 33| 600| NumberValue(JsonInteger x) : asSignedInteger(x) {} _ZN11ArduinoJson8V710HB426detail6NumberC2Em: 55| 1.67k| Number(JsonUInt value) : type_(NumberType::UnsignedInteger), value_(value) {} _ZN11ArduinoJson8V710HB426detail11NumberValueC2Em: 34| 1.67k| NumberValue(JsonUInt x) : asUnsignedInteger(x) {} _ZN11ArduinoJson8V710HB426detail6NumberC2Ef: 53| 3.88k| Number(float value) : type_(NumberType::Float), value_(value) {} _ZN11ArduinoJson8V710HB426detail11NumberValueC2Ef: 32| 3.88k| NumberValue(float x) : asFloat(x) {} _ZN11ArduinoJson8V710HB426detail6NumberC2Ed: 57| 1.08k| Number(double value) : type_(NumberType::Double), value_(value) {} _ZN11ArduinoJson8V710HB426detail11NumberValueC2Ed: 36| 1.08k| NumberValue(double x) : asDouble(x) {} _ZNK11ArduinoJson8V710HB426detail6Number4typeEv: 78| 7.40k| NumberType type() const { 79| 7.40k| return type_; 80| 7.40k| } _ZNK11ArduinoJson8V710HB426detail6Number17asUnsignedIntegerEv: 87| 1.67k| JsonUInt asUnsignedInteger() const { 88| 1.67k| ARDUINOJSON_ASSERT(type_ == NumberType::UnsignedInteger); ------------------ | | 11| 1.67k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 89| 1.67k| return value_.asUnsignedInteger; 90| 1.67k| } _ZNK11ArduinoJson8V710HB426detail6Number15asSignedIntegerEv: 82| 600| JsonInteger asSignedInteger() const { 83| 600| ARDUINOJSON_ASSERT(type_ == NumberType::SignedInteger); ------------------ | | 11| 600|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 84| 600| return value_.asSignedInteger; 85| 600| } _ZNK11ArduinoJson8V710HB426detail6Number7asFloatEv: 92| 3.88k| float asFloat() const { 93| 3.88k| ARDUINOJSON_ASSERT(type_ == NumberType::Float); ------------------ | | 11| 3.88k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 94| 3.88k| return value_.asFloat; 95| 3.88k| } _ZNK11ArduinoJson8V710HB426detail6Number8asDoubleEv: 98| 1.08k| double asDouble() const { 99| 1.08k| ARDUINOJSON_ASSERT(type_ == NumberType::Double); ------------------ | | 11| 1.08k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 100| 1.08k| return value_.asDouble; 101| 1.08k| } _ZNK11ArduinoJson8V710HB426detail10ObjectData9getMemberINS1_19StaticStringAdapterEEEPNS1_11VariantDataET_PKNS1_15ResourceManagerE: 15| 2.96k| TAdaptedString key, const ResourceManager* resources) const { 16| 2.96k| auto it = findKey(key, resources); 17| 2.96k| if (it.done()) ------------------ | Branch (17:7): [True: 2.46k, False: 506] ------------------ 18| 2.46k| return nullptr; 19| 506| it.next(resources); 20| 506| return it.data(); 21| 2.96k|} _ZNK11ArduinoJson8V710HB426detail10ObjectData7findKeyINS1_19StaticStringAdapterEEENS1_18CollectionIteratorET_PKNS1_15ResourceManagerE: 34| 2.96k| TAdaptedString key, const ResourceManager* resources) const { 35| 2.96k| if (key.isNull()) ------------------ | Branch (35:7): [True: 0, False: 2.96k] ------------------ 36| 0| return iterator(); 37| 2.96k| bool isKey = true; 38| 12.0k| for (auto it = createIterator(resources); !it.done(); it.next(resources)) { ------------------ | Branch (38:45): [True: 9.55k, False: 2.46k] ------------------ 39| 9.55k| if (isKey && stringEquals(key, adaptString(it->asString()))) ------------------ | Branch (39:9): [True: 5.02k, False: 4.52k] | Branch (39:9): [True: 506, False: 9.04k] | Branch (39:18): [True: 506, False: 4.52k] ------------------ 40| 506| return it; 41| 9.04k| isKey = !isKey; 42| 9.04k| } 43| 2.46k| return iterator(); 44| 2.96k|} _ZN11ArduinoJson8V710HB426detail10ObjectData9addMemberIPNS1_10StringNodeEEEPNS1_11VariantDataET_PNS1_15ResourceManagerE: 54| 2.46k| ResourceManager* resources) { 55| 2.46k| auto keySlot = resources->allocVariant(); 56| 2.46k| if (!keySlot) ------------------ | Branch (56:7): [True: 0, False: 2.46k] ------------------ 57| 0| return nullptr; 58| | 59| 2.46k| auto valueSlot = resources->allocVariant(); 60| 2.46k| if (!valueSlot) ------------------ | Branch (60:7): [True: 0, False: 2.46k] ------------------ 61| 0| return nullptr; 62| | 63| 2.46k| if (!keySlot->setString(key, resources)) ------------------ | Branch (63:7): [True: 0, False: 2.46k] ------------------ 64| 0| return nullptr; 65| | 66| 2.46k| CollectionData::appendPair(keySlot, valueSlot, resources); 67| | 68| 2.46k| return valueSlot.ptr(); 69| 2.46k|} _ZN11ArduinoJson8V710HB426detail10alias_castIPNS1_15ResourceManager8SlotDataEPNS1_11VariantDataEEET_T0_: 24| 1.01k|T alias_cast(F raw_data) { 25| 1.01k| alias_cast_t ac; 26| 1.01k| ac.raw = raw_data; 27| 1.01k| return ac.data; 28| 1.01k|} _ZN11ArduinoJson8V710HB426detail10alias_castIdmEET_T0_: 24| 206|T alias_cast(F raw_data) { 25| 206| alias_cast_t ac; 26| 206| ac.raw = raw_data; 27| 206| return ac.data; 28| 206|} _ZN11ArduinoJson8V710HB426detail7isdigitEc: 12| 44.8k|inline bool isdigit(char c) { 13| 44.8k| return '0' <= c && c <= '9'; ------------------ | Branch (13:10): [True: 28.3k, False: 16.5k] | Branch (13:22): [True: 24.8k, False: 3.44k] ------------------ 14| 44.8k|} _ZN11ArduinoJson8V710HB426detail14numeric_limitsIjvE7highestEv: 25| 1.67k| static constexpr T highest() { 26| 1.67k| return T(-1); 27| 1.67k| } _ZN11ArduinoJson8V710HB426detail14numeric_limitsIivE6lowestEv: 33| 940| static constexpr T lowest() { 34| 940| return T(T(1) << (sizeof(T) * 8 - 1)); 35| 940| } _ZN11ArduinoJson8V710HB426detail14numeric_limitsIivE7highestEv: 36| 340| static constexpr T highest() { 37| 340| return T(~lowest()); 38| 340| } _ZN11ArduinoJson8V710HB426detail5isnanIdEEbT_: 16| 1.65k|bool isnan(T x) { 17| 1.65k| return x != x; 18| 1.65k|} _ZN11ArduinoJson8V710HB426detail5isinfIdEEbT_: 23| 1.65k|bool isinf(T x) { 24| 1.65k| return x != 0.0 && x * 2 == x; ------------------ | Branch (24:10): [True: 1.06k, False: 584] | Branch (24:22): [True: 70, False: 998] ------------------ 25| 1.65k|} _ZN11ArduinoJson8V710HB426detail7pgm_ptrIdEC2EPKd: 57| 7.87k| explicit pgm_ptr(const T* ptr) : ptr_(ptr) {} _ZNK11ArduinoJson8V710HB426detail7pgm_ptrIdEixEl: 59| 9.69k| T operator[](intptr_t index) const { 60| 9.69k| return pgm_read(ptr_ + index); 61| 9.69k| } _ZN11ArduinoJson8V710HB426detail8pgm_readIdEET_PKS3_: 48| 9.69k|inline T pgm_read(const T* p) { 49| 9.69k| return *p; 50| 9.69k|} _ZN11ArduinoJson8V710HB426detail7pgm_ptrIfEC2EPKf: 57| 3.82k| explicit pgm_ptr(const T* ptr) : ptr_(ptr) {} _ZNK11ArduinoJson8V710HB426detail7pgm_ptrIfEixEl: 59| 1.15k| T operator[](intptr_t index) const { 60| 1.15k| return pgm_read(ptr_ + index); 61| 1.15k| } _ZN11ArduinoJson8V710HB426detail8pgm_readIfEET_PKS3_: 48| 1.15k|inline T pgm_read(const T* p) { 49| 1.15k| return *p; 50| 1.15k|} _ZN11ArduinoJson8V710HB426detail7forwardIRNS0_12JsonDocumentEEEOT_RNS1_16remove_referenceIS5_E4typeE: 14| 2.40k|T&& forward(remove_reference_t& t) noexcept { 15| 2.40k| return static_cast(t); 16| 2.40k|} _ZN11ArduinoJson8V710HB426detail7forwardIRmEEOT_RNS1_16remove_referenceIS4_E4typeE: 14| 2.40k|T&& forward(remove_reference_t& t) noexcept { 15| 2.40k| return static_cast(t); 16| 2.40k|} _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEEC2ERSB_: 14| 926| explicit CountingDecorator(TWriter& writer) : writer_(writer), count_(0) {} _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEPKhm: 20| 3.66k| void write(const uint8_t* s, size_t n) { 21| 3.66k| count_ += writer_.write(s, n); 22| 3.66k| } _ZN11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5writeEh: 16| 7.10k| void write(uint8_t c) { 17| 7.10k| count_ += writer_.write(c); 18| 7.10k| } _ZNK11ArduinoJson8V710HB426detail17CountingDecoratorINS1_6WriterINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEvEEE5countEv: 24| 3.82k| size_t count() const { 25| 3.82k| return count_; 26| 3.82k| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvEC2ERS9_: 24| 926| Writer(TDestination& str) : str_(&str) { 25| 926| str.clear(); 26| 926| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEPKhm: 33| 3.66k| size_t write(const uint8_t* s, size_t n) { 34| 3.66k| str_->append(reinterpret_cast(s), n); 35| 3.66k| return n; 36| 3.66k| } _ZN11ArduinoJson8V710HB426detail6WriterINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEvE5writeEh: 28| 7.10k| size_t write(uint8_t c) { 29| 7.10k| str_->push_back(static_cast(c)); 30| 7.10k| return 1; 31| 7.10k| } _ZN11ArduinoJson8V710HB426detail9serializeINS1_14JsonSerializerENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEmNS0_16JsonVariantConstERT0_: 21| 926| TDestination& destination) { 22| 926| Writer writer(destination); 23| 926| return doSerialize(source, writer); 24| 926|} _ZN11ArduinoJson8V710HB426detail11doSerializeINS1_14JsonSerializerENS1_6WriterINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEvEEEEmNS0_16JsonVariantConstET0_: 12| 926|size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) { 13| 926| auto data = VariantAttorney::getData(source); 14| 926| auto resources = VariantAttorney::getResourceManager(source); 15| 926| TSerializer serializer(writer, resources); 16| 926| return VariantData::accept(data, resources, serializer); 17| 926|} _ZN11ArduinoJson8V710HB426detail13StringAdapterINS0_10JsonStringEvE5adaptERKS3_: 30| 5.02k| static AdaptedString adapt(const JsonString& s) { 31| 5.02k| return AdaptedString(s); 32| 5.02k| } _ZN11ArduinoJson8V710HB426detail17JsonStringAdapterC2ERKNS0_10JsonStringE: 16| 5.02k| : SizedRamString(s.c_str(), s.size()), linked_(s.isLinked()) {} _ZNK11ArduinoJson8V710HB426detail23ZeroTerminatedRamString6isNullEv: 26| 7.99k| bool isNull() const { 27| 7.99k| return !str_; 28| 7.99k| } _ZNK11ArduinoJson8V710HB426detail14SizedRamString6isNullEv: 106| 32.3k| bool isNull() const { 107| 32.3k| return !str_; 108| 32.3k| } _ZNK11ArduinoJson8V710HB426detail14SizedRamString4sizeEv: 110| 61.0k| size_t size() const { 111| 61.0k| return size_; 112| 61.0k| } _ZNK11ArduinoJson8V710HB426detail23ZeroTerminatedRamString4sizeEv: 30| 9.80k| FORCE_INLINE size_t size() const { 31| 9.80k| return str_ ? ::strlen(str_) : 0; ------------------ | Branch (31:12): [True: 9.80k, False: 0] ------------------ 32| 9.80k| } _ZNK11ArduinoJson8V710HB426detail14SizedRamStringixEm: 114| 28.7k| char operator[](size_t i) const { 115| 28.7k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 28.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 116| 28.7k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 28.7k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 117| 28.7k| return str_[i]; 118| 28.7k| } _ZNK11ArduinoJson8V710HB426detail23ZeroTerminatedRamStringixEm: 34| 4.77k| char operator[](size_t i) const { 35| 4.77k| ARDUINOJSON_ASSERT(str_ != 0); ------------------ | | 11| 4.77k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 36| 4.77k| ARDUINOJSON_ASSERT(i <= size()); ------------------ | | 11| 4.77k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 37| 4.77k| return str_[i]; 38| 4.77k| } _ZN11ArduinoJson8V710HB426detail14SizedRamStringC2EPKcm: 104| 22.2k| SizedRamString(const char* str, size_t sz) : str_(str), size_(sz) {} _ZN11ArduinoJson8V710HB426detail13StringAdapterIPKcvE5adaptES4_: 95| 2.96k| static AdaptedString adapt(const char* p) { 96| 2.96k| return AdaptedString(p); 97| 2.96k| } _ZN11ArduinoJson8V710HB426detail19StaticStringAdapterC2EPKc: 84| 2.96k| StaticStringAdapter(const char* str) : ZeroTerminatedRamString(str) {} _ZN11ArduinoJson8V710HB426detail23ZeroTerminatedRamStringC2EPKc: 24| 2.96k| ZeroTerminatedRamString(const char* str) : str_(str) {} _ZN11ArduinoJson8V710HB426detail18SizedStringAdapterIPcvE5adaptEPKcm: 137| 17.1k| static AdaptedString adapt(const TChar* p, size_t n) { 138| 17.1k| return AdaptedString(reinterpret_cast(p), n); 139| 17.1k| } _ZNK11ArduinoJson8V710HB4210JsonString5c_strEv: 28| 11.3k| const char* c_str() const { 29| 11.3k| return data_; 30| 11.3k| } _ZNK11ArduinoJson8V710HB4210JsonString4sizeEv: 44| 5.38k| size_t size() const { 45| 5.38k| return size_; 46| 5.38k| } _ZN11ArduinoJson8V710HB4210JsonStringC2EPKcmNS1_9OwnershipE: 25| 8.34k| : data_(data), size_(sz), ownership_(ownership) {} _ZNK11ArduinoJson8V710HB4210JsonString8isLinkedEv: 39| 5.02k| bool isLinked() const { 40| 5.02k| return ownership_ == Linked; 41| 5.02k| } _ZN11ArduinoJson8V710HB426detail11adaptStringINS0_10JsonStringEEENS1_13StringAdapterIT_vE13AdaptedStringERKS5_: 16| 5.02k|typename StringAdapter::AdaptedString adaptString(const TString& s) { 17| 5.02k| return StringAdapter::adapt(s); 18| 5.02k|} _ZN11ArduinoJson8V710HB426detail11adaptStringIKcEENS1_13StringAdapterIPT_vE13AdaptedStringES6_: 21| 2.96k|typename StringAdapter::AdaptedString adaptString(TChar* p) { 22| 2.96k| return StringAdapter::adapt(p); 23| 2.96k|} _ZN11ArduinoJson8V710HB426detail11adaptStringIcEENS1_18SizedStringAdapterIPT_vE13AdaptedStringES5_m: 27| 17.1k| size_t n) { 28| 17.1k| return SizedStringAdapter::adapt(p, n); 29| 17.1k|} _ZN11ArduinoJson8V710HB426detail12stringEqualsINS1_19StaticStringAdapterENS1_17JsonStringAdapterEEENS1_9enable_ifIXgtsrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES6_S7_: 61| 5.02k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 62| 5.02k| return stringEquals(s2, s1); 63| 5.02k|} _ZN11ArduinoJson8V710HB426detail12stringEqualsINS1_17JsonStringAdapterENS1_19StaticStringAdapterEEENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES6_S7_: 45| 5.02k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 46| 5.02k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 5.02k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 5.02k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 5.02k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 5.02k| size_t size1 = s1.size(); 49| 5.02k| size_t size2 = s2.size(); 50| 5.02k| if (size1 != size2) ------------------ | Branch (50:7): [True: 473, False: 4.55k] ------------------ 51| 473| return false; 52| 5.28k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (52:22): [True: 4.77k, False: 506] ------------------ 53| 4.77k| if (s1[i] != s2[i]) ------------------ | Branch (53:9): [True: 4.05k, False: 729] ------------------ 54| 4.05k| return false; 55| 4.77k| } 56| 506| return true; 57| 4.55k|} _ZN11ArduinoJson8V710HB426detail12stringEqualsINS1_14SizedRamStringES3_EENS1_9enable_ifIXlesrT_11typeSortKeysrT0_11typeSortKeyEbE4typeES5_S6_: 45| 13.6k|stringEquals(TAdaptedString1 s1, TAdaptedString2 s2) { 46| 13.6k| ARDUINOJSON_ASSERT(!s1.isNull()); ------------------ | | 11| 13.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 47| 13.6k| ARDUINOJSON_ASSERT(!s2.isNull()); ------------------ | | 11| 13.6k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 48| 13.6k| size_t size1 = s1.size(); 49| 13.6k| size_t size2 = s2.size(); 50| 13.6k| if (size1 != size2) ------------------ | Branch (50:7): [True: 1.61k, False: 12.0k] ------------------ 51| 1.61k| return false; 52| 13.6k| for (size_t i = 0; i < size1; i++) { ------------------ | Branch (52:22): [True: 11.9k, False: 1.64k] ------------------ 53| 11.9k| if (s1[i] != s2[i]) ------------------ | Branch (53:9): [True: 10.3k, False: 1.58k] ------------------ 54| 10.3k| return false; 55| 11.9k| } 56| 1.64k| return true; 57| 12.0k|} _ZN11ArduinoJson8V710HB4216JsonVariantConstC2EPKNS0_6detail11VariantDataEPKNS2_15ResourceManagerE: 43| 926| : data_(data), resources_(resources) {} _ZNK11ArduinoJson8V710HB4216JsonVariantConst7getDataEv: 178| 926| const detail::VariantData* getData() const { 179| 926| return data_; 180| 926| } _ZNK11ArduinoJson8V710HB4216JsonVariantConst18getResourceManagerEv: 182| 926| const detail::ResourceManager* getResourceManager() const { 183| 926| return resources_; 184| 926| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney7getDataINS0_16JsonVariantConstEEEDTcldtfp_7getDataEERT_: 25| 926| static auto getData(TClient& client) -> decltype(client.getData()) { 26| 926| return client.getData(); 27| 926| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney18getResourceManagerINS0_16JsonVariantConstEEEDTcldtfp_18getResourceManagerEERT_: 20| 926| -> decltype(client.getResourceManager()) { 21| 926| return client.getResourceManager(); 22| 926| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney15getOrCreateDataINS0_12JsonDocumentEEEPNS1_11VariantDataERT_: 30| 2.40k| static VariantData* getOrCreateData(TClient& client) { 31| 2.40k| return client.getOrCreateData(); 32| 2.40k| } _ZN11ArduinoJson8V710HB426detail15VariantAttorney18getResourceManagerINS0_12JsonDocumentEEEDTcldtfp_18getResourceManagerEERT_: 20| 2.40k| -> decltype(client.getResourceManager()) { 21| 2.40k| return client.getResourceManager(); 22| 2.40k| } _ZN11ArduinoJson8V710HB426detail14VariantContentC2Ev: 50| 15.6k| VariantContent() {} _ZN11ArduinoJson8V710HB426detailanENS1_11VariantTypeENS1_15VariantTypeBitsE: 45| 8.66k|inline bool operator&(VariantType type, VariantTypeBits bit) { 46| 8.66k| return (uint8_t(type) & uint8_t(bit)) != 0; 47| 8.66k|} _ZN11ArduinoJson8V710HB426detail11VariantDataC2Ev: 33| 15.6k| VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {} _ZN11ArduinoJson8V710HB426detail11VariantData6acceptINS1_14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeEPKS2_PKNS1_15ResourceManagerERSF_: 103| 926| TVisitor& visit) { 104| 926| if (var != 0) ------------------ | Branch (104:9): [True: 926, False: 0] ------------------ 105| 926| return var->accept(visit, resources); 106| 0| else 107| 0| return visit.visit(nullptr); 108| 926| } _ZNK11ArduinoJson8V710HB426detail11VariantData6acceptINS1_14JsonSerializerINS1_6WriterINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEvEEEEEENT_11result_typeERSF_PKNS1_15ResourceManagerE: 45| 3.82k| TVisitor& visit, const ResourceManager* resources) const { 46| 3.82k|#if ARDUINOJSON_USE_EXTENSIONS 47| 3.82k| auto extension = getExtension(resources); 48| |#else 49| | (void)resources; // silence warning 50| |#endif 51| 3.82k| switch (type_) { 52| 1.23k| case VariantType::Float: ------------------ | Branch (52:7): [True: 1.23k, False: 2.58k] ------------------ 53| 1.23k| return visit.visit(content_.asFloat); 54| | 55| 0|#if ARDUINOJSON_USE_DOUBLE 56| 419| case VariantType::Double: ------------------ | Branch (56:7): [True: 419, False: 3.40k] ------------------ 57| 419| return visit.visit(extension->asDouble); 58| 0|#endif 59| | 60| 516| case VariantType::Array: ------------------ | Branch (60:7): [True: 516, False: 3.30k] ------------------ 61| 516| return visit.visit(content_.asArray); 62| | 63| 189| case VariantType::Object: ------------------ | Branch (63:7): [True: 189, False: 3.63k] ------------------ 64| 189| return visit.visit(content_.asObject); 65| | 66| 0| case VariantType::LinkedString: ------------------ | Branch (66:7): [True: 0, False: 3.82k] ------------------ 67| 0| return visit.visit(JsonString(content_.asLinkedString)); 68| | 69| 352| case VariantType::OwnedString: ------------------ | Branch (69:7): [True: 352, False: 3.46k] ------------------ 70| 352| return visit.visit(JsonString(content_.asOwnedString->data, 71| 352| content_.asOwnedString->length, 72| 352| JsonString::Copied)); 73| | 74| 0| case VariantType::RawString: ------------------ | Branch (74:7): [True: 0, False: 3.82k] ------------------ 75| 0| return visit.visit(RawString(content_.asOwnedString->data, 76| 0| content_.asOwnedString->length)); 77| | 78| 216| case VariantType::Int32: ------------------ | Branch (78:7): [True: 216, False: 3.60k] ------------------ 79| 216| return visit.visit(static_cast(content_.asInt32)); 80| | 81| 316| case VariantType::Uint32: ------------------ | Branch (81:7): [True: 316, False: 3.50k] ------------------ 82| 316| return visit.visit(static_cast(content_.asUint32)); 83| | 84| 0|#if ARDUINOJSON_USE_LONG_LONG 85| 223| case VariantType::Int64: ------------------ | Branch (85:7): [True: 223, False: 3.59k] ------------------ 86| 223| return visit.visit(extension->asInt64); 87| | 88| 159| case VariantType::Uint64: ------------------ | Branch (88:7): [True: 159, False: 3.66k] ------------------ 89| 159| return visit.visit(extension->asUint64); 90| 0|#endif 91| | 92| 132| case VariantType::Boolean: ------------------ | Branch (92:7): [True: 132, False: 3.68k] ------------------ 93| 132| return visit.visit(content_.asBoolean != 0); 94| | 95| 66| default: ------------------ | Branch (95:7): [True: 66, False: 3.75k] ------------------ 96| 66| return visit.visit(nullptr); 97| 3.82k| } 98| 3.82k| } _ZNK11ArduinoJson8V710HB426detail11VariantData4nextEv: 35| 13.9k| SlotId next() const { 36| 13.9k| return next_; 37| 13.9k| } _ZN11ArduinoJson8V710HB426detail11VariantData5resetEv: 429| 2.40k| void reset() { // TODO: remove 430| 2.40k| type_ = VariantType::Null; 431| 2.40k| } _ZN11ArduinoJson8V710HB426detail11VariantDatanwEmPv: 27| 13.2k| static void* operator new(size_t, void* p) noexcept { 28| 13.2k| return p; 29| 13.2k| } _ZN11ArduinoJson8V710HB426detail11VariantData7setNextEj: 39| 10.0k| void setNext(SlotId slot) { 40| 10.0k| next_ = slot; 41| 10.0k| } _ZN11ArduinoJson8V710HB426detail11VariantData7toArrayEv: 522| 2.03k| ArrayData& toArray() { 523| 2.03k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 2.03k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 524| 2.03k| type_ = VariantType::Array; 525| 2.03k| new (&content_.asArray) ArrayData(); 526| 2.03k| return content_.asArray; 527| 2.03k| } _ZNK11ArduinoJson8V710HB426detail11VariantData8asStringEv: 271| 5.02k| JsonString asString() const { 272| 5.02k| switch (type_) { 273| 0| case VariantType::LinkedString: ------------------ | Branch (273:7): [True: 0, False: 5.02k] ------------------ 274| 0| return JsonString(content_.asLinkedString, JsonString::Linked); 275| 5.02k| case VariantType::OwnedString: ------------------ | Branch (275:7): [True: 5.02k, False: 0] ------------------ 276| 5.02k| return JsonString(content_.asOwnedString->data, 277| 5.02k| content_.asOwnedString->length, JsonString::Copied); 278| 0| default: ------------------ | Branch (278:7): [True: 0, False: 5.02k] ------------------ 279| 0| return JsonString(); 280| 5.02k| } 281| 5.02k| } _ZN11ArduinoJson8V710HB426detail11VariantData9setStringEPNS1_10StringNodeEPNS1_15ResourceManagerE: 480| 2.46k| bool setString(StringNode* s, ResourceManager*) { 481| 2.46k| setOwnedString(s); 482| 2.46k| return true; 483| 2.46k| } _ZN11ArduinoJson8V710HB426detail11VariantData14setOwnedStringEPNS1_10StringNodeE: 501| 3.53k| void setOwnedString(StringNode* s) { 502| 3.53k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.53k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 503| 3.53k| ARDUINOJSON_ASSERT(s); ------------------ | | 11| 3.53k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 504| 3.53k| type_ = VariantType::OwnedString; 505| 3.53k| content_.asOwnedString = s; 506| 3.53k| } _ZN11ArduinoJson8V710HB426detail11VariantData12asCollectionEv: 174| 1.52k| CollectionData* asCollection() { 175| 1.52k| return isCollection() ? &content_.asCollection : 0; ------------------ | Branch (175:12): [True: 413, False: 1.10k] ------------------ 176| 1.52k| } _ZNK11ArduinoJson8V710HB426detail11VariantData12isCollectionEv: 336| 1.52k| bool isCollection() const { 337| 1.52k| return type_ & VariantTypeBits::CollectionMask; 338| 1.52k| } _ZN11ArduinoJson8V710HB426detail11VariantData8toObjectEv: 536| 1.83k| ObjectData& toObject() { 537| 1.83k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 1.83k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 538| 1.83k| type_ = VariantType::Object; 539| 1.83k| new (&content_.asObject) ObjectData(); 540| 1.83k| return content_.asObject; 541| 1.83k| } _ZN11ArduinoJson8V710HB426detail11VariantData10setBooleanEb: 433| 525| void setBoolean(bool value) { 434| 525| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 525|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 435| 525| type_ = VariantType::Boolean; 436| 525| content_.asBoolean = value; 437| 525| } _ZN11ArduinoJson8V710HB426detail11VariantData8setFloatIfEENS1_9enable_ifIXeqstT_Li4EEbE4typeES5_PNS1_15ResourceManagerE: 440| 3.88k| enable_if_t setFloat(T value, ResourceManager*) { 441| 3.88k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 3.88k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 442| 3.88k| type_ = VariantType::Float; 443| 3.88k| content_.asFloat = value; 444| 3.88k| return true; 445| 3.88k| } _ZNK11ArduinoJson8V710HB426detail11VariantData7isFloatEv: 340| 276| bool isFloat() const { 341| 276| return type_ & VariantTypeBits::NumberBit; 342| 276| } _ZNK11ArduinoJson8V710HB426detail11VariantData12getExtensionEPKNS1_15ResourceManagerE: 61| 3.82k| const ResourceManager* resources) const { 62| 3.82k| return type_ & VariantTypeBits::ExtensionBit ------------------ | Branch (62:10): [True: 801, False: 3.02k] ------------------ 63| 3.82k| ? resources->getExtension(content_.asSlotId) 64| 3.82k| : nullptr; 65| 3.82k|} _ZN11ArduinoJson8V710HB426detail11VariantData5clearEPNS1_15ResourceManagerE: 43| 1.52k|inline void VariantData::clear(ResourceManager* resources) { 44| 1.52k| if (type_ & VariantTypeBits::OwnedStringBit) ------------------ | Branch (44:7): [True: 343, False: 1.17k] ------------------ 45| 343| resources->dereferenceString(content_.asOwnedString->data); 46| | 47| 1.52k|#if ARDUINOJSON_USE_EXTENSIONS 48| 1.52k| if (type_ & VariantTypeBits::ExtensionBit) ------------------ | Branch (48:7): [True: 86, False: 1.43k] ------------------ 49| 86| resources->freeExtension(content_.asSlotId); 50| 1.52k|#endif 51| | 52| 1.52k| auto collection = asCollection(); 53| 1.52k| if (collection) ------------------ | Branch (53:7): [True: 413, False: 1.10k] ------------------ 54| 413| collection->clear(resources); 55| | 56| 1.52k| type_ = VariantType::Null; 57| 1.52k|} _ZN11ArduinoJson8V710HB426detail11VariantData10setIntegerImEENS1_9enable_ifIXsr11is_unsignedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 120| 1.67k| T value, ResourceManager* resources) { 121| 1.67k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 1.67k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 122| 1.67k| (void)resources; // silence warning 123| | 124| 1.67k| if (canConvertNumber(value)) { ------------------ | Branch (124:7): [True: 1.47k, False: 200] ------------------ 125| 1.47k| type_ = VariantType::Uint32; 126| 1.47k| content_.asUint32 = static_cast(value); 127| 1.47k| } 128| 200|#if ARDUINOJSON_USE_LONG_LONG 129| 200| else { 130| 200| auto extension = resources->allocExtension(); 131| 200| if (!extension) ------------------ | Branch (131:9): [True: 0, False: 200] ------------------ 132| 0| return false; 133| 200| type_ = VariantType::Uint64; 134| 200| content_.asSlotId = extension.id(); 135| 200| extension->asUint64 = value; 136| 200| } 137| 1.67k|#endif 138| 1.67k| return true; 139| 1.67k|} _ZN11ArduinoJson8V710HB426detail11VariantData10setIntegerIlEENS1_9enable_ifIXsr9is_signedIT_EE5valueEbE4typeES5_PNS1_15ResourceManagerE: 97| 600| T value, ResourceManager* resources) { 98| 600| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 600|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 99| 600| (void)resources; // silence warning 100| | 101| 600| if (canConvertNumber(value)) { ------------------ | Branch (101:7): [True: 340, False: 260] ------------------ 102| 340| type_ = VariantType::Int32; 103| 340| content_.asInt32 = static_cast(value); 104| 340| } 105| 260|#if ARDUINOJSON_USE_LONG_LONG 106| 260| else { 107| 260| auto extension = resources->allocExtension(); 108| 260| if (!extension) ------------------ | Branch (108:9): [True: 0, False: 260] ------------------ 109| 0| return false; 110| 260| type_ = VariantType::Int64; 111| 260| content_.asSlotId = extension.id(); 112| 260| extension->asInt64 = value; 113| 260| } 114| 600|#endif 115| 600| return true; 116| 600|} _ZN11ArduinoJson8V710HB426detail11VariantData8setFloatIdEENS1_9enable_ifIXeqstT_Li8EEbE4typeES5_PNS1_15ResourceManagerE: 70| 1.08k| T value, ResourceManager* resources) { 71| 1.08k| ARDUINOJSON_ASSERT(type_ == VariantType::Null); // must call clear() first ------------------ | | 11| 1.08k|# define ARDUINOJSON_ASSERT(X) assert(X) ------------------ 72| 1.08k| (void)resources; // silence warning 73| | 74| 1.08k| float valueAsFloat = static_cast(value); 75| | 76| 1.08k|#if ARDUINOJSON_USE_DOUBLE 77| 1.08k| if (value == valueAsFloat) { ------------------ | Branch (77:7): [True: 296, False: 788] ------------------ 78| 296| type_ = VariantType::Float; 79| 296| content_.asFloat = valueAsFloat; 80| 788| } else { 81| 788| auto extension = resources->allocExtension(); 82| 788| if (!extension) ------------------ | Branch (82:9): [True: 0, False: 788] ------------------ 83| 0| return false; 84| 788| type_ = VariantType::Double; 85| 788| content_.asSlotId = extension.id(); 86| 788| extension->asDouble = value; 87| 788| } 88| |#else 89| | type_ = VariantType::Float; 90| | content_.asFloat = valueAsFloat; 91| |#endif 92| 1.08k| return true; 93| 1.08k|}