Compiling..pheww

Author: wu-hui

firestore/CMakeLists.txt

@@ -41,6 +41,7 @@ set(common_SRCS
     src/common/hard_assert_common.h
     src/common/listener_registration.cc
     src/common/load_bundle_task_progress.cc
+    src/common/local_cache_settings.cc
     src/common/macros.h
     src/common/query.cc
     src/common/query_snapshot.cc

firestore/src/common/local_cache_settings.cc

@@ -48,6 +48,10 @@ PersistentCacheSettings PersistentCacheSettings::WithSizeBytes(
       settings_internal_->core_settings().WithSizeBytes(size)}};
 }
 
+const CoreCacheSettings& PersistentCacheSettings::core_cache_settings() const {
+  return settings_internal_->core_settings();
+}
+
 MemoryCacheSettings MemoryCacheSettings::Create() { return {}; }
 
 MemoryCacheSettings::MemoryCacheSettings() {
@@ -61,5 +65,10 @@ MemoryCacheSettings::MemoryCacheSettings(
     const MemoryCacheSettingsInternal& other) {
   settings_internal_ = std::make_unique<MemoryCacheSettingsInternal>(other);
 }
+
+const CoreCacheSettings& MemoryCacheSettings::core_cache_settings() const {
+  return settings_internal_->core_settings();
+}
+
 }  // namespace firestore
 }  // namespace firebase

firestore/src/common/settings.cc

@@ -16,10 +16,14 @@
 
 #include "firestore/src/include/firebase/firestore/settings.h"
 
+#include <memory>
 #include <ostream>
 #include <sstream>
 
+#include "Firestore/core/src/api/settings.h"
+#include "Firestore/core/src/util/hard_assert.h"
 #include "app/meta/move.h"
+#include "firebase/firestore/local_cache_settings.h"
 
 #if !defined(__ANDROID__)
 #include "Firestore/core/src/util/executor.h"
@@ -51,12 +55,46 @@ void Settings::set_host(std::string host) { host_ = firebase::Move(host); }
 
 void Settings::set_ssl_enabled(bool enabled) { ssl_enabled_ = enabled; }
 
+std::shared_ptr<LocalCacheSettings> Settings::local_cache_settings() const {
+  if (used_legacy_cache_settings_) {
+    if (is_persistence_enabled()) {
+      return std::make_shared<PersistentCacheSettings>(
+          *PersistentCacheSettings::Create()
+               .WithSizeBytes(cache_size_bytes())
+               .settings_internal_);
+    } else {
+      return std::make_shared<MemoryCacheSettings>(
+          *MemoryCacheSettings::Create().settings_internal_);
+    }
+  } else if (local_cache_settings_ != nullptr) {
+    return local_cache_settings_;
+  }
+
+  return std::make_shared<PersistentCacheSettings>(
+      *PersistentCacheSettings::Create().settings_internal_);
+}
+
+void Settings::set_local_cache_settings(const LocalCacheSettings& cache) {
+  HARD_ASSERT(!used_legacy_cache_settings_, "");
+  if (cache.kind() == api::LocalCacheSettings::Kind::kPersistent) {
+    local_cache_settings_ = std::make_shared<PersistentCacheSettings>(
+        *static_cast<const PersistentCacheSettings&>(cache).settings_internal_);
+  } else {
+    local_cache_settings_ = std::make_shared<MemoryCacheSettings>(
+        *static_cast<const MemoryCacheSettings&>(cache).settings_internal_);
+  }
+}
+
 void Settings::set_persistence_enabled(bool enabled) {
+  HARD_ASSERT(local_cache_settings() == nullptr, "");
   persistence_enabled_ = enabled;
+  used_legacy_cache_settings_ = true;
 }
 
 void Settings::set_cache_size_bytes(int64_t value) {
+  HARD_ASSERT(local_cache_settings() == nullptr, "");
   cache_size_bytes_ = value;
+  used_legacy_cache_settings_ = true;
 }
 
 std::string Settings::ToString() const {

firestore/src/include/firebase/firestore/local_cache_settings.h

@@ -21,42 +21,66 @@
 #include <memory>
 
 #include "Firestore/core/src/api/settings.h"
+#include "firestore/src/main/firestore_main.h"
 
 namespace firebase {
 namespace firestore {
 
+using CoreCacheSettings = api::LocalCacheSettings;
 using CoreMemorySettings = api::MemoryCacheSettings;
 using CorePersistentSettings = api::PersistentCacheSettings;
 
+class Settings;
 class PersistentCacheSettingsInternal;
 class MemoryCacheSettingsInternal;
 
 class LocalCacheSettings {
-  virtual ~LocalCacheSettings() = 0;
+ public:
+  virtual api::LocalCacheSettings::Kind kind() const = 0;
+  virtual ~LocalCacheSettings() = default;
+
+ private:
+  friend class FirestoreInternal;
+
+  virtual const CoreCacheSettings& core_cache_settings() const = 0;
 };
 
-class PersistentCacheSettings : public LocalCacheSettings {
+class PersistentCacheSettings final : public LocalCacheSettings {
  public:
   static PersistentCacheSettings Create();
+  ~PersistentCacheSettings();
+  PersistentCacheSettings(const PersistentCacheSettingsInternal& other);
 
   PersistentCacheSettings WithSizeBytes(int64_t size) const;
+  const CoreCacheSettings& core_cache_settings() const override;
+  api::LocalCacheSettings::Kind kind() const override {
+    return api::LocalCacheSettings::Kind::kPersistent;
+  }
 
  private:
+  friend class Settings;
+
   PersistentCacheSettings();
-  PersistentCacheSettings(const PersistentCacheSettingsInternal& other);
-  ~PersistentCacheSettings();
 
   std::unique_ptr<PersistentCacheSettingsInternal> settings_internal_;
 };
 
-class MemoryCacheSettings : public LocalCacheSettings {
+class MemoryCacheSettings final : public LocalCacheSettings {
  public:
   static MemoryCacheSettings Create();
+  ~MemoryCacheSettings();
+
+  const CoreCacheSettings& core_cache_settings() const override;
+  api::LocalCacheSettings::Kind kind() const override {
+    return api::LocalCacheSettings::Kind::kMemory;
+  }
+
+  MemoryCacheSettings(const MemoryCacheSettingsInternal& other);
 
  private:
+  friend class Settings;
+
   MemoryCacheSettings();
-  MemoryCacheSettings(const MemoryCacheSettingsInternal& other);
-  ~MemoryCacheSettings();
 
   std::unique_ptr<MemoryCacheSettingsInternal> settings_internal_;
 };

firestore/src/include/firebase/firestore/settings.h

@@ -17,6 +17,7 @@
 #ifndef FIREBASE_FIRESTORE_SRC_INCLUDE_FIREBASE_FIRESTORE_SETTINGS_H_
 #define FIREBASE_FIRESTORE_SRC_INCLUDE_FIREBASE_FIRESTORE_SETTINGS_H_
 
+#include "firebase/firestore/local_cache_settings.h"
 #if defined(__OBJC__)
 #include <dispatch/dispatch.h>
 #endif
@@ -47,6 +48,7 @@ class Executor;
 #endif
 
 class FirestoreInternal;
+class LocalCacheSettings;
 
 /** Settings used to configure a Firestore instance. */
 class Settings final {
@@ -136,6 +138,9 @@ class Settings final {
    */
   void set_ssl_enabled(bool enabled);
 
+  std::shared_ptr<LocalCacheSettings> local_cache_settings() const;
+  void set_local_cache_settings(const LocalCacheSettings& cache);
+
   /**
    * Enables or disables local persistent storage.
    *
@@ -213,6 +218,10 @@ class Settings final {
 
   std::string host_;
   bool ssl_enabled_ = true;
+
+  std::shared_ptr<LocalCacheSettings> local_cache_settings_ = nullptr;
+
+  bool used_legacy_cache_settings_ = false;
   bool persistence_enabled_ = true;
   int64_t cache_size_bytes_ = kDefaultCacheSizeBytes;
 

firestore/src/main/firestore_main.cc

@@ -23,6 +23,7 @@
 
 #include "Firestore/core/src/api/document_reference.h"
 #include "Firestore/core/src/api/query_core.h"
+#include "Firestore/core/src/api/settings.h"
 #include "Firestore/core/src/credentials/empty_credentials_provider.h"
 #include "Firestore/core/src/model/database_id.h"
 #include "Firestore/core/src/model/resource_path.h"
@@ -198,8 +199,13 @@ void FirestoreInternal::set_settings(Settings from) {
   api::Settings settings;
   settings.set_host(std::move(from.host()));
   settings.set_ssl_enabled(from.is_ssl_enabled());
-  settings.set_persistence_enabled(from.is_persistence_enabled());
-  settings.set_cache_size_bytes(from.cache_size_bytes());
+  if (!from.used_legacy_cache_settings_) {
+    settings.set_local_cache_settings(
+        from.local_cache_settings()->core_cache_settings());
+  } else {
+    settings.set_persistence_enabled(from.is_persistence_enabled());
+    settings.set_cache_size_bytes(from.cache_size_bytes());
+  }
   firestore_core_->set_settings(settings);
 
   std::unique_ptr<Executor> user_executor = from.CreateExecutor();

firestore/src/main/firestore_main.h

@@ -47,6 +47,7 @@ class Firestore;
 class ListenerRegistrationInternal;
 class Transaction;
 class WriteBatch;
+class Settings;
 
 namespace util {
 class Executor;

firestore/src/main/local_cache_settings_main.h

@@ -29,7 +29,8 @@ using CorePersistentSettings = api::PersistentCacheSettings;
 
 class LocalCacheSettingsInternal {};
 
-class PersistentCacheSettingsInternal : public LocalCacheSettingsInternal {
+class PersistentCacheSettingsInternal final
+    : public LocalCacheSettingsInternal {
  public:
   explicit PersistentCacheSettingsInternal(
       const CorePersistentSettings& core_settings)
@@ -43,7 +44,7 @@ class PersistentCacheSettingsInternal : public LocalCacheSettingsInternal {
   CorePersistentSettings settings_;
 };
 
-class MemoryCacheSettingsInternal : public LocalCacheSettingsInternal {
+class MemoryCacheSettingsInternal final : public LocalCacheSettingsInternal {
  public:
   explicit MemoryCacheSettingsInternal(const CoreMemorySettings& core_settings)
       : settings_(std::move(core_settings)) {}