VariantOperators.hpp

00001 // ArduinoJson - arduinojson.org
00002 // Copyright Benoit Blanchon 2014-2021
00003 // MIT License
00004 
00005 #pragma once
00006 
00007 #include <ArduinoJson/Misc/Visitable.hpp>
00008 #include <ArduinoJson/Numbers/arithmeticCompare.hpp>
00009 #include <ArduinoJson/Polyfills/attributes.hpp>
00010 #include <ArduinoJson/Polyfills/type_traits.hpp>
00011 #include <ArduinoJson/Variant/VariantAs.hpp>
00012 #include <ArduinoJson/Variant/VariantTag.hpp>
00013 
00014 namespace ARDUINOJSON_NAMESPACE {
00015 
00016 template <typename T1, typename T2>
00017 CompareResult compare(const T1 &lhs, const T2 &rhs);  // VariantCompare.cpp
00018 
00019 template <typename TVariant>
00020 struct VariantOperators {
00021   // Returns the default value if the VariantRef is undefined or incompatible
00022   //
00023   // int operator|(JsonVariant, int)
00024   // float operator|(JsonVariant, float)
00025   // bool operator|(JsonVariant, bool)
00026   // const char* operator|(JsonVariant, const char*)
00027   // char* operator|(JsonVariant, const char*)
00028   template <typename T>
00029   friend typename enable_if<!IsVariant<T>::value,
00030                             typename VariantAs<T>::type>::type
00031   operator|(const TVariant &variant, T defaultValue) {
00032     if (variant.template is<T>())
00033       return variant.template as<T>();
00034     else
00035       return defaultValue;
00036   }
00037   //
00038   // JsonVariant operator|(JsonVariant, JsonVariant)
00039   template <typename T>
00040   friend typename enable_if<IsVariant<T>::value, typename T::variant_type>::type
00041   operator|(const TVariant &variant, T defaultValue) {
00042     if (variant)
00043       return variant;
00044     else
00045       return defaultValue;
00046   }
00047 
00048   // value == TVariant
00049   template <typename T>
00050   friend bool operator==(T *lhs, TVariant rhs) {
00051     return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
00052   }
00053   template <typename T>
00054   friend bool operator==(const T &lhs, TVariant rhs) {
00055     return compare(rhs, lhs) == COMPARE_RESULT_EQUAL;
00056   }
00057 
00058   // TVariant == value
00059   template <typename T>
00060   friend bool operator==(TVariant lhs, T *rhs) {
00061     return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
00062   }
00063   template <typename T>
00064   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator==(
00065       TVariant lhs, const T &rhs) {
00066     return compare(lhs, rhs) == COMPARE_RESULT_EQUAL;
00067   }
00068 
00069   // value != TVariant
00070   template <typename T>
00071   friend bool operator!=(T *lhs, TVariant rhs) {
00072     return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
00073   }
00074   template <typename T>
00075   friend bool operator!=(const T &lhs, TVariant rhs) {
00076     return compare(rhs, lhs) != COMPARE_RESULT_EQUAL;
00077   }
00078 
00079   // TVariant != value
00080   template <typename T>
00081   friend bool operator!=(TVariant lhs, T *rhs) {
00082     return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
00083   }
00084   template <typename T>
00085   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator!=(
00086       TVariant lhs, const T &rhs) {
00087     return compare(lhs, rhs) != COMPARE_RESULT_EQUAL;
00088   }
00089 
00090   // value < TVariant
00091   template <typename T>
00092   friend bool operator<(T *lhs, TVariant rhs) {
00093     return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
00094   }
00095   template <typename T>
00096   friend bool operator<(const T &lhs, TVariant rhs) {
00097     return compare(rhs, lhs) == COMPARE_RESULT_GREATER;
00098   }
00099 
00100   // TVariant < value
00101   template <typename T>
00102   friend bool operator<(TVariant lhs, T *rhs) {
00103     return compare(lhs, rhs) == COMPARE_RESULT_LESS;
00104   }
00105   template <typename T>
00106   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<(
00107       TVariant lhs, const T &rhs) {
00108     return compare(lhs, rhs) == COMPARE_RESULT_LESS;
00109   }
00110 
00111   // value <= TVariant
00112   template <typename T>
00113   friend bool operator<=(T *lhs, TVariant rhs) {
00114     return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
00115   }
00116   template <typename T>
00117   friend bool operator<=(const T &lhs, TVariant rhs) {
00118     return (compare(rhs, lhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
00119   }
00120 
00121   // TVariant <= value
00122   template <typename T>
00123   friend bool operator<=(TVariant lhs, T *rhs) {
00124     return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
00125   }
00126   template <typename T>
00127   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator<=(
00128       TVariant lhs, const T &rhs) {
00129     return (compare(lhs, rhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
00130   }
00131 
00132   // value > TVariant
00133   template <typename T>
00134   friend bool operator>(T *lhs, TVariant rhs) {
00135     return compare(rhs, lhs) == COMPARE_RESULT_LESS;
00136   }
00137   template <typename T>
00138   friend bool operator>(const T &lhs, TVariant rhs) {
00139     return compare(rhs, lhs) == COMPARE_RESULT_LESS;
00140   }
00141 
00142   // TVariant > value
00143   template <typename T>
00144   friend bool operator>(TVariant lhs, T *rhs) {
00145     return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
00146   }
00147   template <typename T>
00148   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>(
00149       TVariant lhs, const T &rhs) {
00150     return compare(lhs, rhs) == COMPARE_RESULT_GREATER;
00151   }
00152 
00153   // value >= TVariant
00154   template <typename T>
00155   friend bool operator>=(T *lhs, TVariant rhs) {
00156     return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
00157   }
00158   template <typename T>
00159   friend bool operator>=(const T &lhs, TVariant rhs) {
00160     return (compare(rhs, lhs) & COMPARE_RESULT_LESS_OR_EQUAL) != 0;
00161   }
00162 
00163   // TVariant >= value
00164   template <typename T>
00165   friend bool operator>=(TVariant lhs, T *rhs) {
00166     return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
00167   }
00168   template <typename T>
00169   friend typename enable_if<!IsVisitable<T>::value, bool>::type operator>=(
00170       TVariant lhs, const T &rhs) {
00171     return (compare(lhs, rhs) & COMPARE_RESULT_GREATER_OR_EQUAL) != 0;
00172   }
00173 };
00174 }  // namespace ARDUINOJSON_NAMESPACE