Flesh out C++ FieldValue (#2990)

* Add GeoPoint::ToString

* Add FieldValue::ToString

* Fix description of FIRTimestamp

* ServerTimestamp's previous_value is a FieldValue

* Implement FieldValue::Hash

Author: wilhuff

Firestore/Source/API/FIRTimestamp.m

@@ -110,7 +110,7 @@ - (NSUInteger)hash {
 }
 
 - (NSString *)description {
-  return [NSString stringWithFormat:@"FIRTimestamp: seconds=%lld nanoseconds=%d>", self.seconds,
+  return [NSString stringWithFormat:@"<FIRTimestamp: seconds=%lld nanoseconds=%d>", self.seconds,
                                     self.nanoseconds];
 }
 

Firestore/core/include/firebase/firestore/geo_point.h

@@ -17,6 +17,9 @@
 #ifndef FIRESTORE_CORE_INCLUDE_FIREBASE_FIRESTORE_GEO_POINT_H_
 #define FIRESTORE_CORE_INCLUDE_FIREBASE_FIRESTORE_GEO_POINT_H_
 
+#include <iosfwd>
+#include <string>
+
 namespace firebase {
 namespace firestore {
 
@@ -55,6 +58,16 @@ class GeoPoint {
     return longitude_;
   }
 
+  /**
+   * Returns a string representation of this `GeoPoint` for logging/debugging
+   * purposes.
+   *
+   * Note: the exact string representation is unspecified and subject to change;
+   * don't rely on the format of the string.
+   */
+  std::string ToString() const;
+  friend std::ostream& operator<<(std::ostream& out, const GeoPoint& geo_point);
+
  private:
   double latitude_;
   double longitude_;

Firestore/core/src/firebase/firestore/geo_point.cc

@@ -17,8 +17,10 @@
 #include "Firestore/core/include/firebase/firestore/geo_point.h"
 
 #include <cmath>
+#include <iostream>
 
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
+#include "absl/strings/str_cat.h"
 
 namespace firebase {
 namespace firestore {
@@ -34,6 +36,15 @@ GeoPoint::GeoPoint(double latitude, double longitude)
               "Latitude must be in the range of [-180, 180]");
 }
 
+std::string GeoPoint::ToString() const {
+  return absl::StrCat("GeoPoint(latitude=", latitude_,
+                      ", longitude=", longitude_, ")");
+}
+
+std::ostream& operator<<(std::ostream& out, const GeoPoint& geo_point) {
+  return out << geo_point.ToString();
+}
+
 bool operator<(const GeoPoint& lhs, const GeoPoint& rhs) {
   if (lhs.latitude() == rhs.latitude()) {
     return lhs.longitude() < rhs.longitude();

Firestore/core/src/firebase/firestore/model/field_value.cc

@@ -18,6 +18,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <iostream>
 #include <memory>
 #include <new>
 #include <utility>
@@ -27,7 +28,9 @@
 #include "Firestore/core/src/firebase/firestore/util/comparison.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 #include "Firestore/core/src/firebase/firestore/util/hashing.h"
+#include "Firestore/core/src/firebase/firestore/util/to_string.h"
 #include "absl/memory/memory.h"
+#include "absl/strings/escaping.h"
 
 namespace firebase {
 namespace firestore {
@@ -38,6 +41,37 @@ using Type = FieldValue::Type;
 using util::Compare;
 using util::ComparisonResult;
 
+std::string ServerTimestamp::ToString() const {
+  std::string time = local_write_time.ToString();
+  return absl::StrCat("ServerTimestamp(local_write_time=", time, ")");
+}
+
+std::ostream& operator<<(std::ostream& os, const ServerTimestamp& value) {
+  return os << value.ToString();
+}
+
+size_t ServerTimestamp::Hash() const {
+  size_t result =
+      util::Hash(local_write_time.seconds(), local_write_time.nanoseconds());
+
+  if (previous_value) {
+    result = util::Hash(result, *previous_value);
+  }
+  return result;
+}
+
+std::string ReferenceValue::ToString() const {
+  return absl::StrCat("Reference(key=", reference.ToString(), ")");
+}
+
+std::ostream& operator<<(std::ostream& os, const ReferenceValue& value) {
+  return os << value.ToString();
+}
+
+size_t ReferenceValue::Hash() const {
+  return util::Hash(reference, *database_id);
+}
+
 FieldValue::FieldValue(const FieldValue& value) {
   *this = value;
 }
@@ -97,8 +131,6 @@ FieldValue& FieldValue::operator=(const FieldValue& value) {
       std::swap(*object_value_, tmp);
       break;
     }
-    default:
-      HARD_FAIL("Unsupported type %s", value.type());
   }
   return *this;
 }
@@ -210,6 +242,14 @@ ObjectValue ObjectValue::SetChild(const std::string& child_name,
   return ObjectValue::FromMap(fv_.object_value_->insert(child_name, value));
 }
 
+absl::string_view FieldValue::blob_value_as_string_view() const {
+  const std::vector<uint8_t>& blob = blob_value();
+
+  // string_view accepts const char*, but treats it internally as unsigned.
+  auto data = reinterpret_cast<const char*>(blob.data());
+  return absl::string_view(data, blob.size());
+}
+
 FieldValue FieldValue::Null() {
   return FieldValue();
 }
@@ -256,7 +296,7 @@ FieldValue FieldValue::FromTimestamp(const Timestamp& value) {
 }
 
 FieldValue FieldValue::FromServerTimestamp(const Timestamp& local_write_time,
-                                           const Timestamp& previous_value) {
+                                           const FieldValue& previous_value) {
   FieldValue result;
   result.SwitchTo(Type::ServerTimestamp);
   result.server_timestamp_value_->local_write_time = local_write_time;
@@ -348,29 +388,43 @@ FieldValue FieldValue::FromMap(FieldValue::Map&& value) {
   return result;
 }
 
+static size_t HashObject(const FieldValue::Map& object) {
+  size_t result = 0;
+  for (auto&& entry : object) {
+    result = util::Hash(result, entry.first, entry.second);
+  }
+  return result;
+}
+
 size_t FieldValue::Hash() const {
   switch (type()) {
     case FieldValue::Type::Null:
-      HARD_FAIL("TODO(rsgowman): Implement");
-
+      // std::hash is not defined for nullptr_t.
+      return util::Hash(static_cast<void*>(nullptr));
     case FieldValue::Type::Boolean:
-      return util::Hash(boolean_value());
-
+      return util::Hash(boolean_value_);
     case FieldValue::Type::Integer:
+      return util::Hash(integer_value_);
     case FieldValue::Type::Double:
+      return util::DoubleBitwiseHash(double_value_);
     case FieldValue::Type::Timestamp:
+      return util::Hash(timestamp_value_->seconds(),
+                        timestamp_value_->nanoseconds());
     case FieldValue::Type::ServerTimestamp:
-      HARD_FAIL("TODO(rsgowman): Implement");
-
+      return util::Hash(*server_timestamp_value_);
     case FieldValue::Type::String:
-      return util::Hash(string_value());
-
+      return util::Hash(*string_value_);
     case FieldValue::Type::Blob:
+      return util::Hash(*blob_value_);
     case FieldValue::Type::Reference:
+      return util::Hash(*reference_value_);
     case FieldValue::Type::GeoPoint:
+      return util::Hash(geo_point_value_->latitude(),
+                        geo_point_value_->longitude());
     case FieldValue::Type::Array:
+      return util::Hash(*array_value_);
     case FieldValue::Type::Object:
-      HARD_FAIL("TODO(rsgowman): Implement");
+      return HashObject(*object_value_);
   }
 
   UNREACHABLE();
@@ -430,12 +484,45 @@ ComparisonResult FieldValue::CompareTo(const FieldValue& rhs) const {
       return CompareContainer(*array_value_, *rhs.array_value_);
     case Type::Object:
       return CompareContainer(*object_value_, *rhs.object_value_);
-    default:
-      HARD_FAIL("Unsupported type %s", type());
-      // return false if assertion does not abort the program. We will say
-      // each unsupported type takes only one value thus everything is equal.
-      return ComparisonResult::Same;
   }
+
+  UNREACHABLE();
+}
+
+std::string FieldValue::ToString() const {
+  switch (tag_) {
+    case Type::Null:
+      return util::ToString(nullptr);
+    case Type::Boolean:
+      return util::ToString(boolean_value_);
+    case Type::Integer:
+      return util::ToString(integer_value_);
+    case Type::Double:
+      return util::ToString(double_value_);
+    case Type::Timestamp:
+      return util::ToString(*timestamp_value_);
+    case Type::ServerTimestamp:
+      return util::ToString(*server_timestamp_value_);
+    case Type::String:
+      return util::ToString(*string_value_);
+    case Type::Blob:
+      return absl::StrCat(
+          "<", absl::BytesToHexString(blob_value_as_string_view()), ">");
+    case Type::Reference:
+      return util::ToString(*reference_value_);
+    case Type::GeoPoint:
+      return util::ToString(*geo_point_value_);
+    case Type::Array:
+      return util::ToString(*array_value_);
+    case Type::Object:
+      return util::ToString(*object_value_);
+  }
+
+  UNREACHABLE();
+}
+
+std::ostream& operator<<(std::ostream& os, const FieldValue& value) {
+  return os << value.ToString();
 }
 
 void FieldValue::SwitchTo(const Type type) {
@@ -522,6 +609,18 @@ ComparisonResult ObjectValue::CompareTo(const ObjectValue& rhs) const {
   return fv_.CompareTo(rhs.fv_);
 }
 
+std::string ObjectValue::ToString() const {
+  return fv_.ToString();
+}
+
+std::ostream& operator<<(std::ostream& os, const ObjectValue& value) {
+  return os << value.ToString();
+}
+
+size_t ObjectValue::Hash() const {
+  return fv_.Hash();
+}
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/src/firebase/firestore/model/field_value.h

@@ -18,6 +18,7 @@
 #define FIRESTORE_CORE_SRC_FIREBASE_FIRESTORE_MODEL_FIELD_VALUE_H_
 
 #include <cstdint>
+#include <iosfwd>
 #include <memory>
 #include <string>
 #include <utility>
@@ -40,16 +41,8 @@ namespace firebase {
 namespace firestore {
 namespace model {
 
-struct ServerTimestamp {
-  Timestamp local_write_time;
-  absl::optional<Timestamp> previous_value;
-};
-
-struct ReferenceValue {
-  DocumentKey reference;
-  // Does not own the DatabaseId instance.
-  const DatabaseId* database_id;
-};
+struct ReferenceValue;
+struct ServerTimestamp;
 
 /**
  * tagged-union class representing an immutable data value as stored in
@@ -153,6 +146,12 @@ class FieldValue : public util::Comparable<FieldValue> {
     return *blob_value_;
   }
 
+  /**
+   * Returns a string_view of the blob_value(). This can be useful when using
+   * abseil bytewise APIs that accept this type.
+   */
+  absl::string_view blob_value_as_string_view() const;
+
   const GeoPoint& geo_point_value() const {
     HARD_ASSERT(tag_ == Type::GeoPoint);
     return *geo_point_value_;
@@ -174,7 +173,7 @@ class FieldValue : public util::Comparable<FieldValue> {
   static FieldValue FromDouble(double value);
   static FieldValue FromTimestamp(const Timestamp& value);
   static FieldValue FromServerTimestamp(const Timestamp& local_write_time,
-                                        const Timestamp& previous_value);
+                                        const FieldValue& previous_value);
   static FieldValue FromServerTimestamp(const Timestamp& local_write_time);
   static FieldValue FromString(const char* value);
   static FieldValue FromString(const std::string& value);
@@ -194,6 +193,9 @@ class FieldValue : public util::Comparable<FieldValue> {
 
   util::ComparisonResult CompareTo(const FieldValue& rhs) const;
 
+  std::string ToString() const;
+  friend std::ostream& operator<<(std::ostream& os, const FieldValue& value);
+
  private:
   friend class ObjectValue;
 
@@ -277,13 +279,41 @@ class ObjectValue : public util::Comparable<ObjectValue> {
 
   util::ComparisonResult CompareTo(const ObjectValue& rhs) const;
 
+  std::string ToString() const;
+  friend std::ostream& operator<<(std::ostream& os, const ObjectValue& value);
+
+  size_t Hash() const;
+
  private:
   ObjectValue SetChild(const std::string& child_name,
                        const FieldValue& value) const;
 
   FieldValue fv_;
 };
 
+struct ServerTimestamp {
+  Timestamp local_write_time;
+  absl::optional<FieldValue> previous_value;
+
+  std::string ToString() const;
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const ServerTimestamp& value);
+
+  size_t Hash() const;
+};
+
+struct ReferenceValue {
+  DocumentKey reference;
+  // Does not own the DatabaseId instance.
+  const DatabaseId* database_id = nullptr;
+
+  std::string ToString() const;
+  friend std::ostream& operator<<(std::ostream& os,
+                                  const ReferenceValue& value);
+
+  size_t Hash() const;
+};
+
 }  // namespace model
 }  // namespace firestore
 }  // namespace firebase