Merge branch 'master' into development/macaddress-conv-op

Author: sebaszm

Source/core/JSON.h

@@ -3216,6 +3216,26 @@ namespace Core {
                 return (*this);
             }
 
+            bool operator==(const ArrayType<ELEMENT>& RHS) const
+            {
+                const uint16_t aLength = this->Length();
+                if (aLength != RHS.Length()) {
+                    return false;
+                }
+
+                for (uint16_t i = 0; i < aLength; ++i) {
+                    if (!((*this)[i] == RHS[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool operator!=(const ArrayType<ELEMENT>& RHS) const
+            {
+                return !(*this == RHS);
+            }
+
         public:
             // IElement and IMessagePack iface:
             bool IsSet() const override
@@ -4537,6 +4557,9 @@ namespace Core {
                 return (*this);
             }
 
+            bool operator==(const Variant& other) const;
+            bool operator!=(const Variant& other) const;
+
             inline void ToString(string& result) const;
 
             // IElement and IMessagePack iface:
@@ -4713,7 +4736,6 @@ namespace Core {
                 , _elements(std::move(move._elements))
             {
                 Elements::iterator index(_elements.begin());
-
                 while (index != _elements.end()) {
                     ASSERT (HasLabel(index->first.c_str()));
                     Container::Add(index->first.c_str(), &(index->second));
@@ -4805,6 +4827,33 @@ namespace Core {
                 return (*this);
             }
 
+            bool operator==(const VariantContainer& RHS) const
+            {
+                if (this->Size() != RHS.Size()) {
+                    return false;
+                }
+
+                auto it = this->Variants();
+                while (it.Next()) {
+                    const TCHAR* key = it.Label();
+                    const JSON::Variant* valRHS = RHS.FindValue(key);
+
+                    if (valRHS == nullptr) {
+                        return false;
+                    }
+
+                    if (!(it.Current() == *valRHS)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            bool operator!=(const VariantContainer& RHS) const
+            {
+                return !(*this == RHS);
+            }
+
             void Set(const TCHAR fieldName[], const JSON::Variant& value)
             {
                 Elements::iterator index(Find(fieldName));
@@ -4868,6 +4917,12 @@ namespace Core {
                        );
             }
 
+            const JSON::Variant* FindValue(const TCHAR key[]) const
+            {
+                Elements::const_iterator index(Find(key));
+                return (index == _elements.end() ? nullptr : &index->second);
+            }
+
             Iterator Variants() const
             {
                 return (Iterator(_elements));
@@ -4944,6 +4999,40 @@ namespace Core {
             return (result);
         }
 
+        inline bool Variant::operator==(const Variant& other) const
+        {
+            if (_type != other._type) {
+                return false;
+            }
+
+            switch (_type) {
+                case type::EMPTY:
+                    return true;
+                case type::BOOLEAN:
+                    return Boolean() == other.Boolean();
+                case type::STRING:
+                    return String() == other.String();
+                case type::NUMBER:
+                    return Number() == other.Number();
+                case type::FLOAT:
+                    return Float() == other.Float();
+                case type::DOUBLE:
+                    return Double() == other.Double();
+                case type::ARRAY:
+                    return Array() == other.Array();
+                case type::OBJECT:
+                    return Object() == other.Object();
+                default:
+                    ASSERT(false);
+            }
+            return false;
+        }
+
+        inline bool Variant::operator!=(const Variant& other) const
+        {
+            return !(*this == other);
+        }
+
         inline bool Variant::IsValid() const {
             bool result = false;
             switch (_type)