Remove Visitable

src/ArduinoJson/Variant/VariantCompare.hpp

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <ArduinoJson/Configuration.hpp>
-#include <ArduinoJson/Misc/Visitable.hpp>
 #include <ArduinoJson/Numbers/arithmeticCompare.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
@@ -128,12 +127,10 @@ struct RawComparer : ComparerBase {
   }
 };
 
-template <typename T>
-struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
-    : ComparerBase {
-  const T *rhs;  // TODO: should be a VariantConstRef
+struct VariantComparer : ComparerBase {
+  VariantConstRef rhs;
 
-  explicit Comparer(const T &value) : rhs(&value) {}
+  explicit VariantComparer(VariantConstRef value) : rhs(value) {}
 
   CompareResult visitArray(const CollectionData &lhs) {
     ArrayComparer comparer(lhs);
@@ -183,7 +180,7 @@ struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
  private:
   template <typename TComparer>
   CompareResult accept(TComparer &comparer) {
-    CompareResult reversedResult = rhs->accept(comparer);
+    CompareResult reversedResult = rhs.accept(comparer);
     switch (reversedResult) {
       case COMPARE_RESULT_GREATER:
         return COMPARE_RESULT_LESS;
@@ -195,9 +192,17 @@ struct Comparer<T, typename enable_if<IsVisitable<T>::value>::type>
   }
 };
 
-template <typename T1, typename T2>
-CompareResult compare(const T1 &lhs, const T2 &rhs) {
-  Comparer<T2> comparer(rhs);
+template <typename T>
+struct Comparer<
+    T, typename enable_if<is_convertible<T, VariantConstRef>::value>::type>
+    : VariantComparer {
+  explicit Comparer(const T &value)
+      : VariantComparer(value.operator VariantConstRef()) {}
+};
+
+template <typename T>
+CompareResult compare(VariantConstRef lhs, const T &rhs) {
+  Comparer<T> comparer(rhs);
   return lhs.accept(comparer);
 }
 

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -124,11 +124,6 @@ VariantRef::to() const {
   return *this;
 }
 
-inline VariantConstRef operator|(VariantConstRef preferedValue,
-                                 VariantConstRef defaultValue) {
-  return preferedValue ? preferedValue : defaultValue;
-}
-
 // Out of class definition to avoid #1560
 inline bool VariantRef::set(char value) const {
   return set(static_cast<signed char>(value));

src/ArduinoJson/Variant/VariantOperators.hpp

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <ArduinoJson/Misc/Visitable.hpp>
 #include <ArduinoJson/Numbers/arithmeticCompare.hpp>
 #include <ArduinoJson/Polyfills/attributes.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
@@ -12,11 +11,16 @@
 
 namespace ARDUINOJSON_NAMESPACE {
 
-template <typename T1, typename T2>
-CompareResult compare(const T1 &lhs, const T2 &rhs);  // VariantCompare.cpp
+class VariantConstRef;
+
+template <typename T>
+CompareResult compare(VariantConstRef lhs,
+                      const T &rhs);  // VariantCompare.cpp
+
+struct VariantOperatorTag {};
 
 template <typename TVariant>
-struct VariantOperators {
+struct VariantOperators : VariantOperatorTag {
   // Returns the default value if the VariantRef is unbound or incompatible
   //
   // int operator|(JsonVariant, int)
@@ -43,7 +47,7 @@ struct VariantOperators {
   //
   // JsonVariant operator|(JsonVariant, JsonVariant)
   template <typename T>
-  friend typename enable_if<IsVariant<T>::value, typename T::variant_type>::type
+  friend typename enable_if<IsVariant<T>::value, VariantConstRef>::type
   operator|(const TVariant &variant, T defaultValue) {
     if (variant)
       return variant;
@@ -67,8 +71,9 @@ struct VariantOperators {
     return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator==(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator==(TVariant lhs, const T &rhs) {
     return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
   }
 
@@ -88,8 +93,9 @@ struct VariantOperators {
     return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator!=(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator!=(TVariant lhs, const T &rhs) {
     return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
   }
 
@@ -109,8 +115,9 @@ struct VariantOperators {
     return compare(lhs, rhs) == COMPARE_RESULT_LESS;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator<(TVariant lhs, const T &rhs) {
     return compare(lhs, rhs) == COMPARE_RESULT_LESS;
   }
 
@@ -130,8 +137,9 @@ struct VariantOperators {
     return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<=(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator<=(TVariant lhs, const T &rhs) {
     return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
   }
 
@@ -151,8 +159,9 @@ struct VariantOperators {
     return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator>(TVariant lhs, const T &rhs) {
     return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
   }
 
@@ -172,8 +181,9 @@ struct VariantOperators {
     return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
   }
   template <typename T>
-  friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>=(
-      TVariant lhs, const T &rhs) {
+  friend
+      typename enable_if<!is_base_of<VariantOperatorTag, T>::value, bool>::type
+      operator>=(TVariant lhs, const T &rhs) {
     return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
   }
 };

src/ArduinoJson/Variant/VariantRef.hpp

@@ -8,7 +8,6 @@
 #include <stdint.h>  // for uint8_t
 
 #include <ArduinoJson/Memory/MemoryPool.hpp>
-#include <ArduinoJson/Misc/Visitable.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <ArduinoJson/Variant/Converter.hpp>
@@ -66,8 +65,7 @@ class VariantRefBase : public VariantTag {
 
 class VariantConstRef : public VariantRefBase<const VariantData>,
                         public VariantOperators<VariantConstRef>,
-                        public VariantShortcuts<VariantConstRef>,
-                        public Visitable {
+                        public VariantShortcuts<VariantConstRef> {
   typedef VariantRefBase<const VariantData> base_type;
 
  public:
@@ -180,8 +178,7 @@ class VariantConstRef : public VariantRefBase<const VariantData>,
 // - a reference to a ArrayRef or ObjectRef
 class VariantRef : public VariantRefBase<VariantData>,
                    public VariantOperators<VariantRef>,
-                   public VariantShortcuts<VariantRef>,
-                   public Visitable {
+                   public VariantShortcuts<VariantRef> {
   typedef VariantRefBase<VariantData> base_type;
 
  public: