Migrate CPP SDK from FieldValue to Protobuf

cmake/external/firestore.cmake

@@ -18,7 +18,7 @@ if(TARGET firestore)
   return()
 endif()
 
-set(version CocoaPods-8.4.0)
+set(version master)
 ExternalProject_Add(
   firestore
 

firestore/CMakeLists.txt

@@ -281,7 +281,7 @@ target_link_libraries(firebase_firestore
 
 if(FIRESTORE_USE_EXTERNAL_CMAKE_BUILD)
   target_link_libraries(firebase_firestore
-    PRIVATE
+    PUBLIC
       firestore_core
       absl_variant
   )

firestore/src/main/document_snapshot_main.cc

@@ -8,8 +8,10 @@
 #include "Firestore/core/src/model/database_id.h"
 #include "Firestore/core/src/model/document_key.h"
 #include "Firestore/core/src/model/field_path.h"
-#include "Firestore/core/src/model/field_value_options.h"
+#include "Firestore/core/src/model/server_timestamp_util.h"
 #include "Firestore/core/src/nanopb/byte_string.h"
+#include "Firestore/core/src/nanopb/message.h"
+#include "Firestore/core/src/nanopb/nanopb_util.h"
 #include "absl/memory/memory.h"
 #include "firestore/src/common/macros.h"
 #include "firestore/src/include/firebase/firestore.h"
@@ -20,7 +22,13 @@ namespace firebase {
 namespace firestore {
 
 using ServerTimestampBehavior = DocumentSnapshot::ServerTimestampBehavior;
-using Type = model::FieldValue::Type;
+using model::DatabaseId;
+using model::DocumentKey;
+using model::GetLocalWriteTime;
+using model::GetPreviousValue;
+using model::IsServerTimestamp;
+using nanopb::MakeString;
+using nanopb::Message;
 
 DocumentSnapshotInternal::DocumentSnapshotInternal(
     api::DocumentSnapshot&& snapshot)
@@ -55,12 +63,11 @@ bool DocumentSnapshotInternal::exists() const { return snapshot_.exists(); }
 
 MapFieldValue DocumentSnapshotInternal::GetData(
     ServerTimestampBehavior stb) const {
-  using Map = model::FieldValue::Map;
+  absl::optional<google_firestore_v1_Value> data =
+      snapshot_.GetValue(model::FieldPath::EmptyPath());
+  if (!data) return MapFieldValue{};
 
-  absl::optional<model::ObjectValue> maybe_object = snapshot_.GetData();
-  const Map& map =
-      maybe_object ? maybe_object.value().GetInternalValue() : Map{};
-  FieldValue result = ConvertObject(map, stb);
+  FieldValue result = ConvertObject(data->map_value, stb);
   SIMPLE_HARD_ASSERT(result.type() == FieldValue::Type::kMap,
                      "Expected snapshot data to parse to a map");
   return result.map_value();
@@ -73,7 +80,8 @@ FieldValue DocumentSnapshotInternal::Get(const FieldPath& field,
 
 FieldValue DocumentSnapshotInternal::GetValue(
     const model::FieldPath& path, ServerTimestampBehavior stb) const {
-  absl::optional<model::FieldValue> maybe_value = snapshot_.GetValue(path);
+  absl::optional<google_firestore_v1_Value> maybe_value =
+      snapshot_.GetValue(path);
   if (maybe_value) {
     return ConvertAnyValue(std::move(maybe_value).value(), stb);
   } else {
@@ -84,95 +92,111 @@ FieldValue DocumentSnapshotInternal::GetValue(
 // FieldValue parsing
 
 FieldValue DocumentSnapshotInternal::ConvertAnyValue(
-    const model::FieldValue& input, ServerTimestampBehavior stb) const {
-  switch (input.type()) {
-    case Type::Object:
-      return ConvertObject(input.object_value(), stb);
-    case Type::Array:
-      return ConvertArray(input.array_value(), stb);
+    const google_firestore_v1_Value& input, ServerTimestampBehavior stb) const {
+  switch (input.which_value_type) {
+    case google_firestore_v1_Value_map_value_tag:
+      return ConvertObject(input.map_value, stb);
+    case google_firestore_v1_Value_array_value_tag:
+      return ConvertArray(input.array_value, stb);
     default:
       return ConvertScalar(input, stb);
   }
 }
 
 FieldValue DocumentSnapshotInternal::ConvertObject(
-    const model::FieldValue::Map& object, ServerTimestampBehavior stb) const {
+    const google_firestore_v1_MapValue& object,
+    ServerTimestampBehavior stb) const {
   MapFieldValue result;
-  for (const auto& kv : object) {
-    result[kv.first] = ConvertAnyValue(kv.second, stb);
+  for (pb_size_t i = 0; i < object.fields_count; ++i) {
+    std::string key = MakeString(object.fields[i].key);
+    const google_firestore_v1_Value& value = object.fields[i].value;
+    result[std::move(key)] = ConvertAnyValue(value, stb);
   }
 
   return FieldValue::Map(std::move(result));
 }
 
 FieldValue DocumentSnapshotInternal::ConvertArray(
-    const model::FieldValue::Array& array, ServerTimestampBehavior stb) const {
+    const google_firestore_v1_ArrayValue& array,
+    ServerTimestampBehavior stb) const {
   std::vector<FieldValue> result;
-  for (const auto& value : array) {
-    result.push_back(ConvertAnyValue(value, stb));
+  for (pb_size_t i = 0; i < array.values_count; ++i) {
+    result.push_back(ConvertAnyValue(array.values[i], stb));
   }
 
   return FieldValue::Array(std::move(result));
 }
 
 FieldValue DocumentSnapshotInternal::ConvertScalar(
-    const model::FieldValue& scalar, ServerTimestampBehavior stb) const {
-  switch (scalar.type()) {
-    case Type::Null:
+    const google_firestore_v1_Value& scalar,
+    ServerTimestampBehavior stb) const {
+  switch (scalar.which_value_type) {
+    case google_firestore_v1_Value_map_value_tag:
+      if (IsServerTimestamp(scalar)) {
+        return ConvertServerTimestamp(scalar, stb);
+      }
       return FieldValue::Null();
-    case Type::Boolean:
-      return FieldValue::Boolean(scalar.boolean_value());
-    case Type::Integer:
-      return FieldValue::Integer(scalar.integer_value());
-    case Type::Double:
-      return FieldValue::Double(scalar.double_value());
-    case Type::String:
-      return FieldValue::String(scalar.string_value());
-    case Type::Timestamp:
-      return FieldValue::Timestamp(scalar.timestamp_value());
-    case Type::GeoPoint:
-      return FieldValue::GeoPoint(scalar.geo_point_value());
-    case Type::Blob:
-      return FieldValue::Blob(scalar.blob_value().data(),
-                              scalar.blob_value().size());
-    case Type::Reference:
-      return ConvertReference(scalar.reference_value());
-    case Type::ServerTimestamp:
-      return ConvertServerTimestamp(scalar.server_timestamp_value(), stb);
+    case google_firestore_v1_Value_boolean_value_tag:
+      return FieldValue::Boolean(scalar.boolean_value);
+    case google_firestore_v1_Value_integer_value_tag:
+      return FieldValue::Integer(scalar.integer_value);
+    case google_firestore_v1_Value_double_value_tag:
+      return FieldValue::Double(scalar.double_value);
+    case google_firestore_v1_Value_string_value_tag:
+      return FieldValue::String(MakeString(scalar.string_value));
+    case google_firestore_v1_Value_timestamp_value_tag:
+      return FieldValue::Timestamp(Timestamp(scalar.timestamp_value.seconds,
+                                             scalar.timestamp_value.nanos));
+    case google_firestore_v1_Value_geo_point_value_tag:
+      return FieldValue::GeoPoint(GeoPoint(scalar.geo_point_value.latitude,
+                                           scalar.geo_point_value.longitude));
+    case google_firestore_v1_Value_bytes_value_tag:
+      return scalar.bytes_value ? FieldValue::Blob(scalar.bytes_value->bytes,
+                                                   scalar.bytes_value->size)
+                                : FieldValue::Blob(nullptr, 0);
+    case google_firestore_v1_Value_reference_value_tag:
+      return ConvertReference(scalar);
     default: {
       // TODO(b/147444199): use string formatting.
       // HARD_FAIL("Unexpected kind of FieldValue: '%s'", scalar.type());
-      auto message = std::string("Unexpected kind of FieldValue: '") +
-                     std::to_string(static_cast<int>(scalar.type())) + "'";
+      auto message = std::string("Unexpected kind of FieldValue");
       SIMPLE_HARD_FAIL(message);
     }
   }
 }
 
 FieldValue DocumentSnapshotInternal::ConvertReference(
-    const model::FieldValue::Reference& reference) const {
-  SIMPLE_HARD_ASSERT(
-      reference.database_id() == firestore_internal()->database_id(),
-      "Converted reference is from another database");
+    const google_firestore_v1_Value& reference) const {
+  std::string ref = MakeString(reference.reference_value);
+  DatabaseId database_id = DatabaseId::FromName(ref);
+  DocumentKey key = DocumentKey::FromName(ref);
+
+  SIMPLE_HARD_ASSERT(database_id == firestore_internal()->database_id(),
+                     "Converted reference is from another database");
 
-  api::DocumentReference api_reference{reference.key(), snapshot_.firestore()};
+  api::DocumentReference api_reference{std::move(key), snapshot_.firestore()};
   return FieldValue::Reference(MakePublic(std::move(api_reference)));
 }
 
 FieldValue DocumentSnapshotInternal::ConvertServerTimestamp(
-    const model::FieldValue::ServerTimestamp& server_timestamp,
+    const google_firestore_v1_Value& server_timestamp,
     ServerTimestampBehavior stb) const {
   switch (stb) {
     case ServerTimestampBehavior::kNone:
       return FieldValue::Null();
     case ServerTimestampBehavior::kEstimate: {
-      return FieldValue::Timestamp(server_timestamp.local_write_time());
+      google_protobuf_Timestamp timestamp = GetLocalWriteTime(server_timestamp);
+      return FieldValue::Timestamp(
+          Timestamp(timestamp.seconds, timestamp.nanos));
     }
-    case ServerTimestampBehavior::kPrevious:
-      if (server_timestamp.previous_value()) {
-        return ConvertScalar(server_timestamp.previous_value().value(), stb);
+    case ServerTimestampBehavior::kPrevious: {
+      absl::optional<google_firestore_v1_Value> previous_value =
+          GetPreviousValue(server_timestamp);
+      if (previous_value) {
+        return ConvertScalar(*previous_value, stb);
       }
       return FieldValue::Null();
+    }
   }
   FIRESTORE_UNREACHABLE();
 }

firestore/src/main/document_snapshot_main.h

@@ -7,8 +7,8 @@
 #include <string>
 #include <vector>
 
+#include "Firestore/Protos/nanopb/google/firestore/v1/document.nanopb.h"
 #include "Firestore/core/src/api/document_snapshot.h"
-#include "Firestore/core/src/model/field_value.h"
 #include "firestore/src/include/firebase/firestore/document_reference.h"
 #include "firestore/src/include/firebase/firestore/document_snapshot.h"
 #include "firestore/src/include/firebase/firestore/field_value.h"
@@ -57,18 +57,17 @@ class DocumentSnapshotInternal {
 
   // Note: these are member functions only because access to `api::Firestore`
   // is needed to create a `DocumentReferenceInternal`.
-  FieldValue ConvertAnyValue(const model::FieldValue& input,
+  FieldValue ConvertAnyValue(const google_firestore_v1_Value& input,
                              ServerTimestampBehavior stb) const;
-  FieldValue ConvertObject(const model::FieldValue::Map& object,
+  FieldValue ConvertObject(const google_firestore_v1_MapValue& object,
                            ServerTimestampBehavior stb) const;
-  FieldValue ConvertArray(const model::FieldValue::Array& array,
+  FieldValue ConvertArray(const google_firestore_v1_ArrayValue& array,
                           ServerTimestampBehavior stb) const;
-  FieldValue ConvertReference(
-      const model::FieldValue::Reference& reference) const;
+  FieldValue ConvertReference(const google_firestore_v1_Value& reference) const;
   FieldValue ConvertServerTimestamp(
-      const model::FieldValue::ServerTimestamp& server_timestamp,
+      const google_firestore_v1_Value& server_timestamp,
       ServerTimestampBehavior stb) const;
-  FieldValue ConvertScalar(const model::FieldValue& scalar,
+  FieldValue ConvertScalar(const google_firestore_v1_Value& scalar,
                            ServerTimestampBehavior stb) const;
 
   api::DocumentSnapshot snapshot_;