andry/EMS-ESP32
1
0
Fork 0
mirror of https://github.com/emsesp/EMS-ESP32.git synced 2025-12-06 15:59:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

remove TODO

Browse Source
This commit is contained in:
proddy
2023-03-05 14:32:27 +01:00
parent 50d489d3c1
commit ef602ca70b
1 changed files with 149 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
lib/ArduinoJson/src/ArduinoJson/Variant/VariantCompare.hpp
View File

@@ -20,190 +20,200 @@ template <typename T, typename Enable = void>
struct Comparer; struct Comparer;
template <typename T> template <typename T>
struct Comparer<T, typename enable_if<IsString<T>::value>::type> struct Comparer<T, typename enable_if<IsString<T>::value>::type> : ComparerBase {
: ComparerBase { T rhs;
T rhs; // TODO: store adapted string?
explicit Comparer(T value) : rhs(value) {} explicit Comparer(T value)
: rhs(value) {
}
CompareResult visitString(const char* lhs, size_t n) { CompareResult visitString(const char * lhs, size_t n) {
int i = stringCompare(adaptString(rhs), adaptString(lhs, n)); int i = stringCompare(adaptString(rhs), adaptString(lhs, n));
if (i < 0) if (i < 0)
return COMPARE_RESULT_GREATER; return COMPARE_RESULT_GREATER;
else if (i > 0) else if (i > 0)
return COMPARE_RESULT_LESS; return COMPARE_RESULT_LESS;
else else
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
} }
CompareResult visitNull() { CompareResult visitNull() {
if (adaptString(rhs).isNull()) if (adaptString(rhs).isNull())
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
else else
return COMPARE_RESULT_DIFFER; return COMPARE_RESULT_DIFFER;
} }
}; };
template <typename T> template <typename T>
struct Comparer<T, typename enable_if<is_integral<T>::value || struct Comparer<T, typename enable_if<is_integral<T>::value || is_floating_point<T>::value>::type> : ComparerBase {
is_floating_point<T>::value>::type> T rhs;
: ComparerBase {
T rhs;
explicit Comparer(T value) : rhs(value) {} explicit Comparer(T value)
: rhs(value) {
}
CompareResult visitFloat(JsonFloat lhs) { CompareResult visitFloat(JsonFloat lhs) {
return arithmeticCompare(lhs, rhs); return arithmeticCompare(lhs, rhs);
} }
CompareResult visitSignedInteger(JsonInteger lhs) { CompareResult visitSignedInteger(JsonInteger lhs) {
return arithmeticCompare(lhs, rhs); return arithmeticCompare(lhs, rhs);
} }
CompareResult visitUnsignedInteger(JsonUInt lhs) { CompareResult visitUnsignedInteger(JsonUInt lhs) {
return arithmeticCompare(lhs, rhs); return arithmeticCompare(lhs, rhs);
} }
CompareResult visitBoolean(bool lhs) { CompareResult visitBoolean(bool lhs) {
return visitUnsignedInteger(static_cast<JsonUInt>(lhs)); return visitUnsignedInteger(static_cast<JsonUInt>(lhs));
} }
}; };
struct NullComparer : ComparerBase { struct NullComparer : ComparerBase {
CompareResult visitNull() { CompareResult visitNull() {
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
} }
}; };
#if ARDUINOJSON_HAS_NULLPTR #if ARDUINOJSON_HAS_NULLPTR
template <> template <>
struct Comparer<decltype(nullptr), void> : NullComparer { struct Comparer<decltype(nullptr), void> : NullComparer {
explicit Comparer(decltype(nullptr)) : NullComparer() {} explicit Comparer(decltype(nullptr))
: NullComparer() {
}
}; };
#endif #endif
struct ArrayComparer : ComparerBase { struct ArrayComparer : ComparerBase {
const CollectionData* _rhs; const CollectionData * _rhs;
explicit ArrayComparer(const CollectionData& rhs) : _rhs(&rhs) {} explicit ArrayComparer(const CollectionData & rhs)
: _rhs(&rhs) {
}
CompareResult visitArray(const CollectionData& lhs) { CompareResult visitArray(const CollectionData & lhs) {
if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs)) if (JsonArrayConst(&lhs) == JsonArrayConst(_rhs))
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
else else
return COMPARE_RESULT_DIFFER; return COMPARE_RESULT_DIFFER;
} }
}; };
struct ObjectComparer : ComparerBase { struct ObjectComparer : ComparerBase {
const CollectionData* _rhs; const CollectionData * _rhs;
explicit ObjectComparer(const CollectionData& rhs) : _rhs(&rhs) {} explicit ObjectComparer(const CollectionData & rhs)
: _rhs(&rhs) {
}
CompareResult visitObject(const CollectionData& lhs) { CompareResult visitObject(const CollectionData & lhs) {
if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs)) if (JsonObjectConst(&lhs) == JsonObjectConst(_rhs))
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
else else
return COMPARE_RESULT_DIFFER; return COMPARE_RESULT_DIFFER;
} }
}; };
struct RawComparer : ComparerBase { struct RawComparer : ComparerBase {
const char* _rhsData; const char * _rhsData;
size_t _rhsSize; size_t _rhsSize;
explicit RawComparer(const char* rhsData, size_t rhsSize) explicit RawComparer(const char * rhsData, size_t rhsSize)
: _rhsData(rhsData), _rhsSize(rhsSize) {} : _rhsData(rhsData)
, _rhsSize(rhsSize) {
}
CompareResult visitRawJson(const char* lhsData, size_t lhsSize) { CompareResult visitRawJson(const char * lhsData, size_t lhsSize) {
size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize; size_t size = _rhsSize < lhsSize ? _rhsSize : lhsSize;
int n = memcmp(lhsData, _rhsData, size); int n = memcmp(lhsData, _rhsData, size);
if (n < 0) if (n < 0)
return COMPARE_RESULT_LESS; return COMPARE_RESULT_LESS;
else if (n > 0) else if (n > 0)
return COMPARE_RESULT_GREATER; return COMPARE_RESULT_GREATER;
else else
return COMPARE_RESULT_EQUAL; return COMPARE_RESULT_EQUAL;
} }
}; };
struct VariantComparer : ComparerBase { struct VariantComparer : ComparerBase {
const VariantData* rhs; const VariantData * rhs;
explicit VariantComparer(const VariantData* value) : rhs(value) {} explicit VariantComparer(const VariantData * value)
: rhs(value) {
CompareResult visitArray(const CollectionData& lhs) { }
ArrayComparer comparer(lhs);
return accept(comparer); CompareResult visitArray(const CollectionData & lhs) {
} ArrayComparer comparer(lhs);
return accept(comparer);
CompareResult visitObject(const CollectionData& lhs) { }
ObjectComparer 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 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 visitString(const char * lhs, size_t) {
} Comparer<const char *> comparer(lhs);
return accept(comparer);
CompareResult visitRawJson(const char* lhsData, size_t lhsSize) { }
RawComparer comparer(lhsData, lhsSize);
return accept(comparer); CompareResult visitRawJson(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 visitSignedInteger(JsonInteger lhs) {
} Comparer<JsonInteger> comparer(lhs);
return accept(comparer);
CompareResult visitUnsignedInteger(JsonUInt lhs) { }
Comparer<JsonUInt> 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 visitBoolean(bool lhs) {
} Comparer<bool> comparer(lhs);
return accept(comparer);
CompareResult visitNull() { }
NullComparer comparer;
return accept(comparer); CompareResult visitNull() {
} NullComparer comparer;
return accept(comparer);
private: }
template <typename TComparer>
CompareResult accept(TComparer& comparer) { private:
CompareResult reversedResult = variantAccept(rhs, comparer); template <typename TComparer>
switch (reversedResult) { CompareResult accept(TComparer & comparer) {
case COMPARE_RESULT_GREATER: CompareResult reversedResult = variantAccept(rhs, comparer);
return COMPARE_RESULT_LESS; switch (reversedResult) {
case COMPARE_RESULT_LESS: case COMPARE_RESULT_GREATER:
return COMPARE_RESULT_GREATER; return COMPARE_RESULT_LESS;
default: case COMPARE_RESULT_LESS:
return reversedResult; return COMPARE_RESULT_GREATER;
default:
return reversedResult;
}
} }
}
}; };
template <typename T> template <typename T>
struct Comparer< struct Comparer<T, typename enable_if<is_convertible<T, JsonVariantConst>::value>::type> : VariantComparer {
T, typename enable_if<is_convertible<T, JsonVariantConst>::value>::type> explicit Comparer(const T & value)
: VariantComparer { : VariantComparer(VariantAttorney::getData(value)) {
explicit Comparer(const T& value) }
: VariantComparer(VariantAttorney::getData(value)) {}
}; };
template <typename T> template <typename T>
CompareResult compare(JsonVariantConst lhs, const T& rhs) { CompareResult compare(JsonVariantConst lhs, const T & rhs) {
Comparer<T> comparer(rhs); Comparer<T> comparer(rhs);
return variantAccept(VariantAttorney::getData(lhs), comparer); return variantAccept(VariantAttorney::getData(lhs), comparer);
} }
} // namespace ARDUINOJSON_NAMESPACE } // namespace ARDUINOJSON_NAMESPACE