5059873495

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

Remove VariantImpl.hpp

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

3280 of 3299 relevant lines covered (99.42%)

6312.26 hits per line

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

99.36

/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

void slotRelease(const VariantSlot* slot, MemoryPool* pool);
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 void variantRelease(const VariantData* var, MemoryPool* pool) {
  ARDUINOJSON_ASSERT(var != nullptr);
  auto s = var->getOwnedString();
  if (s)
    pool->dereferenceString(s);

  auto c = var->asCollection();
  if (c) {
    for (auto slot = c->head(); slot; slot = slot->next())
      slotRelease(slot, pool);
  }
}

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;
  variantRelease(var, pool);
  var->setNull();
}

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

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

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

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

  if (value.isNull()) {
    var->setNull();
    return;
  }

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

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

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

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

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

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

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 || key.isNull())
    return nullptr;
  auto obj = var->isNull() ? &var->toObject() : var->asObject();
  if (!obj)
    return nullptr;
  auto slot = obj->get(key);
  if (slot)
    return slot->data();
  return collectionAddMember(obj, key, pool);
}

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

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

inline size_t variantNesting(const VariantData* var) {
  if (!var)
    return 0;

  const CollectionData* collection = var->asCollection();
  if (!collection)
    return 0;

  size_t maxChildNesting = 0;
  for (const VariantSlot* s = collection->head(); s; s = s->next()) {
    size_t childNesting = variantNesting(s->data());
    if (childNesting > maxChildNesting)
      maxChildNesting = childNesting;
  }
  return maxChildNesting + 1;
}

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

bblanchon / ArduinoJson / 5059873495

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