9401199389

Committed 06 Jun 2024 12:50PM CUT coverage: 99.563% (+0.2%) from 99.362%

Build # 9401199389

Build Type

push

github

Committed by

bblanchon

Commit Message

Rewrite fromJson

Run Details

15 of 15 new or added lines in 1 file covered. (100.0%)

3876 of 3893 relevant lines covered (99.56%)

10740.81 hits per line

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

98.81

/src/ArduinoJson/Variant/VariantCompare.hpp

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

#pragma once

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

ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE

struct ComparerBase : JsonVariantVisitor<CompareResult> {};

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

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

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

  CompareResult visit(JsonString lhs) {
    int i = stringCompare(adaptString(rhs), adaptString(lhs));
    if (i < 0)
      return COMPARE_RESULT_GREATER;
    else if (i > 0)
      return COMPARE_RESULT_LESS;
    else
      return COMPARE_RESULT_EQUAL;
  }

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

  using ComparerBase::visit;
};

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

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

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

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

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

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

  using ComparerBase::visit;
};

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

  using ComparerBase::visit;
};

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

struct ArrayComparer : ComparerBase {
  JsonArrayConst rhs_;

  explicit ArrayComparer(JsonArrayConst rhs) : rhs_(rhs) {}

  CompareResult visit(JsonArrayConst lhs) {
    if (rhs_ == lhs)
      return COMPARE_RESULT_EQUAL;
    else
      return COMPARE_RESULT_DIFFER;
  }

  using ComparerBase::visit;
};

struct ObjectComparer : ComparerBase {
  JsonObjectConst rhs_;

  explicit ObjectComparer(JsonObjectConst rhs) : rhs_(rhs) {}

  CompareResult visit(JsonObjectConst lhs) {
    if (lhs == rhs_)
      return COMPARE_RESULT_EQUAL;
    else
      return COMPARE_RESULT_DIFFER;
  }

  using ComparerBase::visit;
};

struct RawComparer : ComparerBase {
  RawString rhs_;

  explicit RawComparer(RawString rhs) : rhs_(rhs) {}

  CompareResult visit(RawString lhs) {
    size_t size = rhs_.size() < lhs.size() ? rhs_.size() : lhs.size();
    int n = memcmp(lhs.data(), rhs_.data(), size);
    if (n < 0)
      return COMPARE_RESULT_LESS;
    else if (n > 0)
      return COMPARE_RESULT_GREATER;
    else
      return COMPARE_RESULT_EQUAL;
  }

  using ComparerBase::visit;
};

struct VariantComparer : ComparerBase {
  JsonVariantConst rhs;

  explicit VariantComparer(JsonVariantConst value) : rhs(value) {}

  CompareResult visit(JsonArrayConst lhs) {
    ArrayComparer comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(JsonObjectConst lhs) {
    ObjectComparer comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(JsonFloat lhs) {
    Comparer<JsonFloat> comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(JsonString lhs) {
    Comparer<JsonString> comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(RawString value) {
    RawComparer comparer(value);
    return reverseResult(comparer);
  }

  CompareResult visit(JsonInteger lhs) {
    Comparer<JsonInteger> comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(JsonUInt lhs) {
    Comparer<JsonUInt> comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(bool lhs) {
    Comparer<bool> comparer(lhs);
    return reverseResult(comparer);
  }

  CompareResult visit(nullptr_t) {
    NullComparer comparer;
    return reverseResult(comparer);
  }

 private:
  template <typename TComparer>
  CompareResult reverseResult(TComparer& comparer) {
    CompareResult reversedResult = accept(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, enable_if_t<is_convertible<T, ArduinoJson::JsonVariantConst>::value>>
    : VariantComparer {
  explicit Comparer(const T& value)
      : VariantComparer(static_cast<JsonVariantConst>(value)) {}
};

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

ARDUINOJSON_END_PRIVATE_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2024, 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/Polyfills/utility.hpp>
11	#include <ArduinoJson/Strings/StringAdapters.hpp>
12	#include <ArduinoJson/Variant/JsonVariantVisitor.hpp>
13
14	ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
15
16	struct ComparerBase : JsonVariantVisitor<CompareResult> {};
17
18	template <typename T, typename Enable = void>
19	struct Comparer;
20
21	template <typename T>
22	struct Comparer<T, enable_if_t<IsString<T>::value>> : ComparerBase {
23	T rhs; // TODO: store adapted string?
24
25	explicit Comparer(T value) : rhs(value) {}	489✔
26
27	CompareResult visit(JsonString lhs) {	481✔
28	int i = stringCompare(adaptString(rhs), adaptString(lhs));	481✔
29	if (i < 0)	481✔
30	return COMPARE_RESULT_GREATER;	59✔
31	else if (i > 0)	422✔
32	return COMPARE_RESULT_LESS;	70✔
33	else
34	return COMPARE_RESULT_EQUAL;	352✔
35	}
36
37	CompareResult visit(nullptr_t) {	7✔
38	if (adaptString(rhs).isNull())	7✔
39	return COMPARE_RESULT_EQUAL;	7✔
40	else
41	return COMPARE_RESULT_DIFFER;	×
42	}
43
44	using ComparerBase::visit;
45	};
46
47	template <typename T>
48	struct Comparer<
49	T, enable_if_t<is_integral<T>::value \|\| is_floating_point<T>::value>>
50	: ComparerBase {
51	T rhs;
52
53	explicit Comparer(T value) : rhs(value) {}	2,687✔
54
55	CompareResult visit(JsonFloat lhs) {	22✔
56	return arithmeticCompare(lhs, rhs);	22✔
57	}
58
59	CompareResult visit(JsonInteger lhs) {	433✔
60	return arithmeticCompare(lhs, rhs);	433✔
61	}
62
63	CompareResult visit(JsonUInt lhs) {	538✔
64	return arithmeticCompare(lhs, rhs);	538✔
65	}
66
67	CompareResult visit(bool lhs) {	419✔
68	return visit(static_cast<JsonUInt>(lhs));	419✔
69	}
70
71	using ComparerBase::visit;
72	};
73
74	struct NullComparer : ComparerBase {
75	CompareResult visit(nullptr_t) {	14✔
76	return COMPARE_RESULT_EQUAL;	14✔
77	}
78
79	using ComparerBase::visit;
80	};
81
82	template <>
83	struct Comparer<nullptr_t, void> : NullComparer {
84	explicit Comparer(nullptr_t) : NullComparer() {}	7✔
85	};
86
87	struct ArrayComparer : ComparerBase {
88	JsonArrayConst rhs_;
89
90	explicit ArrayComparer(JsonArrayConst rhs) : rhs_(rhs) {}	268✔
91
92	CompareResult visit(JsonArrayConst lhs) {	244✔
93	if (rhs_ == lhs)	244✔
94	return COMPARE_RESULT_EQUAL;	188✔
95	else
96	return COMPARE_RESULT_DIFFER;	56✔
97	}
98
99	using ComparerBase::visit;
100	};
101
102	struct ObjectComparer : ComparerBase {
103	JsonObjectConst rhs_;
104
105	explicit ObjectComparer(JsonObjectConst rhs) : rhs_(rhs) {}	273✔
106
107	CompareResult visit(JsonObjectConst lhs) {	249✔
108	if (lhs == rhs_)	249✔
109	return COMPARE_RESULT_EQUAL;	191✔
110	else
111	return COMPARE_RESULT_DIFFER;	58✔
112	}
113
114	using ComparerBase::visit;
115	};
116
117	struct RawComparer : ComparerBase {
118	RawString rhs_;
119
120	explicit RawComparer(RawString rhs) : rhs_(rhs) {}	36✔
121
122	CompareResult visit(RawString lhs) {	36✔
123	size_t size = rhs_.size() < lhs.size() ? rhs_.size() : lhs.size();	36✔
124	int n = memcmp(lhs.data(), rhs_.data(), size);	36✔
125	if (n < 0)	36✔
126	return COMPARE_RESULT_LESS;	12✔
127	else if (n > 0)	24✔
128	return COMPARE_RESULT_GREATER;	12✔
129	else
130	return COMPARE_RESULT_EQUAL;	12✔
131	}
132
133	using ComparerBase::visit;
134	};
135
136	struct VariantComparer : ComparerBase {
137	JsonVariantConst rhs;
138
139	explicit VariantComparer(JsonVariantConst value) : rhs(value) {}	1,414✔
140
141	CompareResult visit(JsonArrayConst lhs) {	268✔
142	ArrayComparer comparer(lhs);	268✔
143	return reverseResult(comparer);	536✔
144	}
145
146	CompareResult visit(JsonObjectConst lhs) {	273✔
147	ObjectComparer comparer(lhs);	273✔
148	return reverseResult(comparer);	546✔
149	}
150
151	CompareResult visit(JsonFloat lhs) {	6✔
152	Comparer<JsonFloat> comparer(lhs);	6✔
153	return reverseResult(comparer);	12✔
154	}
155
156	CompareResult visit(JsonString lhs) {	317✔
157	Comparer<JsonString> comparer(lhs);	317✔
158	return reverseResult(comparer);	634✔
159	}
160
161	CompareResult visit(RawString value) {	36✔
162	RawComparer comparer(value);	36✔
163	return reverseResult(comparer);	72✔
164	}
165
166	CompareResult visit(JsonInteger lhs) {	379✔
167	Comparer<JsonInteger> comparer(lhs);	379✔
168	return reverseResult(comparer);	758✔
169	}
170
171	CompareResult visit(JsonUInt lhs) {	12✔
172	Comparer<JsonUInt> comparer(lhs);	12✔
173	return reverseResult(comparer);	24✔
174	}
175
176	CompareResult visit(bool lhs) {	66✔
177	Comparer<bool> comparer(lhs);	66✔
178	return reverseResult(comparer);	132✔
179	}
180
181	CompareResult visit(nullptr_t) {	57✔
182	NullComparer comparer;
183	return reverseResult(comparer);	114✔
184	}
185
186	private:
187	template <typename TComparer>
188	CompareResult reverseResult(TComparer& comparer) {	1,414✔
189	CompareResult reversedResult = accept(rhs, comparer);	1,414✔
190	switch (reversedResult) {	1,414✔
191	case COMPARE_RESULT_GREATER:	89✔
192	return COMPARE_RESULT_LESS;	89✔
193	case COMPARE_RESULT_LESS:	109✔
194	return COMPARE_RESULT_GREATER;	109✔
195	default:	1,216✔
196	return reversedResult;	1,216✔
197	}
198	}
199	};
200
201	template <typename T>
202	struct Comparer<
203	T, enable_if_t<is_convertible<T, ArduinoJson::JsonVariantConst>::value>>
204	: VariantComparer {
205	explicit Comparer(const T& value)	1,414✔
206	: VariantComparer(static_cast<JsonVariantConst>(value)) {}	1,414✔
207	};
208
209	template <typename T>
210	CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {	3,817✔
211	Comparer<T> comparer(rhs);	3,868✔
212	return accept(lhs, comparer);	7,634✔
213	}
214
215	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 9401199389

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