get things to compile

Author: dconeybe

Firestore/core/src/core/filter.h

@@ -17,6 +17,7 @@
 #ifndef FIRESTORE_CORE_SRC_CORE_FILTER_H_
 #define FIRESTORE_CORE_SRC_CORE_FILTER_H_
 
+#include <functional>
 #include <iosfwd>
 #include <memory>
 #include <string>
@@ -146,7 +147,8 @@ class Filter {
     virtual bool IsEmpty() const = 0;
 
     virtual const std::vector<FieldFilter>& GetFlattenedFilters() const {
-      return flattened_filters_.value();
+      const auto func = std::bind(&Rep::CalculateFlattenedFilters, this);
+      return memoized_flattened_filters_.value(func);
     }
 
     virtual std::vector<Filter> GetFilters() const = 0;
@@ -159,7 +161,7 @@ class Filter {
      * Memoized list of all field filters that can be found by
      * traversing the tree of filters contained in this composite filter.
      */
-    mutable util::ThreadSafeMemoizer<std::vector<FieldFilter>> flattened_filters_{[&] { return CalculateFlattenedFilters(); }};
+    mutable util::ThreadSafeMemoizer<std::vector<FieldFilter>> memoized_flattened_filters_;
   };
 
   explicit Filter(std::shared_ptr<const Rep>&& rep) : rep_(rep) {

Firestore/core/src/core/query.cc

@@ -17,6 +17,7 @@
 #include "Firestore/core/src/core/query.h"
 
 #include <algorithm>
+#include <memory>
 #include <ostream>
 
 #include "Firestore/core/src/core/bound.h"
@@ -92,7 +93,7 @@ absl::optional<Operator> Query::FindOpInsideFilters(
   return absl::nullopt;
 }
 
-std::shared_ptr<std::vector<OrderBy>> Query::calculate_normalized_order_bys() const {
+std::shared_ptr<std::vector<OrderBy>> Query::CalculateNormalizedOrderBys() const {
   auto result = std::make_shared<std::vector<OrderBy>>(explicit_order_bys_);
 
   std::set<FieldPath> fieldsNormalized;
@@ -295,11 +296,11 @@ std::string Query::ToString() const {
   return absl::StrCat("Query(canonical_id=", CanonicalId(), ")");
 }
 
-std::shared_ptr<Target> Query::calculate_target() const {
+std::shared_ptr<Target> Query::CalculateTarget() const {
   return std::make_shared<Target>(ToTarget(normalized_order_bys()));
 }
 
-std::shared_ptr<Target> Query::calculate_aggregate_target() const {
+std::shared_ptr<Target> Query::CalculateAggregateTarget() const {
   return std::make_shared<Target>(ToTarget(explicit_order_bys_));
 }
 

Firestore/core/src/core/query.h

@@ -149,7 +149,8 @@ class Query {
    * backend behavior.
    */
   const std::vector<OrderBy>& normalized_order_bys() const {
-    return normalized_order_bys_.value();
+    const auto func = std::bind(&Query::CalculateNormalizedOrderBys, this);
+    return memoized_normalized_order_bys_.value(func);
   }
 
   bool has_limit() const {
@@ -249,7 +250,8 @@ class Query {
    * and local store.
    */
   const Target& ToTarget() const& {
-    return target_.value();
+    const auto func = std::bind(&Query::CalculateTarget, this);
+    return memoized_target_.value(func);
   }
 
   /**
@@ -259,7 +261,8 @@ class Query {
    * normalized order-bys, they only contain explicit order-bys.
    */
   const Target& ToAggregateTarget() const& {
-    return aggregate_target_.value();
+    const auto func = std::bind(&Query::CalculateAggregateTarget, this);
+    return memoized_aggregate_target_.value(func);
   }
 
   friend std::ostream& operator<<(std::ostream& os, const Query& query);
@@ -301,19 +304,18 @@ class Query {
   // member variable, which is not copyable).
 
   // The memoized list of sort orders.
-  std::shared_ptr<std::vector<OrderBy>> calculate_normalized_order_bys() const;
-  mutable util::ThreadSafeMemoizer<std::vector<OrderBy>>
-      normalized_order_bys_{[&] {return calculate_normalized_order_bys(); }};
+  std::shared_ptr<std::vector<OrderBy>> CalculateNormalizedOrderBys() const;
+  mutable util::ThreadSafeMemoizer<std::vector<OrderBy>> memoized_normalized_order_bys_;
 
   // The corresponding Target of this Query instance.
-  std::shared_ptr<Target> calculate_target() const;
-  mutable util::ThreadSafeMemoizer<Target> target_{[&] {return calculate_target(); }};
+  std::shared_ptr<Target> CalculateTarget() const;
+  mutable util::ThreadSafeMemoizer<Target> memoized_target_;
 
   // The corresponding aggregate Target of this Query instance. Unlike targets
   // for non-aggregate queries, aggregate query targets do not contain
   // normalized order-bys, they only contain explicit order-bys.
-  std::shared_ptr<Target> calculate_aggregate_target() const;
-  mutable util::ThreadSafeMemoizer<Target> aggregate_target_{[&] {return calculate_aggregate_target(); }};;
+  std::shared_ptr<Target> CalculateAggregateTarget() const;
+  mutable util::ThreadSafeMemoizer<Target> memoized_aggregate_target_;
 };
 
 bool operator==(const Query& lhs, const Query& rhs);

Firestore/core/src/util/thread_safe_memoizer.h

@@ -20,7 +20,6 @@
 #include <atomic>
 #include <functional>
 #include <memory>
-#include <utility>
 
 namespace firebase {
 namespace firestore {
@@ -33,22 +32,19 @@ namespace util {
 template <typename T>
 class ThreadSafeMemoizer {
  public:
-  explicit ThreadSafeMemoizer(std::function<std::shared_ptr<T>()> func) : func_(std::move(func)) {
-  }
+  ThreadSafeMemoizer() = default;
 
-  ThreadSafeMemoizer(const ThreadSafeMemoizer& other) : func_(other.func_), memoized_(std::atomic_load(&other.memoized_)) {}
+  ThreadSafeMemoizer(const ThreadSafeMemoizer& other) : memoized_(std::atomic_load(&other.memoized_)) {}
 
   ThreadSafeMemoizer& operator=(const ThreadSafeMemoizer& other) {
-    func_ = other.func_;
     std::atomic_store(&memoized_, std::atomic_load(&other.memoized_));
     return *this;
   }
 
-  ThreadSafeMemoizer(ThreadSafeMemoizer&& other) noexcept : func_(std::move(other.func_)), memoized_(std::atomic_load(&other.memoized_)) {
+  ThreadSafeMemoizer(ThreadSafeMemoizer&& other) noexcept : memoized_(std::atomic_load(&other.memoized_)) {
   }
 
   ThreadSafeMemoizer& operator=(ThreadSafeMemoizer&& other) noexcept {
-    func_ = std::move(other.func_);
     std::atomic_store(&memoized_, std::atomic_load(&other.memoized_));
     return *this;
   }
@@ -70,14 +66,14 @@ class ThreadSafeMemoizer {
    * No reference to the given function is retained by this object, and the
    * function be called synchronously, if it is called at all.
    */
-  const T& value() {
+  const T& value(const std::function<std::shared_ptr<T>()>& func) {
     std::shared_ptr<T> old_memoized = std::atomic_load(&memoized_);
     while (true) {
       if (old_memoized) {
         return *old_memoized;
       }
 
-      std::shared_ptr<T> new_memoized = func_();
+      std::shared_ptr<T> new_memoized = func();
 
       if (std::atomic_compare_exchange_weak(&memoized_, &old_memoized, new_memoized)) {
         return *new_memoized;
@@ -86,7 +82,6 @@ class ThreadSafeMemoizer {
   }
 
  private:
-  std::function<std::shared_ptr<T>()> func_;
   std::shared_ptr<T> memoized_;
 };
 

Firestore/core/test/unit/util/thread_safe_memoizer_test.cc

@@ -40,13 +40,13 @@ TEST(ThreadSafeMemoizerTest, MultiThreadedMemoization) {
   constexpr int expected_result = 78;
 
   // Create a thread safe memoizer and multiple threads.
-  ThreadSafeMemoizer<int> memoized_result(expensive_lambda);
+  ThreadSafeMemoizer<int> memoized_result;
   std::vector<std::thread> threads;
 
   for (int i = 0; i < num_threads; ++i) {
     threads.emplace_back(
-        [&memoized_result, expected_result] {
-          const int& actual_result = memoized_result.value();
+        [&memoized_result, expected_result, &expensive_lambda] {
+          const int& actual_result = memoized_result.value(expensive_lambda);
           // Verify that all threads get the same memoized result.
           EXPECT_EQ(actual_result, expected_result);
         });