10680315983

Committed 03 Sep 2024 09:30AM CUT coverage: 99.497%. First build

Build # 10680315983

Build Type

push

github

Committed by

bblanchon

Commit Message

Fu

Run Details

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

3957 of 3977 relevant lines covered (99.5%)

10631.34 hits per line

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

98.75

/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) {}

  template <typename U>
  enable_if_t<is_floating_point<U>::value || is_integral<U>::value,
              CompareResult>
  visit(const U& lhs) {
    return arithmeticCompare(lhs, rhs);
  }

  template <typename U>
  enable_if_t<!is_floating_point<U>::value && !is_integral<U>::value,
              CompareResult>
  visit(const U& lhs) {
    return ComparerBase::visit(lhs);
  }
};

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	template <typename U>
56	enable_if_t<is_floating_point<U>::value \|\| is_integral<U>::value,
57	CompareResult>
58	visit(const U& lhs) {	993✔
59	return arithmeticCompare(lhs, rhs);	993✔
60	}
61
62	template <typename U>
63	enable_if_t<!is_floating_point<U>::value && !is_integral<U>::value,
64	CompareResult>
65	visit(const U& lhs) {	1,694✔
66	return ComparerBase::visit(lhs);	1,694✔
67	}
68	};
69
70	struct NullComparer : ComparerBase {
71	CompareResult visit(nullptr_t) {	14✔
72	return COMPARE_RESULT_EQUAL;	14✔
73	}
74
75	using ComparerBase::visit;
76	};
77
78	template <>
79	struct Comparer<nullptr_t, void> : NullComparer {
80	explicit Comparer(nullptr_t) : NullComparer() {}	7✔
81	};
82
83	struct ArrayComparer : ComparerBase {
84	JsonArrayConst rhs_;
85
86	explicit ArrayComparer(JsonArrayConst rhs) : rhs_(rhs) {}	268✔
87
88	CompareResult visit(JsonArrayConst lhs) {	244✔
89	if (rhs_ == lhs)	244✔
90	return COMPARE_RESULT_EQUAL;	188✔
91	else
92	return COMPARE_RESULT_DIFFER;	56✔
93	}
94
95	using ComparerBase::visit;
96	};
97
98	struct ObjectComparer : ComparerBase {
99	JsonObjectConst rhs_;
100
101	explicit ObjectComparer(JsonObjectConst rhs) : rhs_(rhs) {}	273✔
102
103	CompareResult visit(JsonObjectConst lhs) {	249✔
104	if (lhs == rhs_)	249✔
105	return COMPARE_RESULT_EQUAL;	191✔
106	else
107	return COMPARE_RESULT_DIFFER;	58✔
108	}
109
110	using ComparerBase::visit;
111	};
112
113	struct RawComparer : ComparerBase {
114	RawString rhs_;
115
116	explicit RawComparer(RawString rhs) : rhs_(rhs) {}	36✔
117
118	CompareResult visit(RawString lhs) {	36✔
119	size_t size = rhs_.size() < lhs.size() ? rhs_.size() : lhs.size();	36✔
120	int n = memcmp(lhs.data(), rhs_.data(), size);	36✔
121	if (n < 0)	36✔
122	return COMPARE_RESULT_LESS;	12✔
123	else if (n > 0)	24✔
124	return COMPARE_RESULT_GREATER;	12✔
125	else
126	return COMPARE_RESULT_EQUAL;	12✔
127	}
128
129	using ComparerBase::visit;
130	};
131
132	struct VariantComparer : ComparerBase {
133	JsonVariantConst rhs;
134
135	explicit VariantComparer(JsonVariantConst value) : rhs(value) {}	1,414✔
136
137	CompareResult visit(JsonArrayConst lhs) {	268✔
138	ArrayComparer comparer(lhs);	268✔
139	return reverseResult(comparer);	536✔
140	}
141
142	CompareResult visit(JsonObjectConst lhs) {	273✔
143	ObjectComparer comparer(lhs);	273✔
144	return reverseResult(comparer);	546✔
145	}
146
147	CompareResult visit(JsonFloat lhs) {	6✔
148	Comparer<JsonFloat> comparer(lhs);	6✔
149	return reverseResult(comparer);	12✔
150	}
151
152	CompareResult visit(JsonString lhs) {	317✔
153	Comparer<JsonString> comparer(lhs);	317✔
154	return reverseResult(comparer);	634✔
155	}
156
157	CompareResult visit(RawString value) {	36✔
158	RawComparer comparer(value);	36✔
159	return reverseResult(comparer);	72✔
160	}
161
162	CompareResult visit(JsonInteger lhs) {	379✔
163	Comparer<JsonInteger> comparer(lhs);	379✔
164	return reverseResult(comparer);	758✔
165	}
166
167	CompareResult visit(JsonUInt lhs) {	12✔
168	Comparer<JsonUInt> comparer(lhs);	12✔
169	return reverseResult(comparer);	24✔
170	}
171
172	CompareResult visit(bool lhs) {	66✔
173	Comparer<bool> comparer(lhs);	66✔
174	return reverseResult(comparer);	132✔
175	}
176
177	CompareResult visit(nullptr_t) {	57✔
178	NullComparer comparer;
179	return reverseResult(comparer);	114✔
180	}
181
182	private:
183	template <typename TComparer>
184	CompareResult reverseResult(TComparer& comparer) {	1,414✔
185	CompareResult reversedResult = accept(rhs, comparer);	1,414✔
186	switch (reversedResult) {	1,414✔
187	case COMPARE_RESULT_GREATER:	89✔
188	return COMPARE_RESULT_LESS;	89✔
189	case COMPARE_RESULT_LESS:	109✔
190	return COMPARE_RESULT_GREATER;	109✔
191	default:	1,216✔
192	return reversedResult;	1,216✔
193	}
194	}
195	};
196
197	template <typename T>
198	struct Comparer<
199	T, enable_if_t<is_convertible<T, ArduinoJson::JsonVariantConst>::value>>
200	: VariantComparer {
201	explicit Comparer(const T& value)	1,414✔
202	: VariantComparer(static_cast<JsonVariantConst>(value)) {}	1,414✔
203	};
204
205	template <typename T>
206	CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {	3,817✔
207	Comparer<T> comparer(rhs);	3,868✔
208	return accept(lhs, comparer);	7,634✔
209	}
210
211	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 10680315983

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