Replace FilterList with std::vector<Filter> for future maintenance (#10398)

Author: cherylEnkidu

Firestore/core/src/bundle/bundle_serializer.cc

@@ -51,7 +51,6 @@ using core::Bound;
 using core::Direction;
 using core::FieldFilter;
 using core::Filter;
-using core::FilterList;
 using core::LimitType;
 using core::OrderBy;
 using core::OrderByList;
@@ -400,8 +399,8 @@ ResourcePath BundleSerializer::DecodeName(JsonReader& reader,
   return path.PopFirst(5);
 }
 
-FilterList BundleSerializer::DecodeWhere(JsonReader& reader,
-                                         const json& query) const {
+std::vector<Filter> BundleSerializer::DecodeWhere(JsonReader& reader,
+                                                  const json& query) const {
   // Absent 'where' is a valid case.
   if (!query.contains("where")) {
     return {};
@@ -413,13 +412,12 @@ FilterList BundleSerializer::DecodeWhere(JsonReader& reader,
     return {};
   }
 
-  FilterList result;
   if (where.contains("compositeFilter")) {
     return DecodeCompositeFilter(reader, where.at("compositeFilter"));
   } else if (where.contains("fieldFilter")) {
-    return result.push_back(DecodeFieldFilter(reader, where.at("fieldFilter")));
+    return {DecodeFieldFilter(reader, where.at("fieldFilter"))};
   } else if (where.contains("unaryFilter")) {
-    return result.push_back(DecodeUnaryFilter(reader, where.at("unaryFilter")));
+    return {DecodeUnaryFilter(reader, where.at("unaryFilter"))};
   } else {
     reader.Fail("'where' does not have valid filter");
     return {};
@@ -446,8 +444,8 @@ Filter BundleSerializer::DecodeFieldFilter(JsonReader& reader,
   return FieldFilter::Create(path, op, std::move(value));
 }
 
-FilterList BundleSerializer::DecodeCompositeFilter(JsonReader& reader,
-                                                   const json& filter) const {
+std::vector<Filter> BundleSerializer::DecodeCompositeFilter(
+    JsonReader& reader, const json& filter) const {
   if (reader.RequiredString("op", filter) != "AND") {
     reader.Fail("The SDK only supports composite filters of type 'AND'");
     return {};
@@ -458,14 +456,14 @@ FilterList BundleSerializer::DecodeCompositeFilter(JsonReader& reader,
       reader.OptionalArray("filters", filter, default_filters);
 
   const json default_objects;
-  FilterList result;
+  std::vector<Filter> result;
   for (const auto& f : filters) {
     const json& field_filter =
         reader.OptionalObject("fieldFilter", f, default_objects);
     if (!field_filter.empty()) {
-      result = result.push_back(DecodeFieldFilter(reader, field_filter));
+      result.push_back(DecodeFieldFilter(reader, field_filter));
     } else {
-      result = result.push_back(DecodeUnaryFilter(
+      result.push_back(DecodeUnaryFilter(
           reader, reader.OptionalObject("unaryFilter", f, default_objects)));
     }
 

Firestore/core/src/bundle/bundle_serializer.h

@@ -26,6 +26,7 @@
 #include "Firestore/core/src/bundle/bundled_document_metadata.h"
 #include "Firestore/core/src/bundle/named_query.h"
 #include "Firestore/core/src/core/core_fwd.h"
+#include "Firestore/core/src/core/filter.h"
 #include "Firestore/core/src/model/resource_path.h"
 #include "Firestore/core/src/model/snapshot_version.h"
 #include "Firestore/core/src/nanopb/message.h"
@@ -60,12 +61,12 @@ class BundleSerializer {
  private:
   BundledQuery DecodeBundledQuery(util::JsonReader& reader,
                                   const nlohmann::json& query) const;
-  core::FilterList DecodeWhere(util::JsonReader& reader,
-                               const nlohmann::json& query) const;
+  std::vector<core::Filter> DecodeWhere(util::JsonReader& reader,
+                                        const nlohmann::json& query) const;
   core::Filter DecodeFieldFilter(util::JsonReader& reader,
                                  const nlohmann::json& filter) const;
-  core::FilterList DecodeCompositeFilter(util::JsonReader& reader,
-                                         const nlohmann::json& filter) const;
+  std::vector<core::Filter> DecodeCompositeFilter(
+      util::JsonReader& reader, const nlohmann::json& filter) const;
   nanopb::Message<google_firestore_v1_Value> DecodeValue(
       util::JsonReader& reader, const nlohmann::json& value) const;
 

Firestore/core/src/core/core_fwd.h

@@ -72,8 +72,6 @@ class EventListener;
 
 using CollectionGroupId = std::shared_ptr<const std::string>;
 
-using FilterList = immutable::AppendOnlyList<Filter>;
-
 using OrderByList = immutable::AppendOnlyList<OrderBy>;
 
 using TransactionResultCallback = util::StatusCallback;

Firestore/core/src/core/filter.h

@@ -27,11 +27,6 @@
 namespace firebase {
 namespace firestore {
 
-namespace immutable {
-template <typename T>
-class AppendOnlyList;
-}  // namespace immutable
-
 namespace core {
 
 class FieldFilter;
@@ -177,9 +172,6 @@ inline bool operator!=(const Filter& lhs, const Filter& rhs) {
   return !(lhs == rhs);
 }
 
-/** A list of Filters, as used in Queries and elsewhere. */
-using FilterList = immutable::AppendOnlyList<Filter>;
-
 std::ostream& operator<<(std::ostream& os, const Filter& filter);
 
 }  // namespace core

Firestore/core/src/core/query.cc

@@ -172,9 +172,12 @@ Query Query::AddingFilter(Filter filter) const {
                   explicit_order_bys_[0].field() == *new_inequality_field,
               "First orderBy must match inequality field");
 
+  std::vector<Filter> filters_copy(filters_);
+  filters_copy.push_back(std::move(filter));
+
   return {path_,
           collection_group_,
-          filters_.push_back(std::move(filter)),
+          std::move(filters_copy),
           explicit_order_bys_,
           limit_,
           limit_type_,

Firestore/core/src/core/query.h

@@ -63,7 +63,7 @@ class Query {
    */
   Query(model::ResourcePath path,
         CollectionGroupId collection_group,
-        FilterList filters,
+        std::vector<Filter> filters,
         OrderByList explicit_order_bys,
         int32_t limit,
         LimitType limit_type,
@@ -108,7 +108,7 @@ class Query {
   bool MatchesAllDocuments() const;
 
   /** The filters on the documents returned by the query. */
-  const FilterList& filters() const {
+  const std::vector<Filter>& filters() const {
     return filters_;
   }
 
@@ -260,10 +260,11 @@ class Query {
   std::shared_ptr<const std::string> collection_group_;
 
   // Filters are shared across related Query instance. i.e. when you call
-  // Query::Filter(f), a new Query instance is created that contains all of the
-  // existing filters, plus the new one. (Both Query and Filter objects are
-  // immutable.) Filters are not shared across unrelated Query instances.
-  FilterList filters_;
+  // Query::AddingFilter(f), a new Query instance is created that contains
+  // all of the existing filters, plus the new one. (Both Query and Filter
+  // objects are immutable.) Filters are not shared across unrelated Query
+  // instances.
+  std::vector<Filter> filters_;
 
   // A list of fields given to sort by. This does not include the implicit key
   // sort at the end.

Firestore/core/src/core/target.h

@@ -86,7 +86,7 @@ class Target {
   bool IsDocumentQuery() const;
 
   /** The filters on the documents returned by the target. */
-  const FilterList& filters() const {
+  const std::vector<Filter>& filters() const {
     return filters_;
   }
 
@@ -178,7 +178,7 @@ class Target {
    */
   Target(model::ResourcePath path,
          CollectionGroupId collection_group,
-         FilterList filters,
+         std::vector<Filter> filters,
          OrderByList order_bys,
          int32_t limit,
          absl::optional<Bound> start_at,
@@ -221,7 +221,7 @@ class Target {
 
   model::ResourcePath path_;
   std::shared_ptr<const std::string> collection_group_;
-  FilterList filters_;
+  std::vector<Filter> filters_;
   OrderByList order_bys_;
   int32_t limit_ = kNoLimit;
   absl::optional<Bound> start_at_;

Firestore/core/src/local/leveldb_index_manager.cc

@@ -957,17 +957,18 @@ std::vector<Target> LevelDbIndexManager::GetSubTargets(const Target& target) {
     std::vector<Filter> dnf = LogicUtils::GetDnfTerms(CompositeFilter::Create(
         std::move(filters), CompositeFilter::Operator::And));
 
+    // TODO(orquery): Add getFilters() in Filter class.
     for (const Filter& term : dnf) {
-      core::FilterList filter_list;
+      std::vector<Filter> subfilters;
       if (term.IsAFieldFilter()) {
-        filter_list = filter_list.push_back(term);
+        subfilters.push_back(term);
       } else if (term.IsACompositeFilter()) {
         for (const auto& filter : (CompositeFilter(term)).filters()) {
-          filter_list = filter_list.push_back(filter);
+          subfilters.push_back(filter);
         }
       }
       subtargets.push_back({target.path(), target.collection_group(),
-                            std::move(filter_list), target.order_bys(),
+                            std::move(subfilters), target.order_bys(),
                             target.limit(), target.start_at(),
                             target.end_at()});
     }

Firestore/core/src/remote/serializer.cc

@@ -66,7 +66,6 @@ using core::CompositeFilter;
 using core::Direction;
 using core::FieldFilter;
 using core::Filter;
-using core::FilterList;
 using core::OrderBy;
 using core::OrderByList;
 using core::Query;
@@ -757,7 +756,7 @@ Target Serializer::DecodeStructuredQuery(
     }
   }
 
-  FilterList filter_by;
+  std::vector<Filter> filter_by;
   if (query.where.which_filter_type != 0) {
     filter_by = DecodeFilters(context, query.where);
   }
@@ -803,16 +802,12 @@ Target Serializer::DecodeQueryTarget(
 }
 
 google_firestore_v1_StructuredQuery_Filter Serializer::EncodeFilters(
-    const core::FilterList& filter_list) const {
-  std::vector<Filter> filters;
-  for (const auto& filter : filter_list) {
-    filters.push_back(filter);
-  }
+    const std::vector<Filter>& filter_list) const {
   return EncodeCompositeFilter(CompositeFilter::Create(
-      std::move(filters), CompositeFilter::Operator::And));
+      std::vector<Filter>(filter_list), CompositeFilter::Operator::And));
 }
 
-FilterList Serializer::DecodeFilters(
+std::vector<Filter> Serializer::DecodeFilters(
     ReadContext* context,
     google_firestore_v1_StructuredQuery_Filter& proto) const {
   Filter decoded_filter = DecodeFilter(context, proto).ValueOrDie();
@@ -824,12 +819,7 @@ FilterList Serializer::DecodeFilters(
   if (decoded_filter.IsACompositeFilter()) {
     CompositeFilter composite_filter(decoded_filter);
     if (composite_filter.IsFlatConjunction()) {
-      FilterList result;
-      result = result.reserve(composite_filter.filters().size());
-      for (const auto& filter : composite_filter.filters()) {
-        result = result.push_back(filter);
-      }
-      return result;
+      return composite_filter.filters();
     }
   }
 

Firestore/core/src/remote/serializer.h

@@ -219,7 +219,7 @@ class Serializer {
    * Decodes the structured query. Modifies the provided proto to release
    * ownership of any Value messages.
    */
-  core::FilterList DecodeFilters(
+  std::vector<core::Filter> DecodeFilters(
       util::ReadContext* context,
       google_firestore_v1_StructuredQuery_Filter& proto) const;
 
@@ -270,7 +270,7 @@ class Serializer {
   std::string EncodeLabel(local::QueryPurpose purpose) const;
 
   google_firestore_v1_StructuredQuery_Filter EncodeFilters(
-      const core::FilterList& filter_list) const;
+      const std::vector<core::Filter>& filter_list) const;
   google_firestore_v1_StructuredQuery_Filter EncodeFilter(
       const core::Filter& filter) const;
   google_firestore_v1_StructuredQuery_Filter EncodeUnaryOrFieldFilter(