5313785987

pending completion

Build # 5313785987

Build Type

push

github

Committed by

bblanchon

Commit Message

Extract `arrayEquals()` and `objectEquals()`

Run Details

28 of 28 new or added lines in 4 files covered. (100.0%)

3362 of 3383 relevant lines covered (99.38%)

6246.1 hits per line

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

98.86

/src/ArduinoJson/Variant/VariantCompare.hpp

// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, 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>

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

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;
  }
};

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

struct ArrayComparer : ComparerBase {
  const CollectionData* rhs_;

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

  CompareResult visitArray(const CollectionData& lhs) {
    if (arrayEquals(lhs, *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 (objectEquals(lhs, *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 visitRawString(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 visitRawString(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, ArduinoJson::JsonVariantConst>::value>::type>
    : VariantComparer {
  explicit Comparer(const T& value)
      : VariantComparer(VariantAttorney::getData(value)) {}
};

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

inline CompareResult compare(const VariantData* lhs, const VariantData* rhs) {
  VariantComparer comparer(rhs);
  return variantAccept(lhs, comparer);
}

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/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	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
14
15	struct ComparerBase : Visitor<CompareResult> {};
16
17	template <typename T, typename Enable = void>
18	struct Comparer;
19
20	template <typename T>
21	struct Comparer<T, typename enable_if<IsString<T>::value>::type>
22	: ComparerBase {
23	T rhs; // TODO: store adapted string?
24
25	explicit Comparer(T value) : rhs(value) {}	530✔
26
27	CompareResult visitString(const char* lhs, size_t n) {	521✔
28	int i = stringCompare(adaptString(rhs), adaptString(lhs, n));	521✔
29	if (i < 0)	521✔
30	return COMPARE_RESULT_GREATER;	84✔
31	else if (i > 0)	437✔
32	return COMPARE_RESULT_LESS;	45✔
33	else
34	return COMPARE_RESULT_EQUAL;	392✔
35	}
36
37	CompareResult visitNull() {	7✔
38	if (adaptString(rhs).isNull())	7✔
39	return COMPARE_RESULT_EQUAL;	7✔
40	else
41	return COMPARE_RESULT_DIFFER;	×
42	}
43	};
44
45	template <typename T>
46	struct Comparer<T, typename enable_if<is_integral<T>::value \|\|
47	is_floating_point<T>::value>::type>
48	: ComparerBase {
49	T rhs;
50
51	explicit Comparer(T value) : rhs(value) {}	2,758✔
52
53	CompareResult visitFloat(JsonFloat lhs) {	22✔
54	return arithmeticCompare(lhs, rhs);	22✔
55	}
56
57	CompareResult visitSignedInteger(JsonInteger lhs) {	492✔
58	return arithmeticCompare(lhs, rhs);	492✔
59	}
60
61	CompareResult visitUnsignedInteger(JsonUInt lhs) {	547✔
62	return arithmeticCompare(lhs, rhs);	547✔
63	}
64
65	CompareResult visitBoolean(bool lhs) {	425✔
66	return visitUnsignedInteger(static_cast<JsonUInt>(lhs));	425✔
67	}
68	};
69
70	struct NullComparer : ComparerBase {
71	CompareResult visitNull() {	10✔
72	return COMPARE_RESULT_EQUAL;	10✔
73	}
74	};
75
76	template <>
77	struct Comparer<decltype(nullptr), void> : NullComparer {
78	explicit Comparer(decltype(nullptr)) : NullComparer() {}	4✔
79	};
80
81	struct ArrayComparer : ComparerBase {
82	const CollectionData* rhs_;
83
84	explicit ArrayComparer(const CollectionData& rhs) : rhs_(&rhs) {}	256✔
85
86	CompareResult visitArray(const CollectionData& lhs) {	234✔
87	if (arrayEquals(lhs, *rhs_))	234✔
88	return COMPARE_RESULT_EQUAL;	182✔
89	else
90	return COMPARE_RESULT_DIFFER;	52✔
91	}
92	};
93
94	struct ObjectComparer : ComparerBase {
95	const CollectionData* rhs_;
96
97	explicit ObjectComparer(const CollectionData& rhs) : rhs_(&rhs) {}	261✔
98
99	CompareResult visitObject(const CollectionData& lhs) {	238✔
100	if (objectEquals(lhs, *rhs_))	238✔
101	return COMPARE_RESULT_EQUAL;	184✔
102	else
103	return COMPARE_RESULT_DIFFER;	54✔
104	}
105	};
106
107	struct RawComparer : ComparerBase {
108	const char* rhsData_;
109	size_t rhsSize_;
110
111	explicit RawComparer(const char* rhsData, size_t rhsSize)	18✔
112	: rhsData_(rhsData), rhsSize_(rhsSize) {}	18✔
113
114	CompareResult visitRawString(const char* lhsData, size_t lhsSize) {	18✔
115	size_t size = rhsSize_ < lhsSize ? rhsSize_ : lhsSize;	18✔
116	int n = memcmp(lhsData, rhsData_, size);	18✔
117	if (n < 0)	18✔
118	return COMPARE_RESULT_LESS;	6✔
119	else if (n > 0)	12✔
120	return COMPARE_RESULT_GREATER;	6✔
121	else
122	return COMPARE_RESULT_EQUAL;	6✔
123	}
124	};
125
126	struct VariantComparer : ComparerBase {
127	const VariantData* rhs;
128
129	explicit VariantComparer(const VariantData* value) : rhs(value) {}	1,480✔
130
131	CompareResult visitArray(const CollectionData& lhs) {	256✔
132	ArrayComparer comparer(lhs);	256✔
133	return accept(comparer);	512✔
134	}
135
136	CompareResult visitObject(const CollectionData& lhs) {	261✔
137	ObjectComparer comparer(lhs);	261✔
138	return accept(comparer);	522✔
139	}
140
141	CompareResult visitFloat(JsonFloat lhs) {	6✔
142	Comparer<JsonFloat> comparer(lhs);	6✔
143	return accept(comparer);	12✔
144	}
145
146	CompareResult visitString(const char* lhs, size_t) {	374✔
147	Comparer<const char*> comparer(lhs);	374✔
148	return accept(comparer);	748✔
149	}
150
151	CompareResult visitRawString(const char* lhsData, size_t lhsSize) {	18✔
152	RawComparer comparer(lhsData, lhsSize);	18✔
153	return accept(comparer);	36✔
154	}
155
156	CompareResult visitSignedInteger(JsonInteger lhs) {	434✔
157	Comparer<JsonInteger> comparer(lhs);	434✔
158	return accept(comparer);	868✔
159	}
160
161	CompareResult visitUnsignedInteger(JsonUInt lhs) {	12✔
162	Comparer<JsonUInt> comparer(lhs);	12✔
163	return accept(comparer);	24✔
164	}
165
166	CompareResult visitBoolean(bool lhs) {	66✔
167	Comparer<bool> comparer(lhs);	66✔
168	return accept(comparer);	132✔
169	}
170
171	CompareResult visitNull() {	53✔
172	NullComparer comparer;
173	return accept(comparer);	106✔
174	}
175
176	private:
177	template <typename TComparer>
178	CompareResult accept(TComparer& comparer) {	1,480✔
179	CompareResult reversedResult = variantAccept(rhs, comparer);	1,480✔
180	switch (reversedResult) {	1,480✔
181	case COMPARE_RESULT_GREATER:	114✔
182	return COMPARE_RESULT_LESS;	114✔
183	case COMPARE_RESULT_LESS:	72✔
184	return COMPARE_RESULT_GREATER;	72✔
185	default:	1,294✔
186	return reversedResult;	1,294✔
187	}
188	}
189	};
190
191	template <typename T>
192	struct Comparer<T, typename enable_if<is_convertible<
193	T, ArduinoJson::JsonVariantConst>::value>::type>
194	: VariantComparer {
195	explicit Comparer(const T& value)	594✔
196	: VariantComparer(VariantAttorney::getData(value)) {}	1,188✔
197	};
198
199	template <typename T>
200	CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {	2,994✔
201	Comparer<T> comparer(rhs);	3,086✔
202	return variantAccept(VariantAttorney::getData(lhs), comparer);	5,988✔
203	}
204
205	inline CompareResult compare(const VariantData* lhs, const VariantData* rhs) {	886✔
206	VariantComparer comparer(rhs);	886✔
207	return variantAccept(lhs, comparer);	1,772✔
208	}
209
210	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 5313785987

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