Added operators == and != for two JsonVariants (issue #436)

include/ArduinoJson/Data/JsonVariantComparer.hpp

@@ -0,0 +1,69 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#pragma once
+
+#include "../JsonVariantBase.hpp"
+#include "../StringTraits/StringTraits.hpp"
+#include "../TypeTraits/EnableIf.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+template <typename TComparand, typename Enable = void>
+struct JsonVariantComparer {};
+
+template <typename TString>
+struct JsonVariantComparer<
+    TString,
+    typename TypeTraits::EnableIf<TypeTraits::IsString<TString>::value>::type> {
+  template <typename TVariant>
+  static bool equals(const JsonVariantBase<TVariant> &variant,
+                     const TString &comparand) {
+    const char *value = variant.template as<const char *>();
+    return Internals::StringTraits<TString>::equals(comparand, value);
+  }
+};
+
+template <typename TComparand>
+struct JsonVariantComparer<
+    TComparand, typename TypeTraits::EnableIf<
+                    !TypeTraits::IsVariant<TComparand>::value &&
+                    !TypeTraits::IsString<TComparand>::value>::type> {
+  template <typename TVariant>
+  static bool equals(const JsonVariantBase<TVariant> &variant,
+                     const TComparand &comparand) {
+    return variant.template as<TComparand>() == comparand;
+  }
+};
+
+template <typename TVariant2>
+struct JsonVariantComparer<TVariant2,
+                           typename TypeTraits::EnableIf<
+                               TypeTraits::IsVariant<TVariant2>::value>::type> {
+  template <typename TVariant1>
+  static bool equals(const JsonVariantBase<TVariant1> &left,
+                     const TVariant2 &right) {
+    if (left.template is<bool>() && right.template is<bool>())
+      return left.template as<bool>() == right.template as<bool>();
+    if (left.template is<JsonInteger>() && right.template is<JsonInteger>())
+      return left.template as<JsonInteger>() ==
+             right.template as<JsonInteger>();
+    if (left.template is<JsonFloat>() && right.template is<JsonFloat>())
+      return left.template as<JsonFloat>() == right.template as<JsonFloat>();
+    if (left.template is<JsonArray>() && right.template is<JsonArray>())
+      return left.template as<JsonArray>() == right.template as<JsonArray>();
+    if (left.template is<JsonObject>() && right.template is<JsonObject>())
+      return left.template as<JsonObject>() == right.template as<JsonObject>();
+    if (left.template is<char *>() && right.template is<char *>())
+      return strcmp(left.template as<char *>(), right.template as<char *>()) ==
+             0;
+
+    return false;
+  }
+};
+}
+}

include/ArduinoJson/JsonVariantBase.hpp

@@ -63,6 +63,11 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
     return impl()->template as<T>();
   }
 
+  template <typename T>
+  FORCE_INLINE bool is() const {
+    return impl()->template is<T>();
+  }
+
   // Mimics an array or an object.
   // Returns the size of the array or object if the variant has that type.
   // Returns 0 if the variant is neither an array nor an object
@@ -126,4 +131,9 @@ class JsonVariantBase : public Internals::JsonPrintable<TImpl> {
     return static_cast<const TImpl *>(this);
   }
 };
+
+namespace TypeTraits {
+template <typename T>
+struct IsVariant : IsBaseOf<JsonVariantBase<T>, T> {};
+}
 }

include/ArduinoJson/JsonVariantComparisons.hpp

@@ -7,100 +7,82 @@
 
 #pragma once
 
-#include "JsonVariantBase.hpp"
-#include "StringTraits/StringTraits.hpp"
-#include "TypeTraits/EnableIf.hpp"
+#include "Data/JsonVariantComparer.hpp"
 
 namespace ArduinoJson {
-template <typename TVariant, typename TComparand, typename Enable = void>
-struct JsonVariantComparer {
-  static bool equals(const TVariant &variant, const TComparand &comparand) {
-    return variant.template as<TComparand>() == comparand;
-  }
-};
-
-template <typename TVariant, typename TString>
-struct JsonVariantComparer<
-    TVariant, TString, typename TypeTraits::EnableIf<Internals::StringTraits<
-                           TString>::has_equals>::type> {
-  static bool equals(const TVariant &variant, const TString &comparand) {
-    const char *value = variant.template as<const char *>();
-    return Internals::StringTraits<TString>::equals(comparand, value);
-  }
-};
-
-template <typename TImpl, typename TComparand>
-inline bool operator==(const JsonVariantBase<TImpl> &variant,
+template <typename TVariant, typename TComparand>
+inline bool operator==(const JsonVariantBase<TVariant> &variant,
                        TComparand comparand) {
-  typedef JsonVariantBase<TImpl> TVariant;
-  return JsonVariantComparer<TVariant, TComparand>::equals(variant, comparand);
+  return Internals::JsonVariantComparer<TComparand>::equals(variant, comparand);
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator==(TComparand comparand,
-                       const JsonVariantBase<TImpl> &variant) {
-  typedef JsonVariantBase<TImpl> TVariant;
-  return JsonVariantComparer<TVariant, TComparand>::equals(variant, comparand);
+template <typename TVariant, typename TComparand>
+inline typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
+                                     bool>::type
+operator==(TComparand comparand, const JsonVariantBase<TVariant> &variant) {
+  return Internals::JsonVariantComparer<TComparand>::equals(variant, comparand);
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator!=(const JsonVariantBase<TImpl> &variant,
+template <typename TVariant, typename TComparand>
+inline bool operator!=(const JsonVariantBase<TVariant> &variant,
                        TComparand comparand) {
-  typedef JsonVariantBase<TImpl> TVariant;
-  return !JsonVariantComparer<TVariant, TComparand>::equals(variant, comparand);
+  return !Internals::JsonVariantComparer<TComparand>::equals(variant,
+                                                             comparand);
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator!=(TComparand comparand,
-                       const JsonVariantBase<TImpl> &variant) {
-  typedef JsonVariantBase<TImpl> TVariant;
-  return !JsonVariantComparer<TVariant, TComparand>::equals(variant, comparand);
+template <typename TVariant, typename TComparand>
+inline typename TypeTraits::EnableIf<!TypeTraits::IsVariant<TComparand>::value,
+                                     bool>::type
+operator!=(TComparand comparand, const JsonVariantBase<TVariant> &variant) {
+  return !Internals::JsonVariantComparer<TComparand>::equals(variant,
+                                                             comparand);
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator<=(const JsonVariantBase<TImpl> &left, TComparand right) {
+template <typename TVariant, typename TComparand>
+inline bool operator<=(const JsonVariantBase<TVariant> &left,
+                       TComparand right) {
   return left.template as<TComparand>() <= right;
 }
 
-template <typename TImpl, typename TComparand>
+template <typename TVariant, typename TComparand>
 inline bool operator<=(TComparand comparand,
-                       const JsonVariantBase<TImpl> &variant) {
+                       const JsonVariantBase<TVariant> &variant) {
   return comparand <= variant.template as<TComparand>();
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator>=(const JsonVariantBase<TImpl> &variant,
+template <typename TVariant, typename TComparand>
+inline bool operator>=(const JsonVariantBase<TVariant> &variant,
                        TComparand comparand) {
   return variant.template as<TComparand>() >= comparand;
 }
 
-template <typename TImpl, typename TComparand>
+template <typename TVariant, typename TComparand>
 inline bool operator>=(TComparand comparand,
-                       const JsonVariantBase<TImpl> &variant) {
+                       const JsonVariantBase<TVariant> &variant) {
   return comparand >= variant.template as<TComparand>();
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator<(const JsonVariantBase<TImpl> &varian,
+template <typename TVariant, typename TComparand>
+inline bool operator<(const JsonVariantBase<TVariant> &varian,
                       TComparand comparand) {
   return varian.template as<TComparand>() < comparand;
 }
 
-template <typename TImpl, typename TComparand>
+template <typename TVariant, typename TComparand>
 inline bool operator<(TComparand comparand,
-                      const JsonVariantBase<TImpl> &variant) {
+                      const JsonVariantBase<TVariant> &variant) {
   return comparand < variant.template as<TComparand>();
 }
 
-template <typename TImpl, typename TComparand>
-inline bool operator>(const JsonVariantBase<TImpl> &variant,
+template <typename TVariant, typename TComparand>
+inline bool operator>(const JsonVariantBase<TVariant> &variant,
                       TComparand comparand) {
   return variant.template as<TComparand>() > comparand;
 }
 
-template <typename TImpl, typename TComparand>
+template <typename TVariant, typename TComparand>
 inline bool operator>(TComparand comparand,
-                      const JsonVariantBase<TImpl> &variant) {
+                      const JsonVariantBase<TVariant> &variant) {
   return comparand > variant.template as<TComparand>();
 }
 }

include/ArduinoJson/StringTraits/StdString.hpp

@@ -34,7 +34,7 @@ struct StdStringTraits {
   };
 
   static bool equals(const TString& str, const char* expected) {
-    return str == expected;
+    return 0 == strcmp(str.c_str(), expected);
   }
 
   static void append(TString& str, char c) {

include/ArduinoJson/StringTraits/StringTraits.hpp

@@ -40,3 +40,18 @@ struct StringTraits<TString&, void> : StringTraits<TString> {};
 #if ARDUINOJSON_ENABLE_PROGMEM
 #include "FlashString.hpp"
 #endif
+
+namespace ArduinoJson {
+namespace TypeTraits {
+template <typename T, typename Enable = void>
+struct IsString {
+  static const bool value = false;
+};
+
+template <typename T>
+struct IsString<T, typename TypeTraits::EnableIf<
+                       Internals::StringTraits<T>::has_equals>::type> {
+  static const bool value = Internals::StringTraits<T>::has_equals;
+};
+}
+}