5059503557

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

getOrAddMember

Run Details

12 of 12 new or added lines in 2 files covered. (100.0%)

3287 of 3306 relevant lines covered (99.43%)

6225.44 hits per line

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

99.2

/src/ArduinoJson/Variant/VariantFunctions.hpp

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

#pragma once

#include <ArduinoJson/Polyfills/assert.hpp>
#include <ArduinoJson/Polyfills/attributes.hpp>
#include <ArduinoJson/Variant/VariantData.hpp>
#include <ArduinoJson/Variant/Visitor.hpp>

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

bool collectionCopy(CollectionData* dst, const CollectionData* src,
                    MemoryPool* pool);
VariantData* collectionAddElement(CollectionData* array, MemoryPool* pool);
void collectionRemoveElement(CollectionData* data, size_t index,
                             MemoryPool* pool);
template <typename TAdaptedString>
void collectionRemoveMember(CollectionData* data, TAdaptedString key,
                            MemoryPool* pool);

template <typename TVisitor>
inline typename TVisitor::result_type variantAccept(const VariantData* var,
                                                    TVisitor& visitor) {
  if (var != 0)
    return var->accept(visitor);
  else
    return visitor.visitNull();
}

inline bool variantCopyFrom(VariantData* dst, const VariantData* src,
                            MemoryPool* pool) {
  if (!dst)
    return false;
  if (!src) {
    dst->setNull();
    return true;
  }
  switch (src->type()) {
    case VALUE_IS_ARRAY:
      return collectionCopy(&dst->toArray(), src->asArray(), pool);
    case VALUE_IS_OBJECT:
      return collectionCopy(&dst->toObject(), src->asObject(), pool);
    case VALUE_IS_OWNED_STRING: {
      auto str = adaptString(src->asString());
      auto dup = pool->saveString(str);
      if (!dup)
        return false;
      dst->setString(dup);
      return true;
    }
    case VALUE_IS_RAW_STRING: {
      auto str = adaptString(src->asRawString());
      auto dup = pool->saveString(str);
      if (!dup)
        return false;
      dst->setRawString(dup);
      return true;
    }
    default:
      *dst = *src;
      return true;
  }
}

inline void variantSetNull(VariantData* var, MemoryPool* pool) {
  if (!var)
    return;
  var->setNull(pool);
}

inline void variantSetBoolean(VariantData* var, bool value, MemoryPool* pool) {
  if (!var)
    return;
  var->setBoolean(value, pool);
}

inline void variantSetFloat(VariantData* var, JsonFloat value,
                            MemoryPool* pool) {
  if (!var)
    return;
  var->setFloat(value, pool);
}

template <typename T>
inline void variantSetInteger(VariantData* var, T value, MemoryPool* pool) {
  if (!var)
    return;
  var->setInteger(value, pool);
}

template <typename TAdaptedString>
inline void variantSetString(VariantData* var, TAdaptedString value,
                             MemoryPool* pool) {
  if (!var)
    return;
  var->setNull(pool);

  if (value.isNull())
    return;

  if (value.isLinked()) {
    var->setString(value.data());
    return;
  }

  auto dup = pool->saveString(value);
  if (dup)
    var->setString(dup);
}

template <typename T>
inline void variantSetRawString(VariantData* var, SerializedValue<T> value,
                                MemoryPool* pool) {
  if (!var)
    return;
  auto dup = pool->saveString(adaptString(value.data(), value.size()));
  if (dup)
    var->setRawString(dup, pool);
  else
    var->setNull(pool);
}

inline size_t variantSize(const VariantData* var) {
  return var != 0 ? var->size() : 0;
}

inline CollectionData* variantToArray(VariantData* var, MemoryPool* pool) {
  if (!var)
    return 0;
  return &var->toArray(pool);
}

inline CollectionData* variantToObject(VariantData* var, MemoryPool* pool) {
  if (!var)
    return 0;
  return &var->toObject(pool);
}

inline VariantData* variantGetElement(const VariantData* var, size_t index) {
  return var != 0 ? var->getElement(index) : 0;
}

inline VariantData* variantAddElement(VariantData* var, MemoryPool* pool) {
  if (!var)
    return nullptr;
  auto array = var->isNull() ? &var->toArray() : var->asArray();
  return collectionAddElement(array, pool);
}

inline NO_INLINE VariantData* variantGetOrAddElement(VariantData* var,
                                                     size_t index,
                                                     MemoryPool* pool) {
  if (!var)
    return nullptr;
  auto array = var->isNull() ? &var->toArray() : var->asArray();
  if (!array)
    return nullptr;
  VariantSlot* slot = array->head();
  while (slot && index > 0) {
    slot = slot->next();
    index--;
  }
  if (!slot)
    index++;
  while (index > 0) {
    slot = new (pool) VariantSlot();
    if (!slot)
      return nullptr;
    array->add(slot);
    index--;
  }
  return slot->data();
}

inline void variantRemoveElement(VariantData* var, size_t index,
                                 MemoryPool* pool) {
  if (!var)
    return;
  collectionRemoveElement(var->asArray(), index, pool);
}

template <typename TAdaptedString>
VariantData* variantGetMember(const VariantData* var, TAdaptedString key) {
  if (!var)
    return 0;
  return var->getMember(key);
}

template <typename TAdaptedString>
VariantData* variantGetOrAddMember(VariantData* var, TAdaptedString key,
                                   MemoryPool* pool) {
  if (!var)
    return nullptr;
  return var->getOrAddMember(key, pool);
}

template <typename TAdaptedString>
void variantRemoveMember(VariantData* var, TAdaptedString key,
                         MemoryPool* pool) {
  if (!var)
    return;
  var->removeMember(key, pool);
}

inline bool variantIsNull(const VariantData* var) {
  return var == 0 || var->isNull();
}

inline size_t variantNesting(const VariantData* var) {
  if (!var)
    return 0;
  return var->nesting();
}

ARDUINOJSON_END_PRIVATE_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2023, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Polyfills/assert.hpp>
8	#include <ArduinoJson/Polyfills/attributes.hpp>
9	#include <ArduinoJson/Variant/VariantData.hpp>
10	#include <ArduinoJson/Variant/Visitor.hpp>
11
12	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
13
14	bool collectionCopy(CollectionData* dst, const CollectionData* src,
15	MemoryPool* pool);
16	VariantData* collectionAddElement(CollectionData* array, MemoryPool* pool);
17	void collectionRemoveElement(CollectionData* data, size_t index,
18	MemoryPool* pool);
19	template <typename TAdaptedString>
20	void collectionRemoveMember(CollectionData* data, TAdaptedString key,
21	MemoryPool* pool);
22
23	template <typename TVisitor>
24	inline typename TVisitor::result_type variantAccept(const VariantData* var,	5,534✔
25	TVisitor& visitor) {
26	if (var != 0)	5,534✔
27	return var->accept(visitor);	5,377✔
28	else
29	return visitor.visitNull();	157✔
30	}
31
32	inline bool variantCopyFrom(VariantData* dst, const VariantData* src,	75✔
33	MemoryPool* pool) {
34	if (!dst)	75✔
35	return false;	4✔
36	if (!src) {	71✔
37	dst->setNull();	4✔
38	return true;	4✔
39	}
40	switch (src->type()) {	67✔
41	case VALUE_IS_ARRAY:	12✔
42	return collectionCopy(&dst->toArray(), src->asArray(), pool);	12✔
43	case VALUE_IS_OBJECT:	17✔
44	return collectionCopy(&dst->toObject(), src->asObject(), pool);	17✔
45	case VALUE_IS_OWNED_STRING: {	11✔
46	auto str = adaptString(src->asString());	11✔
47	auto dup = pool->saveString(str);	11✔
48	if (!dup)	11✔
49	return false;	1✔
50	dst->setString(dup);	10✔
51	return true;	10✔
52	}
53	case VALUE_IS_RAW_STRING: {	4✔
54	auto str = adaptString(src->asRawString());	4✔
55	auto dup = pool->saveString(str);	4✔
56	if (!dup)	4✔
57	return false;	1✔
58	dst->setRawString(dup);	3✔
59	return true;	3✔
60	}
61	default:	23✔
62	dst = src;	23✔
63	return true;	23✔
64	}
65	}
66
67	inline void variantSetNull(VariantData* var, MemoryPool* pool) {	409✔
68	if (!var)	409✔
69	return;	1✔
70	var->setNull(pool);	408✔
71	}
72
73	inline void variantSetBoolean(VariantData* var, bool value, MemoryPool* pool) {	253✔
74	if (!var)	253✔
75	return;	4✔
76	var->setBoolean(value, pool);	249✔
77	}
78
79	inline void variantSetFloat(VariantData* var, JsonFloat value,	63✔
80	MemoryPool* pool) {
81	if (!var)	63✔
82	return;	2✔
83	var->setFloat(value, pool);	61✔
84	}
85
86	template <typename T>
87	inline void variantSetInteger(VariantData* var, T value, MemoryPool* pool) {	590✔
88	if (!var)	590✔
89	return;	19✔
90	var->setInteger(value, pool);	571✔
91	}
92
93	template <typename TAdaptedString>
94	inline void variantSetString(VariantData* var, TAdaptedString value,	65,960✔
95	MemoryPool* pool) {
96	if (!var)	65,960✔
97	return;	6✔
98	var->setNull(pool);	65,954✔
99
100	if (value.isNull())	65,954✔
101	return;	65,553✔
102
103	if (value.isLinked()) {	401✔
104	var->setString(value.data());	300✔
105	return;	300✔
106	}
107
108	auto dup = pool->saveString(value);	101✔
109	if (dup)	101✔
110	var->setString(dup);	98✔
111	}
112
113	template <typename T>
114	inline void variantSetRawString(VariantData* var, SerializedValue<T> value,	33✔
115	MemoryPool* pool) {
116	if (!var)	33✔
117	return;	3✔
118	auto dup = pool->saveString(adaptString(value.data(), value.size()));	30✔
119	if (dup)	30✔
120	var->setRawString(dup, pool);	27✔
121	else
122	var->setNull(pool);	3✔
123	}
124
125	inline size_t variantSize(const VariantData* var) {	30✔
126	return var != 0 ? var->size() : 0;	30✔
127	}
128
129	inline CollectionData* variantToArray(VariantData* var, MemoryPool* pool) {	222✔
130	if (!var)	222✔
131	return 0;	2✔
132	return &var->toArray(pool);	220✔
133	}
134
135	inline CollectionData* variantToObject(VariantData* var, MemoryPool* pool) {	273✔
136	if (!var)	273✔
137	return 0;	2✔
138	return &var->toObject(pool);	271✔
139	}
140
141	inline VariantData* variantGetElement(const VariantData* var, size_t index) {	429✔
142	return var != 0 ? var->getElement(index) : 0;	429✔
143	}
144
145	inline VariantData* variantAddElement(VariantData* var, MemoryPool* pool) {	248✔
146	if (!var)	248✔
147	return nullptr;	6✔
148	auto array = var->isNull() ? &var->toArray() : var->asArray();	242✔
149	return collectionAddElement(array, pool);	242✔
150	}
151
152	inline NO_INLINE VariantData* variantGetOrAddElement(VariantData* var,	137✔
153	size_t index,
154	MemoryPool* pool) {
155	if (!var)	137✔
156	return nullptr;	1✔
157	auto array = var->isNull() ? &var->toArray() : var->asArray();	136✔
158	if (!array)	136✔
159	return nullptr;	1✔
160	VariantSlot* slot = array->head();	135✔
161	while (slot && index > 0) {	145✔
162	slot = slot->next();	10✔
163	index--;	10✔
164	}
165	if (!slot)	135✔
166	index++;	101✔
167	while (index > 0) {	249✔
168	slot = new (pool) VariantSlot();	228✔
169	if (!slot)	114✔
170	return nullptr;	×
171	array->add(slot);	114✔
172	index--;	114✔
173	}
174	return slot->data();	135✔
175	}
176
177	inline void variantRemoveElement(VariantData* var, size_t index,	8✔
178	MemoryPool* pool) {
179	if (!var)	8✔
180	return;	1✔
181	collectionRemoveElement(var->asArray(), index, pool);	7✔
182	}
183
184	template <typename TAdaptedString>
185	VariantData* variantGetMember(const VariantData* var, TAdaptedString key) {	2,140✔
186	if (!var)	2,140✔
187	return 0;	13✔
188	return var->getMember(key);	2,127✔
189	}
190
191	template <typename TAdaptedString>
192	VariantData* variantGetOrAddMember(VariantData* var, TAdaptedString key,	804✔
193	MemoryPool* pool) {
194	if (!var)	804✔
195	return nullptr;	5✔
196	return var->getOrAddMember(key, pool);	799✔
197	}
198
199	template <typename TAdaptedString>
200	void variantRemoveMember(VariantData* var, TAdaptedString key,	14✔
201	MemoryPool* pool) {
202	if (!var)	14✔
203	return;	1✔
204	var->removeMember(key, pool);	13✔
205	}
206
207	inline bool variantIsNull(const VariantData* var) {	1,237✔
208	return var == 0 \|\| var->isNull();	1,237✔
209	}
210
211	inline size_t variantNesting(const VariantData* var) {	18✔
212	if (!var)	18✔
213	return 0;	3✔
214	return var->nesting();	15✔
215	}
216
217	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 5059503557

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