16401353174

Committed 20 Jul 2025 03:16PM UTC coverage: 99.197% (-0.02%) from 99.215%

Build # 16401353174

Build Type

push

github

Committed by

bblanchon

Commit Message

Done

Run Details

32 of 35 new or added lines in 5 files covered. (91.43%)

6 existing lines in 4 files now uncovered.

3955 of 3987 relevant lines covered (99.2%)

10923.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.67

/src/ArduinoJson/Variant/VariantData.hpp

// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2025, Benoit BLANCHON
// MIT License

#pragma once

#include <ArduinoJson/Memory/StringNode.hpp>
#include <ArduinoJson/Variant/VariantContent.hpp>

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

template <typename T>
T parseNumber(const char* s);

template <typename T>
static bool isTinyString(const T& s, size_t n) {
  if (n > tinyStringMaxLength)
    return false;
  bool containsNul = false;
  for (uint8_t i = 0; i < uint8_t(n); i++)
    containsNul |= !s[i];
  return !containsNul;
}

struct VariantData {
  VariantContent content;  // must be first to allow cast from array to variant
  VariantType type = VariantType::Null;
  SlotId next = NULL_SLOT;

  // Placement new
  static void* operator new(size_t, void* p) noexcept {
    return p;
  }

  static void operator delete(void*, void*) noexcept {}

  void setBoolean(bool value) {
    ARDUINOJSON_ASSERT(type == VariantType::Null);
    type = VariantType::Boolean;
    content.asBoolean = value;
  }

  template <typename TAdaptedString>
  void setTinyString(const TAdaptedString& s) {
    ARDUINOJSON_ASSERT(type == VariantType::Null);
    ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);

    type = VariantType::TinyString;

    auto n = uint8_t(s.size());
    for (uint8_t i = 0; i < n; i++) {
      char c = s[i];
      ARDUINOJSON_ASSERT(c != 0);  // no NUL in tiny string
      content.asTinyString[i] = c;
    }

    content.asTinyString[n] = 0;
  }

  void setOwnedString(StringNode* s) {
    ARDUINOJSON_ASSERT(type == VariantType::Null);
    ARDUINOJSON_ASSERT(s);
    type = VariantType::OwnedString;
    content.asOwnedString = s;
  }

  void setRawString(StringNode* s) {
    ARDUINOJSON_ASSERT(type == VariantType::Null);
    ARDUINOJSON_ASSERT(s);
    type = VariantType::RawString;
    content.asOwnedString = s;
  }

  bool isCollection() const {
    return type & VariantTypeBits::CollectionMask;
  }

  bool isFloat() const {
    return type & VariantTypeBits::NumberBit;
  }

  bool isString() const {
    return type == VariantType::LinkedString ||
           type == VariantType::OwnedString || type == VariantType::TinyString;
  }

  VariantData* toArray() {
    return toCollection(VariantType::Array);
  }

  VariantData* toCollection(VariantType collectionType) {
    ARDUINOJSON_ASSERT(type == VariantType::Null);
    ARDUINOJSON_ASSERT(collectionType & VariantTypeBits::CollectionMask);
    type = collectionType;
    new (&content.asCollection) CollectionData();
    return this;
  }

  VariantData* toObject() {
    return toCollection(VariantType::Object);
  }

  VariantData* getOrCreateArray() {
    switch (type) {
      case VariantType::Null:
        return toArray();
      case VariantType::Array:
        return this;
      default:
        return nullptr;
    }
  }

  VariantData* getOrCreateObject() {
    switch (type) {
      case VariantType::Null:
        return toObject();
      case VariantType::Object:
        return this;
      default:
        return nullptr;
    }
  }
};

ARDUINOJSON_END_PRIVATE_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2025, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Memory/StringNode.hpp>
8	#include <ArduinoJson/Variant/VariantContent.hpp>
9
10	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
11
12	template <typename T>
13	T parseNumber(const char* s);
14
15	template <typename T>
16	static bool isTinyString(const T& s, size_t n) {	2,017✔
17	if (n > tinyStringMaxLength)	2,017✔
18	return false;	1,725✔
19	bool containsNul = false;	292✔
20	for (uint8_t i = 0; i < uint8_t(n); i++)	934✔
21	containsNul \|= !s[i];	642✔
22	return !containsNul;	292✔
23	}
24
25	struct VariantData {
26	VariantContent content; // must be first to allow cast from array to variant
27	VariantType type = VariantType::Null;
28	SlotId next = NULL_SLOT;
29
30	// Placement new
31	static void* operator new(size_t, void* p) noexcept {	74,803✔
32	return p;	74,803✔
33	}
34
35	static void operator delete(void, void) noexcept {}
36
37	void setBoolean(bool value) {	330✔
38	ARDUINOJSON_ASSERT(type == VariantType::Null);
39	type = VariantType::Boolean;	330✔
40	content.asBoolean = value;	330✔
41	}	330✔
42
43	template <typename TAdaptedString>
44	void setTinyString(const TAdaptedString& s) {	280✔
45	ARDUINOJSON_ASSERT(type == VariantType::Null);
46	ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);
47
48	type = VariantType::TinyString;	280✔
49
50	auto n = uint8_t(s.size());	280✔
51	for (uint8_t i = 0; i < n; i++) {	886✔
52	char c = s[i];	606✔
53	ARDUINOJSON_ASSERT(c != 0); // no NUL in tiny string
54	content.asTinyString[i] = c;	606✔
55	}
56
57	content.asTinyString[n] = 0;	280✔
58	}	280✔
59
60	void setOwnedString(StringNode* s) {	1,765✔
61	ARDUINOJSON_ASSERT(type == VariantType::Null);
62	ARDUINOJSON_ASSERT(s);
63	type = VariantType::OwnedString;	1,765✔
64	content.asOwnedString = s;	1,765✔
65	}	1,765✔
66
67	void setRawString(StringNode* s) {	87✔
68	ARDUINOJSON_ASSERT(type == VariantType::Null);
69	ARDUINOJSON_ASSERT(s);
70	type = VariantType::RawString;	87✔
71	content.asOwnedString = s;	87✔
72	}	87✔
73
74	bool isCollection() const {	6,712✔
75	return type & VariantTypeBits::CollectionMask;	6,712✔
76	}
77
78	bool isFloat() const {	406✔
79	return type & VariantTypeBits::NumberBit;	406✔
80	}
81
82	bool isString() const {	80✔
83	return type == VariantType::LinkedString \|\|	136✔
84	type == VariantType::OwnedString \|\| type == VariantType::TinyString;	80✔
85	}
86
87	VariantData* toArray() {	1,280✔
88	return toCollection(VariantType::Array);	1,280✔
89	}
90
91	VariantData* toCollection(VariantType collectionType) {	2,652✔
92	ARDUINOJSON_ASSERT(type == VariantType::Null);
93	ARDUINOJSON_ASSERT(collectionType & VariantTypeBits::CollectionMask);
94	type = collectionType;	2,652✔
95	new (&content.asCollection) CollectionData();	5,304✔
96	return this;	2,652✔
97	}
98
99	VariantData* toObject() {	1,372✔
100	return toCollection(VariantType::Object);	1,372✔
101	}
102
103	VariantData* getOrCreateArray() {	444✔
104	switch (type) {	444✔
105	case VariantType::Null:	247✔
106	return toArray();	247✔
107	case VariantType::Array:	194✔
108	return this;	194✔
109	default:	3✔
110	return nullptr;	3✔
111	}
112	}
113
114	VariantData* getOrCreateObject() {	932✔
115	switch (type) {	932✔
116	case VariantType::Null:	368✔
117	return toObject();	368✔
118	case VariantType::Object:	564✔
119	return this;	564✔
UNCOV 120	default:	×
UNCOV 121	return nullptr;	×
122	}
123	}
124	};
125
126	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 16401353174

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous