operator== and operator!= for SetOptions. (#606)

* operator== and operator!= for SetOptions.

* Address comments.

* Return a reference.

* Fix lint warning.

Author: ehsannas

firestore/integration_test_internal/CMakeLists.txt

@@ -95,6 +95,7 @@ set(FIREBASE_INTEGRATION_TEST_PORTABLE_TEST_SRCS
     src/query_test.cc
     src/sanity_test.cc
     src/server_timestamp_test.cc
+    src/set_options_test.cc
     src/settings_test.cc
     src/smoke_test.cc
     src/source_test.cc

firestore/integration_test_internal/src/set_options_test.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "firebase/firestore.h"
+
+#include "gtest/gtest.h"
+
+namespace firebase {
+namespace firestore {
+namespace {
+
+TEST(SetOptionsTest, Equality) {
+  SetOptions opt1 = SetOptions();
+  SetOptions opt2 = SetOptions();
+  SetOptions opt3 = SetOptions::Merge();
+  SetOptions opt4 = SetOptions::Merge();
+  SetOptions opt5 = SetOptions::MergeFields({"a", "a", "b", "c.d"});
+  SetOptions opt6 = SetOptions::MergeFields({"c.d", "b", "a", "b"});
+  SetOptions opt7 = SetOptions::MergeFields({"b"});
+
+  EXPECT_TRUE(opt1 == opt1);
+  EXPECT_TRUE(opt1 == opt2);
+  EXPECT_TRUE(opt1 != opt3);
+  EXPECT_TRUE(opt1 != opt4);
+  EXPECT_TRUE(opt1 != opt5);
+  EXPECT_TRUE(opt1 != opt6);
+  EXPECT_TRUE(opt1 != opt7);
+  EXPECT_TRUE(opt3 == opt4);
+  EXPECT_TRUE(opt3 != opt5);
+  EXPECT_TRUE(opt3 != opt6);
+  EXPECT_TRUE(opt3 != opt7);
+  EXPECT_TRUE(opt5 == opt6);
+  EXPECT_TRUE(opt5 != opt7);
+
+  EXPECT_FALSE(opt1 != opt1);
+  EXPECT_FALSE(opt1 != opt2);
+  EXPECT_FALSE(opt1 == opt3);
+  EXPECT_FALSE(opt1 == opt4);
+  EXPECT_FALSE(opt1 == opt5);
+  EXPECT_FALSE(opt1 == opt6);
+  EXPECT_FALSE(opt1 == opt7);
+  EXPECT_FALSE(opt3 != opt4);
+  EXPECT_FALSE(opt3 == opt5);
+  EXPECT_FALSE(opt3 == opt6);
+  EXPECT_FALSE(opt3 == opt7);
+  EXPECT_FALSE(opt5 != opt6);
+  EXPECT_FALSE(opt5 == opt7);
+}
+
+}  // namespace
+}  // namespace firestore
+}  // namespace firebase

firestore/src/common/set_options.cc

@@ -21,29 +21,30 @@
 namespace firebase {
 namespace firestore {
 
-SetOptions::SetOptions(Type type, std::vector<FieldPath> fields)
+SetOptions::SetOptions(Type type, std::unordered_set<FieldPath> fields)
     : type_(type), fields_(firebase::Move(fields)) {}
 
 SetOptions::~SetOptions() {}
 
 /* static */
 SetOptions SetOptions::Merge() {
-  return SetOptions{Type::kMergeAll, std::vector<FieldPath>{}};
+  return SetOptions{Type::kMergeAll, std::unordered_set<FieldPath>{}};
 }
 
 /* static */
 SetOptions SetOptions::MergeFields(const std::vector<std::string>& fields) {
-  std::vector<FieldPath> field_paths;
+  std::unordered_set<FieldPath> field_paths;
   field_paths.reserve(fields.size());
   for (const std::string& field : fields) {
-    field_paths.push_back(FieldPath::FromDotSeparatedString(field));
+    field_paths.insert(FieldPath::FromDotSeparatedString(field));
   }
   return SetOptions{Type::kMergeSpecific, firebase::Move(field_paths)};
 }
 
 /* static */
 SetOptions SetOptions::MergeFieldPaths(const std::vector<FieldPath>& fields) {
-  return SetOptions{Type::kMergeSpecific, fields};
+  return SetOptions{Type::kMergeSpecific, std::unordered_set<FieldPath>(
+                                              fields.begin(), fields.end())};
 }
 
 }  // namespace firestore

firestore/src/include/firebase/firestore/set_options.h

@@ -18,6 +18,7 @@
 #define FIREBASE_FIRESTORE_SRC_INCLUDE_FIREBASE_FIRESTORE_SET_OPTIONS_H_
 
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 #include "firebase/firestore/field_path.h"
@@ -135,14 +136,25 @@ class SetOptions final {
   static SetOptions MergeFieldPaths(const std::vector<FieldPath>& fields);
 
  private:
+  friend bool operator==(const SetOptions& lhs, const SetOptions& rhs);
   friend class SetOptionsInternal;
 
-  SetOptions(Type type, std::vector<FieldPath> fields);
+  SetOptions(Type type, std::unordered_set<FieldPath> fields);
 
   Type type_ = Type::kOverwrite;
-  std::vector<FieldPath> fields_;
+  std::unordered_set<FieldPath> fields_;
 };
 
+/** Checks `lhs` and `rhs` for equality. */
+inline bool operator==(const SetOptions& lhs, const SetOptions& rhs) {
+  return lhs.type_ == rhs.type_ && lhs.fields_ == rhs.fields_;
+}
+
+/** Checks `lhs` and `rhs` for inequality. */
+inline bool operator!=(const SetOptions& lhs, const SetOptions& rhs) {
+  return !(lhs == rhs);
+}
+
 }  // namespace firestore
 }  // namespace firebase
 

firestore/src/main/set_options_main.h

@@ -17,6 +17,7 @@
 #ifndef FIREBASE_FIRESTORE_SRC_MAIN_SET_OPTIONS_MAIN_H_
 #define FIREBASE_FIRESTORE_SRC_MAIN_SET_OPTIONS_MAIN_H_
 
+#include <unordered_set>
 #include <utility>
 
 #include "firestore/src/include/firebase/firestore/set_options.h"
@@ -41,7 +42,9 @@ class SetOptionsInternal {
       : options_{std::move(options)} {}
 
   Type type() const { return options_.type_; }
-  const std::vector<FieldPath>& field_mask() const { return options_.fields_; }
+  const std::unordered_set<FieldPath>& field_mask() const {
+    return options_.fields_;
+  }
 
  private:
   SetOptions options_;

firestore/src/main/user_data_converter_main.cc

@@ -157,7 +157,7 @@ void ParseNumericIncrement(const FieldValue& value, ParseContext&& context) {
 }
 
 FieldMask CreateFieldMask(const ParseAccumulator& accumulator,
-                          const std::vector<FieldPath>& field_paths) {
+                          const std::unordered_set<FieldPath>& field_paths) {
   std::set<model::FieldPath> validated;
 
   for (const FieldPath& public_path : field_paths) {
@@ -240,7 +240,8 @@ ParsedSetData UserDataConverter::ParseSetData(
 
 ParsedSetData UserDataConverter::ParseMergeData(
     const MapFieldValue& input,
-    const absl::optional<std::vector<FieldPath>>& maybe_field_mask) const {
+    const absl::optional<std::unordered_set<FieldPath>>& maybe_field_mask)
+    const {
   ParseAccumulator accumulator{UserDataSource::MergeSet};
 
   auto update_data = ParseMap(input, accumulator.RootContext());

firestore/src/main/user_data_converter_main.h

@@ -17,6 +17,7 @@
 #ifndef FIREBASE_FIRESTORE_SRC_MAIN_USER_DATA_CONVERTER_MAIN_H_
 #define FIREBASE_FIRESTORE_SRC_MAIN_USER_DATA_CONVERTER_MAIN_H_
 
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -78,7 +79,7 @@ class UserDataConverter {
   /** Parse document data from a merge `SetData` call. */
   core::ParsedSetData ParseMergeData(
       const MapFieldValue& input,
-      const absl::optional<std::vector<FieldPath>>& field_mask =
+      const absl::optional<std::unordered_set<FieldPath>>& field_mask =
           absl::nullopt) const;
 
   /**

release_build_files/readme.md

@@ -571,7 +571,7 @@ code.
 -   Changes
     -   General: Updating Android and iOS dependencies to the latest.
     -   Firestore: Added `operator==` and `operator!=` for `SnapshotMetadata`,
-        `Settings`, `QuerySnapshot`, and `DocumentSnapshot`.
+        `Settings`, `QuerySnapshot`, `DocumentSnapshot`, and `SetOptions`.
 
 ### 8.3.0
 -   Changes