4017712708

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

Deduce template argument of `pgm_read()`

Run Details

15 of 15 new or added lines in 3 files covered. (100.0%)

3370 of 3386 relevant lines covered (99.53%)

6017.47 hits per line

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

98.82

/src/ArduinoJson/Variant/VariantCompare.hpp

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

#pragma once

#include <ArduinoJson/Configuration.hpp>
#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
#include <ArduinoJson/Polyfills/type_traits.hpp>
#include <ArduinoJson/Strings/StringAdapters.hpp>
#include <ArduinoJson/Variant/Visitor.hpp>

namespace ARDUINOJSON_NAMESPACE {

class CollectionData;

struct ComparerBase : Visitor<CompareResult> {};

template <typename T, typename Enable = void>
struct Comparer;

template <typename T>
struct Comparer<T, typename enable_if<IsString<T>::value>::type>
    : ComparerBase {
  T rhs;  // TODO: store adapted string?

  explicit Comparer(T value) : rhs(value) {}

  CompareResult visitString(const char* lhs, size_t n) {
    int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
    if (i < 0)
      return COMPARE_RESULT_GREATER;
    else if (i > 0)
      return COMPARE_RESULT_LESS;
    else
      return COMPARE_RESULT_EQUAL;
  }

  CompareResult visitNull() {
    if (adaptString(rhs).isNull())
      return COMPARE_RESULT_EQUAL;
    else
      return COMPARE_RESULT_DIFFER;
  }
};

template <typename T>
struct Comparer<T, typename enable_if<is_integral<T>::value ||
                                      is_floating_point<T>::value>::type>
    : ComparerBase {
  T rhs;

  explicit Comparer(T value) : rhs(value) {}

  CompareResult visitFloat(JsonFloat lhs) {
    return arithmeticCompare(lhs, rhs);
  }

  CompareResult visitSignedInteger(JsonInteger lhs) {
    return arithmeticCompare(lhs, rhs);
  }

  CompareResult visitUnsignedInteger(JsonUInt lhs) {
    return arithmeticCompare(lhs, rhs);
  }

  CompareResult visitBoolean(bool lhs) {
    return visitUnsignedInteger(static_cast<JsonUInt>(lhs));
  }
};

struct NullComparer : ComparerBase {
  CompareResult visitNull() {
    return COMPARE_RESULT_EQUAL;
  }
};

#if ARDUINOJSON_HAS_NULLPTR
template <>
struct Comparer<decltype(nullptr), void> : NullComparer {
  explicit Comparer(decltype(nullptr)) : NullComparer() {}
};
#endif

struct ArrayComparer : ComparerBase {
  const CollectionData* _rhs;

  explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}

  CompareResult visitArray(const CollectionData& lhs) {
    if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
      return COMPARE_RESULT_EQUAL;
    else
      return COMPARE_RESULT_DIFFER;
  }
};

struct ObjectComparer : ComparerBase {
  const CollectionData* _rhs;

  explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}

  CompareResult visitObject(const CollectionData& lhs) {
    if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
      return COMPARE_RESULT_EQUAL;
    else
      return COMPARE_RESULT_DIFFER;
  }
};

struct RawComparer : ComparerBase {
  const char* _rhsData;
  size_t _rhsSize;

  explicit RawComparer(const char* rhsData, size_t rhsSize)
      : _rhsData(rhsData), _rhsSize(rhsSize) {}

  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
    size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
    int n = memcmp(lhsData, _rhsData, size);
    if (n < 0)
      return COMPARE_RESULT_LESS;
    else if (n > 0)
      return COMPARE_RESULT_GREATER;
    else
      return COMPARE_RESULT_EQUAL;
  }
};

struct VariantComparer : ComparerBase {
  const VariantData* rhs;

  explicit VariantComparer(const VariantData* value) : rhs(value) {}

  CompareResult visitArray(const CollectionData& lhs) {
    ArrayComparer comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitObject(const CollectionData& lhs) {
    ObjectComparer comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitFloat(JsonFloat lhs) {
    Comparer<JsonFloat> comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitString(const char* lhs, size_t) {
    Comparer<const char*> comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {
    RawComparer comparer(lhsData, lhsSize);
    return accept(comparer);
  }

  CompareResult visitSignedInteger(JsonInteger lhs) {
    Comparer<JsonInteger> comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitUnsignedInteger(JsonUInt lhs) {
    Comparer<JsonUInt> comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitBoolean(bool lhs) {
    Comparer<bool> comparer(lhs);
    return accept(comparer);
  }

  CompareResult visitNull() {
    NullComparer comparer;
    return accept(comparer);
  }

 private:
  template <typename TComparer>
  CompareResult accept(TComparer& comparer) {
    CompareResult reversedResult = variantAccept(rhs, comparer);
    switch (reversedResult) {
      case COMPARE_RESULT_GREATER:
        return COMPARE_RESULT_LESS;
      case COMPARE_RESULT_LESS:
        return COMPARE_RESULT_GREATER;
      default:
        return reversedResult;
    }
  }
};

template <typename T>
struct Comparer<
    T, typename enable_if<is_convertible<T, JsonVariantConst>::value>::type>
    : VariantComparer {
  explicit Comparer(const T& value)
      : VariantComparer(VariantAttorney::getData(value)) {}
};

template <typename T>
CompareResult compare(JsonVariantConst lhs, const T& rhs) {
  Comparer<T> comparer(rhs);
  return variantAccept(VariantAttorney::getData(lhs), comparer);
}

}  // namespace ARDUINOJSON_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2022, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Configuration.hpp>
8	#include <ArduinoJson/Numbers/arithmeticCompare.hpp>
9	#include <ArduinoJson/Polyfills/type_traits.hpp>
10	#include <ArduinoJson/Strings/StringAdapters.hpp>
11	#include <ArduinoJson/Variant/Visitor.hpp>
12
13	namespace ARDUINOJSON_NAMESPACE {
14
15	class CollectionData;
16
17	struct ComparerBase : Visitor<CompareResult> {};
18
19	template <typename T, typename Enable = void>
20	struct Comparer;
21
22	template <typename T>
23	struct Comparer<T, typename enable_if<IsString<T>::value>::type>
24	: ComparerBase {
25	T rhs; // TODO: store adapted string?
26
27	explicit Comparer(T value) : rhs(value) {}	419✔
28
29	CompareResult visitString(const char* lhs, size_t n) {	412✔
30	int i = stringCompare(adaptString(rhs), adaptString(lhs, n));	412✔
31	if (i < 0)	412✔
32	return COMPARE_RESULT_GREATER;	36✔
33	else if (i > 0)	376✔
34	return COMPARE_RESULT_LESS;	93✔
35	else
36	return COMPARE_RESULT_EQUAL;	283✔
37	}
38
39	CompareResult visitNull() {	7✔
40	if (adaptString(rhs).isNull())	7✔
41	return COMPARE_RESULT_EQUAL;	7✔
42	else
43	return COMPARE_RESULT_DIFFER;	×
44	}
45	};
46
47	template <typename T>
48	struct Comparer<T, typename enable_if<is_integral<T>::value \|\|
49	is_floating_point<T>::value>::type>
50	: ComparerBase {
51	T rhs;
52
53	explicit Comparer(T value) : rhs(value) {}	2,644✔
54
55	CompareResult visitFloat(JsonFloat lhs) {	22✔
56	return arithmeticCompare(lhs, rhs);	22✔
57	}
58
59	CompareResult visitSignedInteger(JsonInteger lhs) {	376✔
60	return arithmeticCompare(lhs, rhs);	376✔
61	}
62
63	CompareResult visitUnsignedInteger(JsonUInt lhs) {	547✔
64	return arithmeticCompare(lhs, rhs);	547✔
65	}
66
67	CompareResult visitBoolean(bool lhs) {	425✔
68	return visitUnsignedInteger(static_cast<JsonUInt>(lhs));	425✔
69	}
70	};
71
72	struct NullComparer : ComparerBase {
73	CompareResult visitNull() {	16✔
74	return COMPARE_RESULT_EQUAL;	16✔
75	}
76	};
77
78	#if ARDUINOJSON_HAS_NULLPTR
79	template <>
80	struct Comparer<decltype(nullptr), void> : NullComparer {
81	explicit Comparer(decltype(nullptr)) : NullComparer() {}	4✔
82	};
83	#endif
84
85	struct ArrayComparer : ComparerBase {
86	const CollectionData* _rhs;
87
88	explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {}	256✔
89
90	CompareResult visitArray(const CollectionData& lhs) {	234✔
91	if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))	468✔
92	return COMPARE_RESULT_EQUAL;	182✔
93	else
94	return COMPARE_RESULT_DIFFER;	52✔
95	}
96	};
97
98	struct ObjectComparer : ComparerBase {
99	const CollectionData* _rhs;
100
101	explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {}	273✔
102
103	CompareResult visitObject(const CollectionData& lhs) {	250✔
104	if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))	500✔
105	return COMPARE_RESULT_EQUAL;	190✔
106	else
107	return COMPARE_RESULT_DIFFER;	60✔
108	}
109	};
110
111	struct RawComparer : ComparerBase {
112	const char* _rhsData;
113	size_t _rhsSize;
114
115	explicit RawComparer(const char* rhsData, size_t rhsSize)	18✔
116	: _rhsData(rhsData), _rhsSize(rhsSize) {}	18✔
117
118	CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {	18✔
119	size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;	18✔
120	int n = memcmp(lhsData, _rhsData, size);	18✔
121	if (n < 0)	18✔
122	return COMPARE_RESULT_LESS;	6✔
123	else if (n > 0)	12✔
124	return COMPARE_RESULT_GREATER;	6✔
125	else
126	return COMPARE_RESULT_EQUAL;	6✔
127	}
128	};
129
130	struct VariantComparer : ComparerBase {
131	const VariantData* rhs;
132
133	explicit VariantComparer(const VariantData* value) : rhs(value) {}	1,284✔
134
135	CompareResult visitArray(const CollectionData& lhs) {	256✔
136	ArrayComparer comparer(lhs);	256✔
137	return accept(comparer);	512✔
138	}
139
140	CompareResult visitObject(const CollectionData& lhs) {	273✔
141	ObjectComparer comparer(lhs);	273✔
142	return accept(comparer);	546✔
143	}
144
145	CompareResult visitFloat(JsonFloat lhs) {	6✔
146	Comparer<JsonFloat> comparer(lhs);	6✔
147	return accept(comparer);	12✔
148	}
149
150	CompareResult visitString(const char* lhs, size_t) {	262✔
151	Comparer<const char*> comparer(lhs);	262✔
152	return accept(comparer);	524✔
153	}
154
155	CompareResult visitRawJson(const char* lhsData, size_t lhsSize) {	18✔
156	RawComparer comparer(lhsData, lhsSize);	18✔
157	return accept(comparer);	36✔
158	}
159
160	CompareResult visitSignedInteger(JsonInteger lhs) {	320✔
161	Comparer<JsonInteger> comparer(lhs);	320✔
162	return accept(comparer);	640✔
163	}
164
165	CompareResult visitUnsignedInteger(JsonUInt lhs) {	12✔
166	Comparer<JsonUInt> comparer(lhs);	12✔
167	return accept(comparer);	24✔
168	}
169
170	CompareResult visitBoolean(bool lhs) {	66✔
171	Comparer<bool> comparer(lhs);	66✔
172	return accept(comparer);	132✔
173	}
174
175	CompareResult visitNull() {	71✔
176	NullComparer comparer;
177	return accept(comparer);	142✔
178	}
179
180	private:
181	template <typename TComparer>
182	CompareResult accept(TComparer& comparer) {	1,284✔
183	CompareResult reversedResult = variantAccept(rhs, comparer);	1,284✔
184	switch (reversedResult) {	1,284✔
185	case COMPARE_RESULT_GREATER:	54✔
186	return COMPARE_RESULT_LESS;	54✔
187	case COMPARE_RESULT_LESS:	132✔
188	return COMPARE_RESULT_GREATER;	132✔
189	default:	1,098✔
190	return reversedResult;	1,098✔
191	}
192	}
193	};
194
195	template <typename T>
196	struct Comparer<
197	T, typename enable_if<is_convertible<T, JsonVariantConst>::value>::type>
198	: VariantComparer {
199	explicit Comparer(const T& value)	1,284✔
200	: VariantComparer(VariantAttorney::getData(value)) {}	2,568✔
201	};
202
203	template <typename T>
204	CompareResult compare(JsonVariantConst lhs, const T& rhs) {	3,685✔
205	Comparer<T> comparer(rhs);	3,777✔
206	return variantAccept(VariantAttorney::getData(lhs), comparer);	7,370✔
207	}
208
209	} // namespace ARDUINOJSON_NAMESPACE

bblanchon / ArduinoJson / 4017712708

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