5059873495

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

Remove VariantImpl.hpp

Run Details

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

3280 of 3299 relevant lines covered (99.42%)

6312.26 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-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

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

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

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	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) {}
28
29	CompareResult visitString(const char* lhs, size_t n) {
30	int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
31	if (i < 0)
32	return COMPARE_RESULT_GREATER;
33	else if (i > 0)
34	return COMPARE_RESULT_LESS;
35	else
36	return COMPARE_RESULT_EQUAL;
37	}
38
39	CompareResult visitNull() {
40	if (adaptString(rhs).isNull())
41	return COMPARE_RESULT_EQUAL;
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) {}
54
55	CompareResult visitFloat(JsonFloat lhs) {
56	return arithmeticCompare(lhs, rhs);
57	}
58
59	CompareResult visitSignedInteger(JsonInteger lhs) {
60	return arithmeticCompare(lhs, rhs);
61	}
62
63	CompareResult visitUnsignedInteger(JsonUInt lhs) {
64	return arithmeticCompare(lhs, rhs);
65	}
66
67	CompareResult visitBoolean(bool lhs) {
68	return visitUnsignedInteger(static_cast<JsonUInt>(lhs));
69	}
70	};
71
72	struct NullComparer : ComparerBase {
73	CompareResult visitNull() {
74	return COMPARE_RESULT_EQUAL;
75	}
76	};
77
78	template <>
79	struct Comparer<decltype(nullptr), void> : NullComparer {
80	explicit Comparer(decltype(nullptr)) : NullComparer() {}
81	};
82
83	struct ArrayComparer : ComparerBase {
84	const CollectionData* rhs_;
85
86	explicit ArrayComparer(const CollectionData& rhs) : rhs_(&rhs) {}
87
88	CompareResult visitArray(const CollectionData& lhs) {
89	if (JsonArrayConst(&lhs) == JsonArrayConst(rhs_))
90	return COMPARE_RESULT_EQUAL;
91	else
92	return COMPARE_RESULT_DIFFER;
93	}
94	};
95
96	struct ObjectComparer : ComparerBase {
97	const CollectionData* rhs_;
98
99	explicit ObjectComparer(const CollectionData& rhs) : rhs_(&rhs) {}
100
101	CompareResult visitObject(const CollectionData& lhs) {
102	if (JsonObjectConst(&lhs) == JsonObjectConst(rhs_))
103	return COMPARE_RESULT_EQUAL;
104	else
105	return COMPARE_RESULT_DIFFER;
106	}
107	};
108
109	struct RawComparer : ComparerBase {
110	const char* rhsData_;
111	size_t rhsSize_;
112
113	explicit RawComparer(const char* rhsData, size_t rhsSize)
114	: rhsData_(rhsData), rhsSize_(rhsSize) {}
115
116	CompareResult visitRawString(const char* lhsData, size_t lhsSize) {
117	size_t size = rhsSize_ < lhsSize ? rhsSize_ : lhsSize;
118	int n = memcmp(lhsData, rhsData_, size);
119	if (n < 0)
120	return COMPARE_RESULT_LESS;
121	else if (n > 0)
122	return COMPARE_RESULT_GREATER;
123	else
124	return COMPARE_RESULT_EQUAL;
125	}
126	};
127
128	struct VariantComparer : ComparerBase {
129	const VariantData* rhs;
130
131	explicit VariantComparer(const VariantData* value) : rhs(value) {}
132
133	CompareResult visitArray(const CollectionData& lhs) {
134	ArrayComparer comparer(lhs);
135	return accept(comparer);
136	}
137
138	CompareResult visitObject(const CollectionData& lhs) {
139	ObjectComparer comparer(lhs);
140	return accept(comparer);
141	}
142
143	CompareResult visitFloat(JsonFloat lhs) {
144	Comparer<JsonFloat> comparer(lhs);
145	return accept(comparer);
146	}
147
148	CompareResult visitString(const char* lhs, size_t) {
149	Comparer<const char*> comparer(lhs);
150	return accept(comparer);
151	}
152
153	CompareResult visitRawString(const char* lhsData, size_t lhsSize) {
154	RawComparer comparer(lhsData, lhsSize);
155	return accept(comparer);
156	}
157
158	CompareResult visitSignedInteger(JsonInteger lhs) {
159	Comparer<JsonInteger> comparer(lhs);
160	return accept(comparer);
161	}
162
163	CompareResult visitUnsignedInteger(JsonUInt lhs) {
164	Comparer<JsonUInt> comparer(lhs);
165	return accept(comparer);
166	}
167
168	CompareResult visitBoolean(bool lhs) {
169	Comparer<bool> comparer(lhs);
170	return accept(comparer);
171	}
172
173	CompareResult visitNull() {
174	NullComparer comparer;
175	return accept(comparer);
176	}
177
178	private:
179	template <typename TComparer>
180	CompareResult accept(TComparer& comparer) {
181	CompareResult reversedResult = variantAccept(rhs, comparer);
182	switch (reversedResult) {
183	case COMPARE_RESULT_GREATER:
184	return COMPARE_RESULT_LESS;
185	case COMPARE_RESULT_LESS:
186	return COMPARE_RESULT_GREATER;
187	default:
188	return reversedResult;
189	}
190	}
191	};
192
193	template <typename T>
194	struct Comparer<T, typename enable_if<is_convertible<
195	T, ArduinoJson::JsonVariantConst>::value>::type>
196	: VariantComparer {
197	explicit Comparer(const T& value)
198	: VariantComparer(VariantAttorney::getData(value)) {}
199	};
200
201	template <typename T>
202	CompareResult compare(ArduinoJson::JsonVariantConst lhs, const T& rhs) {
203	Comparer<T> comparer(rhs);
204	return variantAccept(VariantAttorney::getData(lhs), comparer);
205	}
206
207	ARDUINOJSON_END_PRIVATE_NAMESPACE

bblanchon / ArduinoJson / 5059873495

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