17341499642

Committed 30 Aug 2025 07:55AM UTC coverage: 99.257%. Remained the same

Build # 17341499642

Build Type

push

github

Committed by

bblanchon

Commit Message

VariantImpl: add `toArrayIfNull()` and `toObjectIfNull()`

Run Details

14 of 14 new or added lines in 5 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

3874 of 3903 relevant lines covered (99.26%)

11049.15 hits per line

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

96.77

/src/ArduinoJson/Variant/VariantRefBaseImpl.hpp

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

#pragma once

#include <ArduinoJson/Array/JsonArray.hpp>
#include <ArduinoJson/Object/JsonObject.hpp>
#include <ArduinoJson/Variant/VariantRefBase.hpp>

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

template <typename TDerived>
inline JsonVariant VariantRefBase<TDerived>::add() const {
  return add<JsonVariant>();
}

template <typename TDerived>
template <typename T>
inline T VariantRefBase<TDerived>::as() const {
  using variant_type =  // JsonVariantConst or JsonVariant?
      typename function_traits<decltype(&Converter<T>::fromJson)>::arg1_type;
  return Converter<T>::fromJson(getVariant<variant_type>());
}

template <typename TDerived>
inline JsonArray VariantRefBase<TDerived>::createNestedArray() const {
  return add<JsonArray>();
}

template <typename TDerived>
template <typename TChar>
inline JsonArray VariantRefBase<TDerived>::createNestedArray(TChar* key) const {
  return operator[](key).template to<JsonArray>();
}

template <typename TDerived>
template <typename TString>
inline JsonArray VariantRefBase<TDerived>::createNestedArray(
    const TString& key) const {
  return operator[](key).template to<JsonArray>();
}

template <typename TDerived>
inline JsonObject VariantRefBase<TDerived>::createNestedObject() const {
  return add<JsonObject>();
}

template <typename TDerived>
template <typename TChar>
inline JsonObject VariantRefBase<TDerived>::createNestedObject(
    TChar* key) const {
  return operator[](key).template to<JsonObject>();
}

template <typename TDerived>
template <typename TString>
inline JsonObject VariantRefBase<TDerived>::createNestedObject(
    const TString& key) const {
  return operator[](key).template to<JsonObject>();
}

template <typename TDerived>
inline bool convertToJson(const VariantRefBase<TDerived>& src,
                          JsonVariant dst) {
  return dst.set(src.template as<JsonVariantConst>());
}

template <typename TDerived>
template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
inline T VariantRefBase<TDerived>::add() const {
  return getOrCreateArray().template add<T>();
}

template <typename TDerived>
template <typename TString, enable_if_t<IsString<TString>::value, int>>
inline bool VariantRefBase<TDerived>::containsKey(const TString& key) const {
  return getImpl().getMember(adaptString(key)) != 0;
}

template <typename TDerived>
template <typename TChar, enable_if_t<IsString<TChar*>::value, int>>
inline bool VariantRefBase<TDerived>::containsKey(TChar* key) const {
  return getImpl().getMember(adaptString(key)) != 0;
}

template <typename TDerived>
template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int>>
inline bool VariantRefBase<TDerived>::containsKey(const TVariant& key) const {
  return containsKey(key.template as<const char*>());
}

template <typename TDerived>
inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
  return JsonVariant(getImpl());
}

template <typename TDerived>
template <typename T>
inline bool VariantRefBase<TDerived>::is() const {
  using variant_type =  // JsonVariantConst or JsonVariant?
      typename function_traits<decltype(&Converter<T>::checkJson)>::arg1_type;
  return Converter<T>::checkJson(getVariant<variant_type>());
}

template <typename TDerived>
inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](
    size_t index) const {
  return {derived(), index};
}

template <typename TDerived>
template <typename TChar,
          enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int>>
inline MemberProxy<TDerived, AdaptedString<TChar*>>
VariantRefBase<TDerived>::operator[](TChar* key) const {
  return {derived(), adaptString(key)};
}

template <typename TDerived>
template <typename TString, enable_if_t<IsString<TString>::value, int>>
inline MemberProxy<TDerived, AdaptedString<TString>>
VariantRefBase<TDerived>::operator[](const TString& key) const {
  return {derived(), adaptString(key)};
}

template <typename TDerived>
template <typename TConverter, typename T>
inline bool VariantRefBase<TDerived>::doSet(const T& value, false_type) const {
  auto impl = getOrCreateImpl();
  TConverter::toJson(value, JsonVariant(impl));
  auto resources = impl.resources();
  return resources && !resources->overflowed();
}

template <typename TDerived>
template <typename TConverter, typename T>
inline bool VariantRefBase<TDerived>::doSet(const T& value, true_type) const {
  auto impl = getOrCreateImpl();
  return TConverter::toJson(value, JsonVariant(impl));
}

template <typename TDerived>
inline JsonArray VariantRefBase<TDerived>::getOrCreateArray() const {
  auto impl = getOrCreateImpl();
  impl.toArrayIfNull();
  return JsonArray(impl);
}

template <typename TDerived>
template <typename T, enable_if_t<is_same<T, JsonArray>::value, int>>
inline JsonArray VariantRefBase<TDerived>::to() const {
  auto impl = getOrCreateImpl();
  if (impl.isUnbound())
    return JsonArray();
  impl.clear();
  impl.data()->toArray();
  return JsonArray(impl);
}

template <typename TDerived>
template <typename T, enable_if_t<is_same<T, JsonObject>::value, int>>
JsonObject VariantRefBase<TDerived>::to() const {
  auto impl = getOrCreateImpl();
  if (impl.isUnbound())
    return JsonObject();
  impl.clear();
  impl.data()->toObject();
  return JsonObject(impl);
}

template <typename TDerived>
template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
JsonVariant VariantRefBase<TDerived>::to() const {
  auto impl = getOrCreateImpl();
  impl.clear();
  return JsonVariant(impl);
}

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/Array/JsonArray.hpp>
8	#include <ArduinoJson/Object/JsonObject.hpp>
9	#include <ArduinoJson/Variant/VariantRefBase.hpp>
10
11	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
12
13	template <typename TDerived>
14	inline JsonVariant VariantRefBase<TDerived>::add() const {	3✔
15	return add<JsonVariant>();	3✔
16	}
17
18	template <typename TDerived>
19	template <typename T>
20	inline T VariantRefBase<TDerived>::as() const {	1,883✔
21	using variant_type = // JsonVariantConst or JsonVariant?
22	typename function_traits<decltype(&Converter<T>::fromJson)>::arg1_type;
23	return Converter<T>::fromJson(getVariant<variant_type>());	1,883✔
24	}
25
26	template <typename TDerived>
27	inline JsonArray VariantRefBase<TDerived>::createNestedArray() const {	1✔
28	return add<JsonArray>();	1✔
29	}
30
31	template <typename TDerived>
32	template <typename TChar>
33	inline JsonArray VariantRefBase<TDerived>::createNestedArray(TChar* key) const {	2✔
34	return operator[](key).template to<JsonArray>();	2✔
35	}
36
37	template <typename TDerived>
38	template <typename TString>
39	inline JsonArray VariantRefBase<TDerived>::createNestedArray(	1✔
40	const TString& key) const {
41	return operator[](key).template to<JsonArray>();	1✔
42	}
43
44	template <typename TDerived>
45	inline JsonObject VariantRefBase<TDerived>::createNestedObject() const {	1✔
46	return add<JsonObject>();	1✔
47	}
48
49	template <typename TDerived>
50	template <typename TChar>
51	inline JsonObject VariantRefBase<TDerived>::createNestedObject(	2✔
52	TChar* key) const {
53	return operator[](key).template to<JsonObject>();	2✔
54	}
55
56	template <typename TDerived>
57	template <typename TString>
58	inline JsonObject VariantRefBase<TDerived>::createNestedObject(	1✔
59	const TString& key) const {
60	return operator[](key).template to<JsonObject>();	1✔
61	}
62
63	template <typename TDerived>
64	inline bool convertToJson(const VariantRefBase<TDerived>& src,	10✔
65	JsonVariant dst) {
66	return dst.set(src.template as<JsonVariantConst>());	10✔
67	}
68
69	template <typename TDerived>
70	template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
71	inline T VariantRefBase<TDerived>::add() const {	41✔
72	return getOrCreateArray().template add<T>();	41✔
73	}
74
75	template <typename TDerived>
76	template <typename TString, enable_if_t<IsString<TString>::value, int>>
77	inline bool VariantRefBase<TDerived>::containsKey(const TString& key) const {	4✔
78	return getImpl().getMember(adaptString(key)) != 0;	4✔
79	}
80
81	template <typename TDerived>
82	template <typename TChar, enable_if_t<IsString<TChar*>::value, int>>
83	inline bool VariantRefBase<TDerived>::containsKey(TChar* key) const {	9✔
84	return getImpl().getMember(adaptString(key)) != 0;	9✔
85	}
86
87	template <typename TDerived>
88	template <typename TVariant, enable_if_t<IsVariant<TVariant>::value, int>>
89	inline bool VariantRefBase<TDerived>::containsKey(const TVariant& key) const {	2✔
90	return containsKey(key.template as<const char*>());	2✔
91	}
92
93	template <typename TDerived>
94	inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
95	return JsonVariant(getImpl());	281✔
96	}
97
98	template <typename TDerived>
99	template <typename T>
100	inline bool VariantRefBase<TDerived>::is() const {
101	using variant_type = // JsonVariantConst or JsonVariant?
102	typename function_traits<decltype(&Converter<T>::checkJson)>::arg1_type;
103	return Converter<T>::checkJson(getVariant<variant_type>());	365✔
104	}
105
106	template <typename TDerived>
107	inline ElementProxy<TDerived> VariantRefBase<TDerived>::operator[](	102✔
108	size_t index) const {
109	return {derived(), index};	102✔
110	}
111
112	template <typename TDerived>
113	template <typename TChar,
114	enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int>>
115	inline MemberProxy<TDerived, AdaptedString<TChar*>>
116	VariantRefBase<TDerived>::operator[](TChar* key) const {
117	return {derived(), adaptString(key)};	9✔
118	}
119
120	template <typename TDerived>
121	template <typename TString, enable_if_t<IsString<TString>::value, int>>
122	inline MemberProxy<TDerived, AdaptedString<TString>>
123	VariantRefBase<TDerived>::operator[](const TString& key) const {
124	return {derived(), adaptString(key)};	179✔
125	}
126
127	template <typename TDerived>
128	template <typename TConverter, typename T>
129	inline bool VariantRefBase<TDerived>::doSet(const T& value, false_type) const {	5✔
130	auto impl = getOrCreateImpl();	5✔
131	TConverter::toJson(value, JsonVariant(impl));	5✔
132	auto resources = impl.resources();	5✔
133	return resources && !resources->overflowed();	5✔
134	}
135
136	template <typename TDerived>
137	template <typename TConverter, typename T>
138	inline bool VariantRefBase<TDerived>::doSet(const T& value, true_type) const {	67,985✔
139	auto impl = getOrCreateImpl();	67,985✔
140	return TConverter::toJson(value, JsonVariant(impl));	67,985✔
141	}
142
143	template <typename TDerived>
144	inline JsonArray VariantRefBase<TDerived>::getOrCreateArray() const {	90✔
145	auto impl = getOrCreateImpl();	90✔
146	impl.toArrayIfNull();	90✔
147	return JsonArray(impl);	90✔
148	}
149
150	template <typename TDerived>
151	template <typename T, enable_if_t<is_same<T, JsonArray>::value, int>>
152	inline JsonArray VariantRefBase<TDerived>::to() const {	253✔
153	auto impl = getOrCreateImpl();	253✔
154	if (impl.isUnbound())	253✔
UNCOV 155	return JsonArray();	×
156	impl.clear();	253✔
157	impl.data()->toArray();	253✔
158	return JsonArray(impl);	253✔
159	}
160
161	template <typename TDerived>
162	template <typename T, enable_if_t<is_same<T, JsonObject>::value, int>>
163	JsonObject VariantRefBase<TDerived>::to() const {	298✔
164	auto impl = getOrCreateImpl();	298✔
165	if (impl.isUnbound())	298✔
UNCOV 166	return JsonObject();	×
167	impl.clear();	298✔
168	impl.data()->toObject();	298✔
169	return JsonObject(impl);	298✔
170	}
171
172	template <typename TDerived>
173	template <typename T, enable_if_t<is_same<T, JsonVariant>::value, int>>
174	JsonVariant VariantRefBase<TDerived>::to() const {	515✔
175	auto impl = getOrCreateImpl();	515✔
176	impl.clear();	515✔
177	return JsonVariant(impl);	515✔
178	}
179
180	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 17341499642

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