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

97.33

/src/ArduinoJson/Variant/VariantImpl.hpp

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

#pragma once

#include <ArduinoJson/Array/JsonArray.hpp>
#include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Numbers/convertNumber.hpp>
#include <ArduinoJson/Numbers/parseNumber.hpp>
#include <ArduinoJson/Object/JsonObject.hpp>
#include <ArduinoJson/Variant/JsonVariant.hpp>

#include <string.h>  // for strcmp

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

template <typename T>
inline T VariantData::asIntegral() const {
  switch (type()) {
    case VALUE_IS_BOOLEAN:
      return content_.asBoolean;
    case VALUE_IS_UNSIGNED_INTEGER:
      return convertNumber<T>(content_.asUnsignedInteger);
    case VALUE_IS_SIGNED_INTEGER:
      return convertNumber<T>(content_.asSignedInteger);
    case VALUE_IS_LINKED_STRING:
      return parseNumber<T>(content_.asLinkedString);
    case VALUE_IS_OWNED_STRING:
      return parseNumber<T>(content_.asOwnedString->data);
    case VALUE_IS_FLOAT:
      return convertNumber<T>(content_.asFloat);
    default:
      return 0;
  }
}

inline bool VariantData::asBoolean() const {
  switch (type()) {
    case VALUE_IS_BOOLEAN:
      return content_.asBoolean;
    case VALUE_IS_SIGNED_INTEGER:
    case VALUE_IS_UNSIGNED_INTEGER:
      return content_.asUnsignedInteger != 0;
    case VALUE_IS_FLOAT:
      return content_.asFloat != 0;
    case VALUE_IS_NULL:
      return false;
    default:
      return true;
  }
}

// T = float/double
template <typename T>
inline T VariantData::asFloat() const {
  switch (type()) {
    case VALUE_IS_BOOLEAN:
      return static_cast<T>(content_.asBoolean);
    case VALUE_IS_UNSIGNED_INTEGER:
      return static_cast<T>(content_.asUnsignedInteger);
    case VALUE_IS_SIGNED_INTEGER:
      return static_cast<T>(content_.asSignedInteger);
    case VALUE_IS_LINKED_STRING:
    case VALUE_IS_OWNED_STRING:
      return parseNumber<T>(content_.asOwnedString->data);
    case VALUE_IS_FLOAT:
      return static_cast<T>(content_.asFloat);
    default:
      return 0;
  }
}

inline JsonString VariantData::asString() const {
  switch (type()) {
    case VALUE_IS_LINKED_STRING:
      return JsonString(content_.asLinkedString, JsonString::Linked);
    case VALUE_IS_OWNED_STRING:
      return JsonString(content_.asOwnedString->data,
                        content_.asOwnedString->length, JsonString::Copied);
    default:
      return JsonString();
  }
}

inline JsonString VariantData::asRawString() const {
  switch (type()) {
    case VALUE_IS_RAW_STRING:
      return JsonString(content_.asOwnedString->data,
                        content_.asOwnedString->length, JsonString::Copied);
    default:
      return JsonString();
  }
}

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

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

template <typename TDerived>
inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
  return JsonVariant(getPool(), getOrCreateData());
}

template <typename TDerived>
template <typename T>
inline typename enable_if<is_same<T, JsonArray>::value, JsonArray>::type
VariantRefBase<TDerived>::to() const {
  return JsonArray(getPool(), variantToArray(getOrCreateData(), getPool()));
}

template <typename TDerived>
template <typename T>
typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type
VariantRefBase<TDerived>::to() const {
  return JsonObject(getPool(), variantToObject(getOrCreateData(), getPool()));
}

template <typename TDerived>
template <typename T>
typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
VariantRefBase<TDerived>::to() const {
  variantSetNull(getOrCreateData(), getPool());
  return *this;
}

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

inline void VariantSlot::setKey(StringNode* k) {
  ARDUINOJSON_ASSERT(k);
  flags_ |= OWNED_KEY_BIT;
  key_ = k->data;
}

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/Array/JsonArray.hpp>
8	#include <ArduinoJson/Configuration.hpp>
9	#include <ArduinoJson/Numbers/convertNumber.hpp>
10	#include <ArduinoJson/Numbers/parseNumber.hpp>
11	#include <ArduinoJson/Object/JsonObject.hpp>
12	#include <ArduinoJson/Variant/JsonVariant.hpp>
13
14	#include <string.h> // for strcmp
15
16	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
17
18	template <typename T>
19	inline T VariantData::asIntegral() const {	210✔
20	switch (type()) {	210✔
21	case VALUE_IS_BOOLEAN:	2✔
22	return content_.asBoolean;	2✔
23	case VALUE_IS_UNSIGNED_INTEGER:	87✔
24	return convertNumber<T>(content_.asUnsignedInteger);	87✔
25	case VALUE_IS_SIGNED_INTEGER:	84✔
26	return convertNumber<T>(content_.asSignedInteger);	84✔
27	case VALUE_IS_LINKED_STRING:	6✔
28	return parseNumber<T>(content_.asLinkedString);	6✔
29	case VALUE_IS_OWNED_STRING:	2✔
30	return parseNumber<T>(content_.asOwnedString->data);	2✔
31	case VALUE_IS_FLOAT:	19✔
32	return convertNumber<T>(content_.asFloat);	19✔
33	default:	10✔
34	return 0;	10✔
35	}
36	}
37
38	inline bool VariantData::asBoolean() const {	554✔
39	switch (type()) {	554✔
40	case VALUE_IS_BOOLEAN:	307✔
41	return content_.asBoolean;	307✔
42	case VALUE_IS_SIGNED_INTEGER:	7✔
43	case VALUE_IS_UNSIGNED_INTEGER:
44	return content_.asUnsignedInteger != 0;	7✔
45	case VALUE_IS_FLOAT:	5✔
46	return content_.asFloat != 0;	5✔
47	case VALUE_IS_NULL:	6✔
48	return false;	6✔
49	default:	229✔
50	return true;	229✔
51	}
52	}
53
54	// T = float/double
55	template <typename T>
56	inline T VariantData::asFloat() const {	117✔
57	switch (type()) {	117✔
58	case VALUE_IS_BOOLEAN:	2✔
59	return static_cast<T>(content_.asBoolean);	2✔
60	case VALUE_IS_UNSIGNED_INTEGER:	3✔
61	return static_cast<T>(content_.asUnsignedInteger);	3✔
62	case VALUE_IS_SIGNED_INTEGER:	6✔
63	return static_cast<T>(content_.asSignedInteger);	6✔
64	case VALUE_IS_LINKED_STRING:	1✔
65	case VALUE_IS_OWNED_STRING:
66	return parseNumber<T>(content_.asOwnedString->data);	1✔
67	case VALUE_IS_FLOAT:	103✔
68	return static_cast<T>(content_.asFloat);	103✔
69	default:	2✔
70	return 0;	2✔
71	}
72	}
73
74	inline JsonString VariantData::asString() const {	444✔
75	switch (type()) {	444✔
76	case VALUE_IS_LINKED_STRING:	30✔
77	return JsonString(content_.asLinkedString, JsonString::Linked);	30✔
78	case VALUE_IS_OWNED_STRING:	76✔
79	return JsonString(content_.asOwnedString->data,	76✔
80	content_.asOwnedString->length, JsonString::Copied);	76✔
81	default:	338✔
82	return JsonString();	338✔
83	}
84	}
85
86	inline JsonString VariantData::asRawString() const {	4✔
87	switch (type()) {	4✔
88	case VALUE_IS_RAW_STRING:	4✔
89	return JsonString(content_.asOwnedString->data,	4✔
90	content_.asOwnedString->length, JsonString::Copied);	4✔
91	default:	×
92	return JsonString();	×
93	}
94	}
95
96	template <typename TDerived>
97	inline JsonVariant VariantRefBase<TDerived>::add() const {
98	return JsonVariant(getPool(),
99	variantAddElement(getOrCreateData(), getPool()));	234✔
100	}
101
102	template <typename TDerived>
103	inline JsonVariant VariantRefBase<TDerived>::getVariant() const {
104	return JsonVariant(getPool(), getData());	1,368✔
105	}
106
107	template <typename TDerived>
108	inline JsonVariant VariantRefBase<TDerived>::getOrCreateVariant() const {
109	return JsonVariant(getPool(), getOrCreateData());	133,948✔
110	}
111
112	template <typename TDerived>
113	template <typename T>
114	inline typename enable_if<is_same<T, JsonArray>::value, JsonArray>::type
115	VariantRefBase<TDerived>::to() const {	222✔
116	return JsonArray(getPool(), variantToArray(getOrCreateData(), getPool()));	666✔
117	}
118
119	template <typename TDerived>
120	template <typename T>
121	typename enable_if<is_same<T, JsonObject>::value, JsonObject>::type
122	VariantRefBase<TDerived>::to() const {	273✔
123	return JsonObject(getPool(), variantToObject(getOrCreateData(), getPool()));	819✔
124	}
125
126	template <typename TDerived>
127	template <typename T>
128	typename enable_if<is_same<T, JsonVariant>::value, JsonVariant>::type
129	VariantRefBase<TDerived>::to() const {	399✔
130	variantSetNull(getOrCreateData(), getPool());	798✔
131	return *this;	399✔
132	}
133
134	template <typename TDerived>
135	inline void convertToJson(const VariantRefBase<TDerived>& src,	8✔
136	JsonVariant dst) {
137	dst.set(src.template as<JsonVariantConst>());	8✔
138	}	8✔
139
140	inline void VariantSlot::setKey(StringNode* k) {	1,390✔
141	ARDUINOJSON_ASSERT(k);
142	flags_ \|= OWNED_KEY_BIT;	1,390✔
143	key_ = k->data;	1,390✔
144	}	1,390✔
145
146	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