6175307035

Committed 13 Sep 2023 04:32PM CUT coverage: 99.544%. Remained the same

Build # 6175307035

Build Type

push

github

Committed by

bblanchon

Commit Message

Fix 'std::string_view' has not been declared (issue #1967)

Ported from 49e2a8d42

Run Details

3494 of 3510 relevant lines covered (99.54%)

8634.54 hits per line

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

98.88

/src/ArduinoJson/Variant/ConverterImpl.hpp

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

#pragma once

#include <ArduinoJson/Json/JsonSerializer.hpp>
#include <ArduinoJson/Memory/StringBuilder.hpp>
#include <ArduinoJson/Polyfills/utility.hpp>
#include <ArduinoJson/Variant/JsonVariantConst.hpp>

#if ARDUINOJSON_ENABLE_STD_STRING
#  include <string>
#endif

#if ARDUINOJSON_ENABLE_STRING_VIEW
#  include <string_view>
#endif

ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE

template <typename T, typename Enable>
struct Converter {
  static void toJson(const T& src, JsonVariant dst) {
    // clang-format off
    convertToJson(src, dst); // Error here? See https://arduinojson.org/v7/unsupported-set/
    // clang-format on
  }

  static T fromJson(JsonVariantConst src) {
    // clang-format off
    T result; // Error here? See https://arduinojson.org/v7/non-default-constructible/
    convertFromJson(src, result);  // Error here? See https://arduinojson.org/v7/unsupported-as/
    // clang-format on
    return result;
  }

  static bool checkJson(JsonVariantConst src) {
    T dummy = T();
    // clang-format off
    return canConvertFromJson(src, dummy);  // Error here? See https://arduinojson.org/v7/unsupported-is/
    // clang-format on
  }
};

template <typename T>
struct Converter<
    T, typename detail::enable_if<detail::is_integral<T>::value &&
                                  !detail::is_same<bool, T>::value &&
                                  !detail::is_same<char, T>::value>::type>
    : private detail::VariantAttorney {
  static void toJson(T src, JsonVariant dst) {
    ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
    auto data = getData(dst);
    if (data)
      data->setInteger(src, getResourceManager(dst));
  }

  static T fromJson(JsonVariantConst src) {
    ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
    auto data = getData(src);
    return data ? data->template asIntegral<T>() : T();
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->template isInteger<T>();
  }
};

template <typename T>
struct Converter<T, typename detail::enable_if<detail::is_enum<T>::value>::type>
    : private detail::VariantAttorney {
  static void toJson(T src, JsonVariant dst) {
    dst.set(static_cast<JsonInteger>(src));
  }

  static T fromJson(JsonVariantConst src) {
    auto data = getData(src);
    return data ? static_cast<T>(data->template asIntegral<int>()) : T();
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->template isInteger<int>();
  }
};

template <>
struct Converter<bool> : private detail::VariantAttorney {
  static void toJson(bool src, JsonVariant dst) {
    auto data = getData(dst);
    if (data)
      data->setBoolean(src, getResourceManager(dst));
  }

  static bool fromJson(JsonVariantConst src) {
    auto data = getData(src);
    return data ? data->asBoolean() : false;
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isBoolean();
  }
};

template <typename T>
struct Converter<
    T, typename detail::enable_if<detail::is_floating_point<T>::value>::type>
    : private detail::VariantAttorney {
  static void toJson(T src, JsonVariant dst) {
    auto data = getData(dst);
    if (data)
      data->setFloat(static_cast<JsonFloat>(src), getResourceManager(dst));
  }

  static T fromJson(JsonVariantConst src) {
    auto data = getData(src);
    return data ? data->template asFloat<T>() : 0;
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isFloat();
  }
};

template <>
struct Converter<const char*> : private detail::VariantAttorney {
  static void toJson(const char* src, JsonVariant dst) {
    detail::VariantData::setString(getData(dst), detail::adaptString(src),
                                   getResourceManager(dst));
  }

  static const char* fromJson(JsonVariantConst src) {
    auto data = getData(src);
    return data ? data->asString().c_str() : 0;
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isString();
  }
};

template <>
struct Converter<JsonString> : private detail::VariantAttorney {
  static void toJson(JsonString src, JsonVariant dst) {
    detail::VariantData::setString(getData(dst), detail::adaptString(src),
                                   getResourceManager(dst));
  }

  static JsonString fromJson(JsonVariantConst src) {
    auto data = getData(src);
    return data ? data->asString() : 0;
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isString();
  }
};

template <typename T>
inline typename detail::enable_if<detail::IsString<T>::value>::type
convertToJson(const T& src, JsonVariant dst) {
  using namespace detail;
  auto data = VariantAttorney::getData(dst);
  auto resources = VariantAttorney::getResourceManager(dst);
  detail::VariantData::setString(data, adaptString(src), resources);
}

// SerializedValue<std::string>
// SerializedValue<String>
// SerializedValue<const __FlashStringHelper*>
template <typename T>
struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
  static void toJson(SerializedValue<T> src, JsonVariant dst) {
    detail::VariantData::setRawString(getData(dst), src,
                                      getResourceManager(dst));
  }
};

template <>
struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
  static void toJson(detail::nullptr_t, JsonVariant dst) {
    detail::VariantData::setNull(getData(dst), getResourceManager(dst));
  }
  static detail::nullptr_t fromJson(JsonVariantConst) {
    return nullptr;
  }
  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data == 0 || data->isNull();
  }
};

#if ARDUINOJSON_ENABLE_ARDUINO_STREAM

namespace detail {
class StringBuilderPrint : public Print {
 public:
  StringBuilderPrint(ResourceManager* resources) : copier_(resources) {
    copier_.startString();
  }

  StringNode* save() {
    ARDUINOJSON_ASSERT(!overflowed());
    return copier_.save();
  }

  size_t write(uint8_t c) {
    copier_.append(char(c));
    return copier_.isValid() ? 1 : 0;
  }

  size_t write(const uint8_t* buffer, size_t size) {
    for (size_t i = 0; i < size; i++) {
      copier_.append(char(buffer[i]));
      if (!copier_.isValid())
        return i;
    }
    return size;
  }

  bool overflowed() const {
    return !copier_.isValid();
  }

 private:
  StringBuilder copier_;
};
}  // namespace detail

inline void convertToJson(const ::Printable& src, JsonVariant dst) {
  auto resources = detail::VariantAttorney::getResourceManager(dst);
  auto data = detail::VariantAttorney::getData(dst);
  if (!resources || !data)
    return;
  detail::StringBuilderPrint print(resources);
  src.printTo(print);
  if (print.overflowed()) {
    data->setNull();
    return;
  }
  data->setOwnedString(print.save());
}

#endif

#if ARDUINOJSON_ENABLE_ARDUINO_STRING

inline void convertFromJson(JsonVariantConst src, ::String& dst) {
  JsonString str = src.as<JsonString>();
  if (str)
    dst = str.c_str();
  else
    serializeJson(src, dst);
}

inline bool canConvertFromJson(JsonVariantConst src, const ::String&) {
  return src.is<JsonString>();
}

#endif

#if ARDUINOJSON_ENABLE_STD_STRING

inline void convertFromJson(JsonVariantConst src, std::string& dst) {
  JsonString str = src.as<JsonString>();
  if (str)
    dst.assign(str.c_str(), str.size());
  else
    serializeJson(src, dst);
}

inline bool canConvertFromJson(JsonVariantConst src, const std::string&) {
  return src.is<JsonString>();
}

#endif

#if ARDUINOJSON_ENABLE_STRING_VIEW

inline void convertFromJson(JsonVariantConst src, std::string_view& dst) {
  JsonString str = src.as<JsonString>();
  if (str)  // the standard doesn't allow passing null to the constructor
    dst = std::string_view(str.c_str(), str.size());
}

inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
  return src.is<JsonString>();
}

#endif

namespace detail {
template <typename T>
struct ConverterNeedsWriteableRef {
 protected:  // <- to avoid GCC's "all member functions in class are private"
  static int probe(T (*f)(ArduinoJson::JsonVariant));
  static char probe(T (*f)(ArduinoJson::JsonVariantConst));

 public:
  static const bool value =
      sizeof(probe(Converter<T>::fromJson)) == sizeof(int);
};
}  // namespace detail

template <>
struct Converter<JsonArrayConst> : private detail::VariantAttorney {
  static void toJson(JsonArrayConst src, JsonVariant dst) {
    if (src.isNull())
      dst.set(nullptr);
    else
      dst.to<JsonArray>().set(src);
  }

  static JsonArrayConst fromJson(JsonVariantConst src) {
    auto data = getData(src);
    auto array = data ? data->asArray() : nullptr;
    return JsonArrayConst(array, getResourceManager(src));
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isArray();
  }
};

template <>
struct Converter<JsonArray> : private detail::VariantAttorney {
  static void toJson(JsonVariantConst src, JsonVariant dst) {
    if (src.isNull())
      dst.set(nullptr);
    else
      dst.to<JsonArray>().set(src);
  }

  static JsonArray fromJson(JsonVariant src) {
    auto data = getData(src);
    auto resources = getResourceManager(src);
    return JsonArray(data != 0 ? data->asArray() : 0, resources);
  }

  static detail::InvalidConversion<JsonVariantConst, JsonArray> fromJson(
      JsonVariantConst);

  static bool checkJson(JsonVariantConst) {
    return false;
  }

  static bool checkJson(JsonVariant src) {
    auto data = getData(src);
    return data && data->isArray();
  }
};

template <>
struct Converter<JsonObjectConst> : private detail::VariantAttorney {
  static void toJson(JsonVariantConst src, JsonVariant dst) {
    if (src.isNull())
      dst.set(nullptr);
    else
      dst.to<JsonObject>().set(src);
  }

  static JsonObjectConst fromJson(JsonVariantConst src) {
    auto data = getData(src);
    auto object = data != 0 ? data->asObject() : nullptr;
    return JsonObjectConst(object, getResourceManager(src));
  }

  static bool checkJson(JsonVariantConst src) {
    auto data = getData(src);
    return data && data->isObject();
  }
};

template <>
struct Converter<JsonObject> : private detail::VariantAttorney {
  static void toJson(JsonVariantConst src, JsonVariant dst) {
    if (src.isNull())
      dst.set(nullptr);
    else
      dst.to<JsonObject>().set(src);
  }

  static JsonObject fromJson(JsonVariant src) {
    auto data = getData(src);
    auto resources = getResourceManager(src);
    return JsonObject(data != 0 ? data->asObject() : 0, resources);
  }

  static detail::InvalidConversion<JsonVariantConst, JsonObject> fromJson(
      JsonVariantConst);

  static bool checkJson(JsonVariantConst) {
    return false;
  }

  static bool checkJson(JsonVariant src) {
    auto data = getData(src);
    return data && data->isObject();
  }
};

ARDUINOJSON_END_PUBLIC_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2023, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Json/JsonSerializer.hpp>
8	#include <ArduinoJson/Memory/StringBuilder.hpp>
9	#include <ArduinoJson/Polyfills/utility.hpp>
10	#include <ArduinoJson/Variant/JsonVariantConst.hpp>
11
12	#if ARDUINOJSON_ENABLE_STD_STRING
13	# include <string>
14	#endif
15
16	#if ARDUINOJSON_ENABLE_STRING_VIEW
17	# include <string_view>
18	#endif
19
20	ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
21
22	template <typename T, typename Enable>
23	struct Converter {
24	static void toJson(const T& src, JsonVariant dst) {	134✔
25	// clang-format off
26	convertToJson(src, dst); // Error here? See https://arduinojson.org/v7/unsupported-set/	134✔
27	// clang-format on
28	}	134✔
29
30	static T fromJson(JsonVariantConst src) {	436✔
31	// clang-format off
32	T result; // Error here? See https://arduinojson.org/v7/non-default-constructible/	435✔
33	convertFromJson(src, result); // Error here? See https://arduinojson.org/v7/unsupported-as/	436✔
34	// clang-format on
35	return result;	436✔
36	}
37
38	static bool checkJson(JsonVariantConst src) {	25✔
39	T dummy = T();	46✔
40	// clang-format off
41	return canConvertFromJson(src, dummy); // Error here? See https://arduinojson.org/v7/unsupported-is/	50✔
42	// clang-format on
43	}
44	};
45
46	template <typename T>
47	struct Converter<
48	T, typename detail::enable_if<detail::is_integral<T>::value &&
49	!detail::is_same<bool, T>::value &&
50	!detail::is_same<char, T>::value>::type>
51	: private detail::VariantAttorney {
52	static void toJson(T src, JsonVariant dst) {	981✔
53	ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
54	auto data = getData(dst);	981✔
55	if (data)	981✔
56	data->setInteger(src, getResourceManager(dst));	957✔
57	}	981✔
58
59	static T fromJson(JsonVariantConst src) {	212✔
60	ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
61	auto data = getData(src);	212✔
62	return data ? data->template asIntegral<T>() : T();	212✔
63	}
64
65	static bool checkJson(JsonVariantConst src) {	110✔
66	auto data = getData(src);	110✔
67	return data && data->template isInteger<T>();	110✔
68	}
69	};
70
71	template <typename T>
72	struct Converter<T, typename detail::enable_if<detail::is_enum<T>::value>::type>
73	: private detail::VariantAttorney {
74	static void toJson(T src, JsonVariant dst) {	1✔
75	dst.set(static_cast<JsonInteger>(src));	1✔
76	}	1✔
77
78	static T fromJson(JsonVariantConst src) {	1✔
79	auto data = getData(src);	1✔
80	return data ? static_cast<T>(data->template asIntegral<int>()) : T();	1✔
81	}
82
83	static bool checkJson(JsonVariantConst src) {	18✔
84	auto data = getData(src);	18✔
85	return data && data->template isInteger<int>();	18✔
86	}
87	};
88
89	template <>
90	struct Converter<bool> : private detail::VariantAttorney {
91	static void toJson(bool src, JsonVariant dst) {	250✔
92	auto data = getData(dst);	250✔
93	if (data)	250✔
94	data->setBoolean(src, getResourceManager(dst));	247✔
95	}	250✔
96
97	static bool fromJson(JsonVariantConst src) {	1,247✔
98	auto data = getData(src);	1,247✔
99	return data ? data->asBoolean() : false;	1,247✔
100	}
101
102	static bool checkJson(JsonVariantConst src) {	38✔
103	auto data = getData(src);	38✔
104	return data && data->isBoolean();	38✔
105	}
106	};
107
108	template <typename T>
109	struct Converter<
110	T, typename detail::enable_if<detail::is_floating_point<T>::value>::type>
111	: private detail::VariantAttorney {
112	static void toJson(T src, JsonVariant dst) {	63✔
113	auto data = getData(dst);	63✔
114	if (data)	63✔
115	data->setFloat(static_cast<JsonFloat>(src), getResourceManager(dst));	61✔
116	}	63✔
117
118	static T fromJson(JsonVariantConst src) {	118✔
119	auto data = getData(src);	118✔
120	return data ? data->template asFloat<T>() : 0;	118✔
121	}
122
123	static bool checkJson(JsonVariantConst src) {	45✔
124	auto data = getData(src);	45✔
125	return data && data->isFloat();	45✔
126	}
127	};
128
129	template <>
130	struct Converter<const char*> : private detail::VariantAttorney {
131	static void toJson(const char* src, JsonVariant dst) {	65,855✔
132	detail::VariantData::setString(getData(dst), detail::adaptString(src),	131,710✔
133	getResourceManager(dst));
134	}	65,855✔
135
136	static const char* fromJson(JsonVariantConst src) {	38✔
137	auto data = getData(src);	38✔
138	return data ? data->asString().c_str() : 0;	38✔
139	}
140
141	static bool checkJson(JsonVariantConst src) {	35✔
142	auto data = getData(src);	35✔
143	return data && data->isString();	35✔
144	}
145	};
146
147	template <>
148	struct Converter<JsonString> : private detail::VariantAttorney {
149	static void toJson(JsonString src, JsonVariant dst) {	35✔
150	detail::VariantData::setString(getData(dst), detail::adaptString(src),	70✔
151	getResourceManager(dst));
152	}	35✔
153
154	static JsonString fromJson(JsonVariantConst src) {	461✔
155	auto data = getData(src);	461✔
156	return data ? data->asString() : 0;	461✔
157	}
158
159	static bool checkJson(JsonVariantConst src) {	39✔
160	auto data = getData(src);	39✔
161	return data && data->isString();	39✔
162	}
163	};
164
165	template <typename T>
166	inline typename detail::enable_if<detail::IsString<T>::value>::type
167	convertToJson(const T& src, JsonVariant dst) {	115✔
168	using namespace detail;
169	auto data = VariantAttorney::getData(dst);	115✔
170	auto resources = VariantAttorney::getResourceManager(dst);	115✔
171	detail::VariantData::setString(data, adaptString(src), resources);	115✔
172	}	115✔
173
174	// SerializedValue<std::string>
175	// SerializedValue<String>
176	// SerializedValue<const __FlashStringHelper*>
177	template <typename T>
178	struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
179	static void toJson(SerializedValue<T> src, JsonVariant dst) {	36✔
180	detail::VariantData::setRawString(getData(dst), src,	72✔
181	getResourceManager(dst));
182	}	36✔
183	};
184
185	template <>
186	struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
187	static void toJson(detail::nullptr_t, JsonVariant dst) {	6✔
188	detail::VariantData::setNull(getData(dst), getResourceManager(dst));	12✔
189	}	6✔
190	static detail::nullptr_t fromJson(JsonVariantConst) {	1✔
191	return nullptr;	1✔
192	}
193	static bool checkJson(JsonVariantConst src) {	3✔
194	auto data = getData(src);	3✔
195	return data == 0 \|\| data->isNull();	3✔
196	}
197	};
198
199	#if ARDUINOJSON_ENABLE_ARDUINO_STREAM
200
201	namespace detail {
202	class StringBuilderPrint : public Print {
203	public:
204	StringBuilderPrint(ResourceManager* resources) : copier_(resources) {	8✔
205	copier_.startString();	8✔
206	}	8✔
207
208	StringNode* save() {	4✔
209	ARDUINOJSON_ASSERT(!overflowed());
210	return copier_.save();	4✔
211	}
212
213	size_t write(uint8_t c) {	52✔
214	copier_.append(char(c));	52✔
215	return copier_.isValid() ? 1 : 0;	52✔
216	}
217
218	size_t write(const uint8_t* buffer, size_t size) {	4✔
219	for (size_t i = 0; i < size; i++) {	54✔
220	copier_.append(char(buffer[i]));	52✔
221	if (!copier_.isValid())	52✔
222	return i;	2✔
223	}
224	return size;	2✔
225	}
226
227	bool overflowed() const {	8✔
228	return !copier_.isValid();	8✔
229	}
230
231	private:
232	StringBuilder copier_;
233	};
234	} // namespace detail
235
236	inline void convertToJson(const ::Printable& src, JsonVariant dst) {	9✔
237	auto resources = detail::VariantAttorney::getResourceManager(dst);	9✔
238	auto data = detail::VariantAttorney::getData(dst);	9✔
239	if (!resources \|\| !data)	9✔
240	return;	5✔
241	detail::StringBuilderPrint print(resources);	8✔
242	src.printTo(print);	8✔
243	if (print.overflowed()) {	8✔
244	data->setNull();	4✔
245	return;	4✔
246	}
247	data->setOwnedString(print.save());	4✔
248	}
249
250	#endif
251
252	#if ARDUINOJSON_ENABLE_ARDUINO_STRING
253
254	inline void convertFromJson(JsonVariantConst src, ::String& dst) {
255	JsonString str = src.as<JsonString>();
256	if (str)
257	dst = str.c_str();
258	else
259	serializeJson(src, dst);
260	}
261
262	inline bool canConvertFromJson(JsonVariantConst src, const ::String&) {
263	return src.is<JsonString>();
264	}
265
266	#endif
267
268	#if ARDUINOJSON_ENABLE_STD_STRING
269
270	inline void convertFromJson(JsonVariantConst src, std::string& dst) {	430✔
271	JsonString str = src.as<JsonString>();
272	if (str)	430✔
273	dst.assign(str.c_str(), str.size());	52✔
274	else
275	serializeJson(src, dst);	378✔
276	}	430✔
277
278	inline bool canConvertFromJson(JsonVariantConst src, const std::string&) {	21✔
279	return src.is<JsonString>();	21✔
280	}
281
282	#endif
283
284	#if ARDUINOJSON_ENABLE_STRING_VIEW
285
286	inline void convertFromJson(JsonVariantConst src, std::string_view& dst) {	5✔
287	JsonString str = src.as<JsonString>();
288	if (str) // the standard doesn't allow passing null to the constructor	5✔
289	dst = std::string_view(str.c_str(), str.size());	4✔
290	}	5✔
291
292	inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {	2✔
293	return src.is<JsonString>();	2✔
294	}
295
296	#endif
297
298	namespace detail {
299	template <typename T>
300	struct ConverterNeedsWriteableRef {
301	protected: // <- to avoid GCC's "all member functions in class are private"
302	static int probe(T (*f)(ArduinoJson::JsonVariant));
303	static char probe(T (*f)(ArduinoJson::JsonVariantConst));
304
305	public:
306	static const bool value =
307	sizeof(probe(Converter<T>::fromJson)) == sizeof(int);
308	};
309	} // namespace detail
310
311	template <>
312	struct Converter<JsonArrayConst> : private detail::VariantAttorney {
313	static void toJson(JsonArrayConst src, JsonVariant dst) {	3✔
314	if (src.isNull())	3✔
315	dst.set(nullptr);	×
316	else
317	dst.to<JsonArray>().set(src);	6✔
318	}	3✔
319
320	static JsonArrayConst fromJson(JsonVariantConst src) {	34✔
321	auto data = getData(src);	34✔
322	auto array = data ? data->asArray() : nullptr;	34✔
323	return JsonArrayConst(array, getResourceManager(src));	34✔
324	}
325
326	static bool checkJson(JsonVariantConst src) {	80✔
327	auto data = getData(src);	80✔
328	return data && data->isArray();	80✔
329	}
330	};
331
332	template <>
333	struct Converter<JsonArray> : private detail::VariantAttorney {
334	static void toJson(JsonVariantConst src, JsonVariant dst) {	11✔
335	if (src.isNull())	11✔
336	dst.set(nullptr);	2✔
337	else
338	dst.to<JsonArray>().set(src);	20✔
339	}	11✔
340
341	static JsonArray fromJson(JsonVariant src) {	75✔
342	auto data = getData(src);	75✔
343	auto resources = getResourceManager(src);	75✔
344	return JsonArray(data != 0 ? data->asArray() : 0, resources);	150✔
345	}
346
347	static detail::InvalidConversion<JsonVariantConst, JsonArray> fromJson(
348	JsonVariantConst);
349
350	static bool checkJson(JsonVariantConst) {	9✔
351	return false;	9✔
352	}
353
354	static bool checkJson(JsonVariant src) {	16✔
355	auto data = getData(src);	16✔
356	return data && data->isArray();	16✔
357	}
358	};
359
360	template <>
361	struct Converter<JsonObjectConst> : private detail::VariantAttorney {
362	static void toJson(JsonVariantConst src, JsonVariant dst) {	9✔
363	if (src.isNull())	9✔
364	dst.set(nullptr);	×
365	else
366	dst.to<JsonObject>().set(src);	18✔
367	}	9✔
368
369	static JsonObjectConst fromJson(JsonVariantConst src) {	21✔
370	auto data = getData(src);	21✔
371	auto object = data != 0 ? data->asObject() : nullptr;	21✔
372	return JsonObjectConst(object, getResourceManager(src));	21✔
373	}
374
375	static bool checkJson(JsonVariantConst src) {	303✔
376	auto data = getData(src);	303✔
377	return data && data->isObject();	303✔
378	}
379	};
380
381	template <>
382	struct Converter<JsonObject> : private detail::VariantAttorney {
383	static void toJson(JsonVariantConst src, JsonVariant dst) {	12✔
384	if (src.isNull())	12✔
385	dst.set(nullptr);	2✔
386	else
387	dst.to<JsonObject>().set(src);	22✔
388	}	12✔
389
390	static JsonObject fromJson(JsonVariant src) {	95✔
391	auto data = getData(src);	95✔
392	auto resources = getResourceManager(src);	95✔
393	return JsonObject(data != 0 ? data->asObject() : 0, resources);	190✔
394	}
395
396	static detail::InvalidConversion<JsonVariantConst, JsonObject> fromJson(
397	JsonVariantConst);
398
399	static bool checkJson(JsonVariantConst) {	9✔
400	return false;	9✔
401	}
402
403	static bool checkJson(JsonVariant src) {	47✔
404	auto data = getData(src);	47✔
405	return data && data->isObject();	47✔
406	}
407	};
408
409	ARDUINOJSON_END_PUBLIC_NAMESPACE

bblanchon / ArduinoJson / 6175307035

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