Migrate to AnyInvocable in data/

PiperOrigin-RevId: 566721712

internal/data/BUILD

@@ -21,6 +21,7 @@ cc_library(
         "//third_party/leveldb:util",
         "//third_party/protobuf:protobuf_lite",
         "@com_google_absl//absl/container:flat_hash_map",
+        "@com_google_absl//absl/functional:any_invocable",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/synchronization",
     ],

internal/data/data_set.h

@@ -15,12 +15,13 @@
 #ifndef THIRD_PARTY_NEARBY_INTERNAL_DATA_DATA_SET_H_
 #define THIRD_PARTY_NEARBY_INTERNAL_DATA_DATA_SET_H_
 
-#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "absl/functional/any_invocable.h"
+
 namespace nearby {
 namespace data {
 
@@ -43,12 +44,13 @@ class DataSet {
   // Asynchronously initializes the object, which must have been created by the
   // DataManager::GetDataSet<T> function. |callback| will be invoked on the
   // calling thread when complete.
-  virtual void Initialize(std::function<void(InitStatus)> callback) = 0;
+  virtual void Initialize(absl::AnyInvocable<void(InitStatus) &&> callback) = 0;
 
   // Asynchronously loads all entries from the database and invokes |callback|
   // when complete.
   virtual void LoadEntries(
-      std::function<void(bool, std::unique_ptr<std::vector<T>>)> callback) = 0;
+      absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+          callback) = 0;
 
   // Asynchronously saves |entries_to_save| and deletes entries from
   // |keys_to_remove| from the database. |callback| will be invoked on the
@@ -57,11 +59,11 @@ class DataSet {
   virtual void UpdateEntries(
       std::unique_ptr<KeyEntryVector> entries_to_save,
       std::unique_ptr<std::vector<std::string>> keys_to_remove,
-      std::function<void(bool)> callback) = 0;
+      absl::AnyInvocable<void(bool) &&> callback) = 0;
 
   // Asynchronously destroys the database. Use this call only if the database
   // needs to be destroyed for this particular profile.
-  virtual void Destroy(std::function<void(bool)> callback) = 0;
+  virtual void Destroy(absl::AnyInvocable<void(bool) &&> callback) = 0;
 };
 
 }  // namespace data

internal/data/leveldb_data_set.h

@@ -15,14 +15,13 @@
 #ifndef THIRD_PARTY_NEARBY_INTERNAL_DATA_LEVELDB_DATA_SET_H_
 #define THIRD_PARTY_NEARBY_INTERNAL_DATA_LEVELDB_DATA_SET_H_
 
-#include <functional>
 #include <memory>
-#include <ostream>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+#include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 #include "third_party/leveldb/include/db.h"
 #include "third_party/leveldb/include/iterator.h"
@@ -47,17 +46,19 @@ class LeveldbDataSet : public DataSet<T> {
   explicit LeveldbDataSet(absl::string_view path) : path_(path) {}
   ~LeveldbDataSet() override = default;
 
-  void Initialize(std::function<void(InitStatus)> callback) override;
-  void LoadEntries(std::function<void(bool, std::unique_ptr<std::vector<T>>)>
-                       callback) override;
+  void Initialize(absl::AnyInvocable<void(InitStatus) &&> callback) override;
+  void LoadEntries(
+      absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+          callback) override;
   void LoadEntriesWithKeys(
-      std::function<
-          void(bool, std::unique_ptr<std::vector<std::pair<std::string, T>>>)>
+      absl::AnyInvocable<
+          void(bool,
+               std::unique_ptr<std::vector<std::pair<std::string, T>>>) &&>
           callback);
   void UpdateEntries(std::unique_ptr<KeyEntryVector> entries_to_save,
                      std::unique_ptr<std::vector<std::string>> keys_to_remove,
-                     std::function<void(bool)> callback) override;
-  void Destroy(std::function<void(bool)> callback) override;
+                     absl::AnyInvocable<void(bool) &&> callback) override;
+  void Destroy(absl::AnyInvocable<void(bool) &&> callback) override;
 
  private:
   void Serialize(T const& value, std::string& str);
@@ -73,7 +74,7 @@ template <typename T,
           std::enable_if_t<std::is_base_of<proto2::MessageLite, T>::value, bool>
               isMessageLite>
 void LeveldbDataSet<T, isMessageLite>::Initialize(
-    std::function<void(InitStatus)> callback) {
+    absl::AnyInvocable<void(InitStatus) &&> callback) {
   leveldb::Options options;
   options.create_if_missing = true;
 
@@ -99,7 +100,8 @@ template <typename T,
           std::enable_if_t<std::is_base_of<proto2::MessageLite, T>::value, bool>
               isMessageLite>
 void LeveldbDataSet<T, isMessageLite>::LoadEntries(
-    std::function<void(bool, std::unique_ptr<std::vector<T>>)> callback) {
+    absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+        callback) {
   auto result = std::make_unique<std::vector<T>>();
   if (status_ != InitStatus::kOK) {
     std::move(callback)(false, std::move(result));
@@ -130,8 +132,8 @@ template <typename T,
           std::enable_if_t<std::is_base_of<proto2::MessageLite, T>::value, bool>
               isMessageLite>
 void LeveldbDataSet<T, isMessageLite>::LoadEntriesWithKeys(
-    std::function<void(bool,
-                       std::unique_ptr<std::vector<std::pair<std::string, T>>>)>
+    absl::AnyInvocable<
+        void(bool, std::unique_ptr<std::vector<std::pair<std::string, T>>>) &&>
         callback) {
   auto result = std::make_unique<std::vector<std::pair<std::string, T>>>();
   if (status_ != InitStatus::kOK) {
@@ -165,7 +167,7 @@ template <typename T,
 void LeveldbDataSet<T, isMessageLite>::UpdateEntries(
     std::unique_ptr<KeyEntryVector> entries_to_save,
     std::unique_ptr<std::vector<std::string>> keys_to_remove,
-    std::function<void(bool)> callback) {
+    absl::AnyInvocable<void(bool) &&> callback) {
   NEARBY_LOGS(INFO) << "UpdateEntries is called.";
   if (status_ != InitStatus::kOK) {
     std::move(callback)(false);
@@ -193,7 +195,7 @@ template <typename T,
           std::enable_if_t<std::is_base_of<proto2::MessageLite, T>::value, bool>
               isMessageLite>
 void LeveldbDataSet<T, isMessageLite>::Destroy(
-    std::function<void(bool)> callback) {
+    absl::AnyInvocable<void(bool) &&> callback) {
   NEARBY_LOGS(INFO) << "Destroy is called.";
   db_.reset();
   leveldb::DestroyDB(path_, leveldb::Options());

internal/data/memory_data_set.h

@@ -15,13 +15,13 @@
 #ifndef THIRD_PARTY_NEARBY_INTERNAL_DATA_MEMORY_DATA_SET_H_
 #define THIRD_PARTY_NEARBY_INTERNAL_DATA_MEMORY_DATA_SET_H_
 
-#include <functional>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
 #include "absl/strings/string_view.h"
 #include "absl/synchronization/mutex.h"
 #include "internal/data/data_set.h"
@@ -37,13 +37,14 @@ class MemoryDataSet : public DataSet<T> {
   explicit MemoryDataSet(absl::string_view path) : path_(path) {}
   ~MemoryDataSet() override = default;
 
-  void Initialize(std::function<void(InitStatus)> callback) override;
-  void LoadEntries(std::function<void(bool, std::unique_ptr<std::vector<T>>)>
-                       callback) override;
+  void Initialize(absl::AnyInvocable<void(InitStatus) &&> callback) override;
+  void LoadEntries(
+      absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+          callback) override;
   void UpdateEntries(std::unique_ptr<KeyEntryVector> entries_to_save,
                      std::unique_ptr<std::vector<std::string>> keys_to_remove,
-                     std::function<void(bool)> callback) override;
-  void Destroy(std::function<void(bool)> callback) override;
+                     absl::AnyInvocable<void(bool) &&> callback) override;
+  void Destroy(absl::AnyInvocable<void(bool) &&> callback) override;
 
  private:
   std::string path_;
@@ -53,13 +54,15 @@ class MemoryDataSet : public DataSet<T> {
 };
 
 template <typename T>
-void MemoryDataSet<T>::Initialize(std::function<void(InitStatus)> callback) {
+void MemoryDataSet<T>::Initialize(
+    absl::AnyInvocable<void(InitStatus) &&> callback) {
   std::move(callback)(InitStatus::kOK);
 }
 
 template <typename T>
 void MemoryDataSet<T>::LoadEntries(
-    std::function<void(bool, std::unique_ptr<std::vector<T>>)> callback) {
+    absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+        callback) {
   auto result = std::make_unique<std::vector<T>>();
   auto it = entries_.begin();
   while (it != entries_.end()) {
@@ -74,7 +77,7 @@ template <typename T>
 void MemoryDataSet<T>::UpdateEntries(
     std::unique_ptr<KeyEntryVector> entries_to_save,
     std::unique_ptr<std::vector<std::string>> keys_to_remove,
-    std::function<void(bool)> callback) {
+    absl::AnyInvocable<void(bool) &&> callback) {
   if (entries_to_save != nullptr) {
     auto it = entries_to_save->begin();
     while (it != entries_to_save->end()) {
@@ -95,7 +98,7 @@ void MemoryDataSet<T>::UpdateEntries(
 }
 
 template <typename T>
-void MemoryDataSet<T>::Destroy(std::function<void(bool)> callback) {
+void MemoryDataSet<T>::Destroy(absl::AnyInvocable<void(bool) &&> callback) {
   entries_.clear();
   std::move(callback)(true);
 }

internal/test/fake_data_set.h

@@ -22,6 +22,7 @@
 #include <vector>
 
 #include "absl/container/flat_hash_map.h"
+#include "absl/functional/any_invocable.h"
 #include "internal/data/data_set.h"
 
 namespace nearby {
@@ -35,41 +36,42 @@ class FakeDataSet : public DataSet<T> {
   explicit FakeDataSet(const absl::flat_hash_map<std::string, T>& entries_map)
       : entries_map_(entries_map) {}
 
-  void Initialize(std::function<void(InitStatus)> callback) override {
+  void Initialize(absl::AnyInvocable<void(InitStatus) &&> callback) override {
     init_callback_ = std::move(callback);
   }
 
-  void LoadEntries(std::function<void(bool, std::unique_ptr<std::vector<T>>)>
-                       callback) override {
+  void LoadEntries(
+      absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+          callback) override {
     load_callback_ = std::move(callback);
   }
 
   void UpdateEntries(std::unique_ptr<KeyEntryVector> entries_to_save,
                      std::unique_ptr<std::vector<std::string>> keys_to_remove,
-                     std::function<void(bool)> callback) override {
+                     absl::AnyInvocable<void(bool) &&> callback) override {
     entries_to_save_ = std::move(entries_to_save);
     keys_to_remove_ = std::move(keys_to_remove);
     update_callback_ = std::move(callback);
   }
 
-  void Destroy(std::function<void(bool)> callback) override {
+  void Destroy(absl::AnyInvocable<void(bool) &&> callback) override {
     destroy_callback_ = std::move(callback);
   }
 
   // Mocked methods
   void InitStatusCallback(InitStatus status) {
-    if (init_callback_ != nullptr) {
-      init_callback_(status);
+    if (auto callback = std::move(init_callback_)) {
+      std::move(callback)(status);
     }
   }
 
   void LoadCallback(bool success) {
-    if (load_callback_ != nullptr) {
+    if (auto callback = std::move(load_callback_)) {
       auto entries = std::make_unique<std::vector<T>>();
       for (auto it = entries_map_.begin(); it != entries_map_.end(); ++it) {
         entries->push_back(it->second);
       }
-      load_callback_(success, std::move(entries));
+      std::move(callback)(success, std::move(entries));
     }
   }
 
@@ -97,8 +99,8 @@ class FakeDataSet : public DataSet<T> {
 
     entries_to_save_ = nullptr;
     keys_to_remove_ = nullptr;
-    if (update_callback_ != nullptr) {
-      update_callback_(success);
+    if (auto callback = std::move(update_callback_)) {
+      std::move(callback)(success);
     }
   }
 
@@ -106,9 +108,8 @@ class FakeDataSet : public DataSet<T> {
     if (success) {
       entries_map_.clear();
     }
-
-    if (destroy_callback_ != nullptr) {
-      destroy_callback_(success);
+    if (auto callback = std::move(destroy_callback_)) {
+      std::move(callback)(success);
     }
   }
 
@@ -116,13 +117,13 @@ class FakeDataSet : public DataSet<T> {
 
  private:
   absl::flat_hash_map<std::string, T> entries_map_ = nullptr;
-  std::function<void(InitStatus)> init_callback_ = nullptr;
-  std::function<void(bool, std::unique_ptr<std::vector<T>>)> load_callback_ =
-      nullptr;
+  absl::AnyInvocable<void(InitStatus) &&> init_callback_ = nullptr;
+  absl::AnyInvocable<void(bool, std::unique_ptr<std::vector<T>>) &&>
+      load_callback_ = nullptr;
   std::unique_ptr<KeyEntryVector> entries_to_save_ = nullptr;
   std::unique_ptr<std::vector<std::string>> keys_to_remove_ = nullptr;
-  std::function<void(bool)> update_callback_ = nullptr;
-  std::function<void(bool)> destroy_callback_ = nullptr;
+  absl::AnyInvocable<void(bool) &&> update_callback_ = nullptr;
+  absl::AnyInvocable<void(bool) &&> destroy_callback_ = nullptr;
 };
 
 }  // namespace data