Implement comparison operators for base::Value

base/values.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file specifies a recursive data storage class called Value intended for
 // storing settings and other persistable data.
 //
 // A Value represents something that can be stored in JSON or passed to/from
 // JavaScript. As such, it is NOT a generalized variant type, since only the
 // types supported by JavaScript/JSON are supported.
@@ skipping 143 matching lines @@
   // Note: Do not add more types. See the file-level comment above for why.
 
   // This creates a deep copy of the entire Value tree, and returns a pointer
   // to the copy. The caller gets ownership of the copy, of course.
   // Subclasses return their own type directly in their overrides;
   // this works because C++ supports covariant return types.
   Value* DeepCopy() const;
   // Preferred version of DeepCopy. TODO(estade): remove the above.
   std::unique_ptr<Value> CreateDeepCopy() const;
 
+  // Comparison operators.
+  friend bool operator==(const Value& lhs, const Value& rhs) {
+    if (lhs.type_ != rhs.type_)
+      return false;
+
+    switch (lhs.type_) {
+      case Type::NONE:
+        return true;
+      case Type::BOOLEAN:
+        return lhs.bool_value_ == rhs.bool_value_;
+      case Type::INTEGER:
+        return lhs.int_value_ == rhs.int_value_;
+      case Type::DOUBLE:
+        return lhs.double_value_ == rhs.double_value_;
+      case Type::STRING:
+        return *lhs.string_value_ == *rhs.string_value_;
+      case Type::BINARY:
+        return *lhs.binary_value_ == *rhs.binary_value_;
+      // TODO(crbug.com/646113): Clean this up when DictionaryValue and
+      // ListValue are completely inlined.
+      case Type::DICTIONARY:
+        if ((*lhs.dict_ptr_)->size() != (*rhs.dict_ptr_)->size())
+          return false;
+        return std::equal(std::begin(**lhs.dict_ptr_),
+                          std::end(**lhs.dict_ptr_),
+                          std::begin(**rhs.dict_ptr_),
+                          [](const DictStorage::value_type& u,
+                             const DictStorage::value_type& v) {
+                            return std::tie(u.first, *u.second) ==
+                                   std::tie(v.first, *v.second);
+                          });
+      case Type::LIST:
+        if (lhs.list_->size() != rhs.list_->size())
+          return false;
+        return std::equal(
+            std::begin(*lhs.list_), std::end(*lhs.list_),
+            std::begin(*rhs.list_),
+            [](const ListStorage::value_type& u,
+               const ListStorage::value_type& v) { return *u == *v; });
+    }
+
+    NOTREACHED();
+    return false;
+  }
+
+  friend bool operator!=(const Value& lhs, const Value& rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend bool operator<(const Value& lhs, const Value& rhs) {
+    if (lhs.type_ != rhs.type_)
+      return lhs.type_ < rhs.type_;
+
+    switch (lhs.type_) {
+      case Type::NONE:
+        return false;
+      case Type::BOOLEAN:
+        return lhs.bool_value_ < rhs.bool_value_;
+      case Type::INTEGER:
+        return lhs.int_value_ < rhs.int_value_;
+      case Type::DOUBLE:
+        return lhs.double_value_ < rhs.double_value_;
+      case Type::STRING:
+        return *lhs.string_value_ < *rhs.string_value_;
+      case Type::BINARY:
+        return *lhs.binary_value_ < *rhs.binary_value_;
+      // TODO(crbug.com/646113): Clean this up when DictionaryValue and
+      // ListValue are completely inlined.
+      case Type::DICTIONARY:
+        return std::lexicographical_compare(
+            std::begin(**lhs.dict_ptr_), std::end(**lhs.dict_ptr_),
+            std::begin(**rhs.dict_ptr_), std::end(**rhs.dict_ptr_),
+            [](const DictStorage::value_type& u,
+               const DictStorage::value_type& v) {
+              return std::tie(u.first, *u.second) <
+                     std::tie(v.first, *v.second);
+            });
+      case Type::LIST:
+        return std::lexicographical_compare(
+            std::begin(*lhs.list_), std::end(*lhs.list_),
+            std::begin(*rhs.list_), std::end(*rhs.list_),
+            [](const ListStorage::value_type& u,
+               const ListStorage::value_type& v) { return *u < *v; });
+    }
+
+    NOTREACHED();
+    return false;
+  }
+
+  friend bool operator>(const Value& lhs, const Value& rhs) {
+    return rhs < lhs;
+  }
+
+  friend bool operator<=(const Value& lhs, const Value& rhs) {
+    return !(rhs < lhs);
+  }
+
+  friend bool operator>=(const Value& lhs, const Value& rhs) {
+    return !(lhs < rhs);
+  }
+
   // Compares if two Value objects have equal contents.
+  // DEPRECATED, use operator==(const Value& lhs, const Value& rhs) instead.
+  // TODO(crbug.com/646113): Delete this and migrate callsites.
   bool Equals(const Value* other) const;
 
   // Compares if two Value objects have equal contents. Can handle NULLs.
   // NULLs are considered equal but different from Value::CreateNullValue().
+  // DEPRECATED, use operator==(const Value& lhs, const Value& rhs) instead.
+  // TODO(crbug.com/646113): Delete this and migrate callsites.
   static bool Equals(const Value* a, const Value* b);
 
  protected:
   // TODO(crbug.com/646113): Make these private once DictionaryValue and
   // ListValue are properly inlined.
   Type type_;
 
   union {
     bool bool_value_;
     int int_value_;
@@ skipping 334 matching lines @@
   return out << static_cast<const Value&>(value);
 }
 
 // Stream operator so that enum class Types can be used in log statements.
 BASE_EXPORT std::ostream& operator<<(std::ostream& out,
                                      const Value::Type& type);
 
 }  // namespace base
 
 #endif  // BASE_VALUES_H_