6770901880

Committed 06 Nov 2023 12:24PM CUT coverage: 99.545%. Remained the same

Build # 6770901880

Build Type

push

github

Committed by

bblanchon

Commit Message

CI: always use libc++ with clang

Run Details

3497 of 3513 relevant lines covered (99.54%)

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

bblanchon / ArduinoJson / 6770901880

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