Replace absl::optional usage in API (#8902)

Author: wu-hui

Firestore/Source/API/FIRCollectionReference.mm

@@ -25,6 +25,7 @@
 
 #include "Firestore/core/src/api/collection_reference.h"
 #include "Firestore/core/src/api/document_reference.h"
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/core/user_data.h"
 #include "Firestore/core/src/model/resource_path.h"
 #include "Firestore/core/src/util/error_apple.h"
@@ -33,6 +34,7 @@
 
 using firebase::firestore::api::CollectionReference;
 using firebase::firestore::api::DocumentReference;
+using firebase::firestore::api::Optional;
 using firebase::firestore::core::ParsedSetData;
 using firebase::firestore::model::ResourcePath;
 using firebase::firestore::util::MakeCallback;
@@ -91,7 +93,7 @@ - (NSString *)collectionID {
 }
 
 - (FIRDocumentReference *_Nullable)parent {
-  absl::optional<DocumentReference> parent = self.reference.parent();
+  Optional<DocumentReference> parent = self.reference.parent();
   if (!parent) {
     return nil;
   }

Firestore/Source/API/FIRDocumentSnapshot+Internal.h

@@ -19,6 +19,7 @@
 #include <memory>
 
 #include "Firestore/core/src/api/api_fwd.h"
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/model/model_fwd.h"
 
 @class FIRFirestore;
@@ -48,7 +49,7 @@ NS_ASSUME_NONNULL_BEGIN
 /** Internal FIRDocumentSnapshot API we don't want exposed in our public header files. */
 @interface FIRDocumentSnapshot (Internal)
 
-- (const absl::optional<model::Document> &)internalDocument;
+- (const api::Optional<model::Document> &)internalDocument;
 
 @end
 

Firestore/Source/API/FIRDocumentSnapshot.mm

@@ -34,6 +34,7 @@
 #include "Firestore/core/src/api/document_reference.h"
 #include "Firestore/core/src/api/document_snapshot.h"
 #include "Firestore/core/src/api/firestore.h"
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/api/settings.h"
 #include "Firestore/core/src/model/database_id.h"
 #include "Firestore/core/src/model/document_key.h"
@@ -50,6 +51,7 @@
 using firebase::firestore::api::Firestore;
 using firebase::firestore::api::MakeFIRGeoPoint;
 using firebase::firestore::api::MakeFIRTimestamp;
+using firebase::firestore::api::Optional;
 using firebase::firestore::api::SnapshotMetadata;
 using firebase::firestore::model::DatabaseId;
 using firebase::firestore::model::Document;
@@ -126,7 +128,7 @@ - (BOOL)exists {
   return _snapshot.exists();
 }
 
-- (const absl::optional<Document> &)internalDocument {
+- (const Optional<Document> &)internalDocument {
   return _snapshot.internal_document();
 }
 
@@ -153,7 +155,7 @@ - (FIRSnapshotMetadata *)metadata {
 
 - (nullable NSDictionary<NSString *, id> *)dataWithServerTimestampBehavior:
     (FIRServerTimestampBehavior)serverTimestampBehavior {
-  absl::optional<google_firestore_v1_Value> data = _snapshot.GetValue(FieldPath::EmptyPath());
+  Optional<google_firestore_v1_Value> data = _snapshot.GetValue(FieldPath::EmptyPath());
   if (!data) return nil;
 
   FSTUserDataWriter *dataWriter =
@@ -176,7 +178,7 @@ - (nullable id)valueForField:(id)field
   } else {
     ThrowInvalidArgument("Subscript key must be an NSString or FIRFieldPath.");
   }
-  absl::optional<google_firestore_v1_Value> fieldValue = _snapshot.GetValue(fieldPath);
+  Optional<google_firestore_v1_Value> fieldValue = _snapshot.GetValue(fieldPath);
   if (!fieldValue) return nil;
   FSTUserDataWriter *dataWriter =
       [[FSTUserDataWriter alloc] initWithFirestore:_snapshot.firestore()

Firestore/core/src/api/collection_reference.cc

@@ -67,12 +67,13 @@ const std::string& CollectionReference::collection_id() const {
   return query().path().last_segment();
 }
 
-absl::optional<DocumentReference> CollectionReference::parent() const {
+Optional<DocumentReference> CollectionReference::parent() const {
   ResourcePath parent_path = query().path().PopLast();
   if (parent_path.empty()) {
-    return absl::nullopt;
+    return {};
   } else {
-    return DocumentReference(DocumentKey(std::move(parent_path)), firestore());
+    return Optional<DocumentReference>(
+        DocumentReference(DocumentKey(std::move(parent_path)), firestore()));
   }
 }
 

Firestore/core/src/api/collection_reference.h

@@ -21,9 +21,9 @@
 #include <string>
 
 #include "Firestore/core/src/api/api_fwd.h"
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/api/query_core.h"
 #include "Firestore/core/src/core/core_fwd.h"
-#include "absl/types/optional.h"
 
 namespace firebase {
 namespace firestore {
@@ -52,7 +52,7 @@ class CollectionReference : public Query {
    * For subcollections, `parent` returns the containing `DocumentReference`.
    * For root collections, nullopt is returned.
    */
-  absl::optional<DocumentReference> parent() const;
+  Optional<DocumentReference> parent() const;
 
   /**
    * A string containing the slash-separated path to this `CollectionReference`

Firestore/core/src/api/common.h

@@ -0,0 +1,130 @@
+/*
+ * 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.
+ */
+
+#ifndef FIRESTORE_CORE_SRC_API_COMMON_H_
+#define FIRESTORE_CORE_SRC_API_COMMON_H_
+
+// This file is copied from
+// https://github.com/firebase/firebase-cpp-sdk/blob/58dbf86c8b767b90f8427275388f6309617650fa/app/src/include/firebase/internal/common.h
+// in order to support optional.h
+
+// Include a STL header file, othewise _STLPORT_VERSION won't be set.
+#include <utility>
+
+// Move operators use rvalue references, which are a C++11 extension.
+// Also, Visual Studio 2010 and later actually support move operators despite
+// reporting __cplusplus to be 199711L, so explicitly check for that.
+// Also, stlport doesn't implement std::move().
+#if (__cplusplus >= 201103L || _MSC_VER >= 1600) && !defined(_STLPORT_VERSION)
+#define FIREBASE_USE_MOVE_OPERATORS
+#endif
+
+// stlport doesn't implement std::function.
+#if !defined(_STLPORT_VERSION)
+#define FIREBASE_USE_STD_FUNCTION
+#endif  // !defined(_STLPORT_VERSION)
+
+// stlport doesn't implement std::aligned_storage.
+#if defined(_STLPORT_VERSION)
+#include <cstddef>
+
+namespace firebase {
+template <std::size_t Length, std::size_t Alignment>
+struct AlignedStorage {
+  struct type {
+    alignas(Alignment) unsigned char data[Length];
+  };
+};
+}  // namespace firebase
+#define FIREBASE_ALIGNED_STORAGE ::firebase::AlignedStorage
+#else
+#include <type_traits>
+#define FIREBASE_ALIGNED_STORAGE std::aligned_storage
+#endif  // defined(_STLPORT_VERSION)
+
+// Visual Studio 2013 does not support snprintf, so use streams instead.
+#if !(defined(_MSC_VER) && _MSC_VER <= 1800)
+#define FIREBASE_USE_SNPRINTF
+#endif  // !(defined(_MSC_VER) && _MSC_VER <= 1800)
+
+#if !(defined(_MSC_VER) && _MSC_VER <= 1800)
+#define FIREBASE_USE_EXPLICIT_DEFAULT_METHODS
+#endif  // !(defined(_MSC_VER) && _MSC_VER <= 1800)
+
+#if !defined(DOXYGEN) && !defined(SWIG)
+#if !defined(_WIN32) && !defined(__CYGWIN__)
+// Prevent GCC & Clang from stripping a symbol.
+#define FIREBASE_APP_KEEP_SYMBOL __attribute__((used))
+#else
+// MSVC needs to reference a symbol directly in the application for it to be
+// kept in the final executable.  In this case, the end user's application
+// must include the appropriate Firebase header (e.g firebase/analytics.h) to
+// initialize the module.
+#define FIREBASE_APP_KEEP_SYMBOL
+#endif  // !defined(_WIN32) && !defined(__CYGWIN__)
+
+// Module initializer's name.
+//
+// This can be used to explicitly include a module initializer in an application
+// to prevent the object from being stripped by the linker.  The symbol is
+// located in the "firebase" namespace so can be referenced using:
+//
+// ::firebase::FIREBASE_APP_REGISTER_CALLBACKS_REFERENCE_NAME(name)
+//
+// Where "name" is the module name, for example "analytics".
+#define FIREBASE_APP_REGISTER_CALLBACKS_INITIALIZER_NAME(module_name) \
+  g_##module_name##_initializer
+
+// Declare a module initializer variable as a global.
+#define FIREBASE_APP_REGISTER_CALLBACKS_INITIALIZER_VARIABLE(module_name)     \
+  namespace firebase {                                                        \
+  extern void* FIREBASE_APP_REGISTER_CALLBACKS_INITIALIZER_NAME(module_name); \
+  } /* namespace firebase */
+
+// Generates code which references a module initializer.
+// For example, FIREBASE_APP_REGISTER_REFERENCE(analytics) will register the
+// module initializer for the analytics module.
+#define FIREBASE_APP_REGISTER_CALLBACKS_REFERENCE(module_name)        \
+  FIREBASE_APP_REGISTER_CALLBACKS_INITIALIZER_VARIABLE(module_name)   \
+  namespace firebase {                                                \
+  static void* module_name##_ref FIREBASE_APP_KEEP_SYMBOL =           \
+      &FIREBASE_APP_REGISTER_CALLBACKS_INITIALIZER_NAME(module_name); \
+  }     /* namespace firebase */
+#endif  //  !defined(DOXYGEN) && !defined(SWIG)
+
+#if defined(SWIG) || defined(DOXYGEN)
+// SWIG needs to ignore the FIREBASE_DEPRECATED tag.
+#define FIREBASE_DEPRECATED
+#endif  // defined(SWIG) || defined(DOXYGEN)
+
+#ifndef FIREBASE_DEPRECATED
+#ifdef __GNUC__
+#define FIREBASE_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define FIREBASE_DEPRECATED __declspec(deprecated)
+#else
+// We don't know how to mark functions as "deprecated" with this compiler.
+#define FIREBASE_DEPRECATED
+#endif
+#endif  // FIREBASE_DEPRECATED
+
+// Calculates the number of elements in an array.
+#define FIREBASE_ARRAYSIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+// Guaranteed compile time strlen.
+#define FIREBASE_STRLEN(s) (FIREBASE_ARRAYSIZE(s) - sizeof((s)[0]))
+
+#endif  // FIRESTORE_CORE_SRC_API_COMMON_H_

Firestore/core/src/api/document_reference.cc

@@ -22,6 +22,7 @@
 #include "Firestore/core/src/api/collection_reference.h"
 #include "Firestore/core/src/api/document_snapshot.h"
 #include "Firestore/core/src/api/firestore.h"
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/api/query_listener_registration.h"
 #include "Firestore/core/src/api/source.h"
 #include "Firestore/core/src/core/firestore_client.h"
@@ -219,7 +220,9 @@ std::unique_ptr<ListenerRegistration> DocumentReference::AddSnapshotListener(
                    : false;
 
       DocumentSnapshot result{
-          firestore_, key_, document,
+          firestore_, key_,
+          document ? Optional<Document>(document.value())
+                   : Optional<Document>(),
           SnapshotMetadata{has_pending_writes, snapshot.from_cache()}};
       user_listener_->OnEvent(std::move(result));
     }

Firestore/core/src/api/document_snapshot.cc

@@ -21,7 +21,6 @@
 #include "Firestore/core/src/api/document_reference.h"
 #include "Firestore/core/src/model/resource_path.h"
 #include "Firestore/core/src/util/hashing.h"
-#include "absl/types/optional.h"
 
 namespace firebase {
 namespace firestore {
@@ -36,21 +35,22 @@ DocumentSnapshot DocumentSnapshot::FromDocument(
     std::shared_ptr<Firestore> firestore,
     model::Document document,
     SnapshotMetadata metadata) {
-  return DocumentSnapshot{std::move(firestore), document->key(), document,
+  return DocumentSnapshot{std::move(firestore), document->key(),
+                          Optional<model::Document>(document),
                           std::move(metadata)};
 }
 
 DocumentSnapshot DocumentSnapshot::FromNoDocument(
     std::shared_ptr<Firestore> firestore,
     model::DocumentKey key,
     SnapshotMetadata metadata) {
-  return DocumentSnapshot{std::move(firestore), std::move(key), absl::nullopt,
-                          std::move(metadata)};
+  return DocumentSnapshot{std::move(firestore), std::move(key),
+                          Optional<model::Document>(), std::move(metadata)};
 }
 
 DocumentSnapshot::DocumentSnapshot(std::shared_ptr<Firestore> firestore,
                                    model::DocumentKey document_key,
-                                   absl::optional<Document> document,
+                                   Optional<Document> document,
                                    SnapshotMetadata metadata)
     : firestore_{std::move(firestore)},
       internal_key_{std::move(document_key)},
@@ -67,7 +67,7 @@ bool DocumentSnapshot::exists() const {
   return internal_document_.has_value();
 }
 
-const absl::optional<Document>& DocumentSnapshot::internal_document() const {
+const Optional<Document>& DocumentSnapshot::internal_document() const {
   return internal_document_;
 }
 
@@ -79,10 +79,15 @@ const std::string& DocumentSnapshot::document_id() const {
   return internal_key_.path().last_segment();
 }
 
-absl::optional<google_firestore_v1_Value> DocumentSnapshot::GetValue(
+Optional<google_firestore_v1_Value> DocumentSnapshot::GetValue(
     const FieldPath& field_path) const {
-  return internal_document_ ? (*internal_document_)->field(field_path)
-                            : absl::nullopt;
+  if (internal_document_) {
+    auto value = (*internal_document_)->field(field_path);
+    if (value) {
+      return Optional<google_firestore_v1_Value>(value.value());
+    }
+  }
+  return {};
 }
 
 bool operator==(const DocumentSnapshot& lhs, const DocumentSnapshot& rhs) {

Firestore/core/src/api/document_snapshot.h

@@ -21,12 +21,12 @@
 #include <string>
 #include <utility>
 
+#include "Firestore/core/src/api/optional.h"
 #include "Firestore/core/src/api/snapshot_metadata.h"
 #include "Firestore/core/src/core/event_listener.h"
 #include "Firestore/core/src/model/document.h"
 #include "Firestore/core/src/model/document_key.h"
 #include "Firestore/core/src/model/model_fwd.h"
-#include "absl/types/optional.h"
 
 namespace firebase {
 namespace firestore {
@@ -50,7 +50,7 @@ class DocumentSnapshot {
   size_t Hash() const;
 
   bool exists() const;
-  const absl::optional<model::Document>& internal_document() const;
+  const Optional<model::Document>& internal_document() const;
   const std::string& document_id() const;
 
   const SnapshotMetadata& metadata() const {
@@ -59,7 +59,7 @@ class DocumentSnapshot {
 
   DocumentReference CreateReference() const;
 
-  absl::optional<google_firestore_v1_Value> GetValue(
+  Optional<google_firestore_v1_Value> GetValue(
       const model::FieldPath& field_path) const;
 
   const std::shared_ptr<Firestore>& firestore() const {
@@ -76,13 +76,13 @@ class DocumentSnapshot {
 
   DocumentSnapshot(std::shared_ptr<Firestore> firestore,
                    model::DocumentKey document_key,
-                   absl::optional<model::Document> document,
+                   Optional<model::Document> document,
                    SnapshotMetadata metadata);
 
  private:
   std::shared_ptr<Firestore> firestore_;
   model::DocumentKey internal_key_;
-  absl::optional<model::Document> internal_document_;
+  Optional<model::Document> internal_document_;
   SnapshotMetadata metadata_;
 };