Implement comparison logic.

Author: ehsannas

Firestore/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Unreleased
 - [feature] Adds support for the following new types: `MinKey`, `MaxKey`, `RegexValue`,
-  `Int32Value`, `BSONObjectId`, `BSONTimestamp`, and `BSONBinaryData`. (#14800)
+  `Int32Value`, `Decimal128Value`, `BSONObjectId`, `BSONTimestamp`, and `BSONBinaryData`. (#14800)
 
 # 11.12.0
 - [fixed] Fixed the `null` value handling in `isNotEqualTo` and `notIn` filters.

Firestore/Source/API/FIRDecimal128Value.mm

@@ -16,6 +16,12 @@
 
 #include "Firestore/Source/Public/FirebaseFirestore/FIRDecimal128Value.h"
 
+#include "Firestore/core/src/util/quadruple.h"
+#include "Firestore/core/src/util/string_apple.h"
+
+using firebase::firestore::util::Quadruple;
+using firebase::firestore::util::MakeString;
+
 @implementation FIRDecimal128Value
 
 - (instancetype)initWithValue:(NSString *)value {
@@ -36,10 +42,12 @@ - (BOOL)isEqual:(nullable id)object {
   }
 
   FIRDecimal128Value *other = (FIRDecimal128Value *)object;
-  //
-  // TODO(ehsann): Convert to Quadruple and compare quadruples.
-  //
-  return [self.value isEqualToString:other.value];
+
+  Quadruple self_quadruple = Quadruple();
+  Quadruple other_quadruple = Quadruple();
+  self_quadruple.Parse(MakeString(self.value));
+  other_quadruple.Parse(MakeString(other.value));
+  return self_quadruple.Compare(other_quadruple) == 0;
 }
 
 - (id)copyWithZone:(__unused NSZone *_Nullable)zone {

Firestore/core/src/model/value_util.cc

@@ -30,6 +30,7 @@
 #include "Firestore/core/src/nanopb/nanopb_util.h"
 #include "Firestore/core/src/util/comparison.h"
 #include "Firestore/core/src/util/hard_assert.h"
+#include "Firestore/core/src/util/quadruple.h"
 #include "absl/strings/escaping.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
@@ -41,6 +42,7 @@ namespace model {
 
 using nanopb::Message;
 using util::ComparisonResult;
+using util::Quadruple;
 
 /** The smallest reference value. */
 pb_bytes_array_s* kMinimumReferenceValue =
@@ -259,12 +261,46 @@ void SortFields(google_firestore_v1_Value& value) {
   }
 }
 
+Quadruple ConvertNumericValueToQuadruple(const google_firestore_v1_Value& value) {
+  if (value.which_value_type == google_firestore_v1_Value_double_value_tag) {
+    return Quadruple(value.double_value);
+  } else if (value.which_value_type == google_firestore_v1_Value_integer_value_tag) {
+    return Quadruple(value.integer_value);
+  } else if (IsInt32Value(value)) {
+    return Quadruple(value.map_value.fields[0].value.integer_value);
+  } else if (IsDecimal128Value(value)) {
+    Quadruple result;
+    result.Parse(nanopb::MakeString(value.map_value.fields[0].value.string_value));
+    return result;
+  }
+
+  HARD_FAIL("ConvertNumericValueToQuadruple was called with non-numeric value: %s", value.ToString());
+}
+
 ComparisonResult Compare128BitNumbers(const google_firestore_v1_Value& left,
                                       const google_firestore_v1_Value& right) {
-  // TODO: implement.
-  (void)left;
-  (void)right;
-  return ComparisonResult::Same;
+  Quadruple lhs = ConvertNumericValueToQuadruple(left);
+  Quadruple rhs = ConvertNumericValueToQuadruple(right);
+  if (lhs.is_nan()) {
+    return rhs.is_nan() ? ComparisonResult::Same : ComparisonResult::Ascending;
+  } else if (rhs.is_nan()) {
+    // rhs is NaN, but lhs is not.
+    return ComparisonResult::Descending;
+  }
+
+  // Override negative zero values to positive zero.
+  Quadruple negative_zero = Quadruple();
+  negative_zero.Parse("-0");
+  if (lhs.Compare(negative_zero) == 0) {
+    lhs = Quadruple();
+  }
+  if (rhs.Compare(negative_zero) == 0) {
+    rhs = Quadruple();
+  }
+
+  // Since `Compare` returns `-1`, `0`, and `1` with the same semantics as the
+  // `ComparisonResult` enum, we can safely cast it.
+  return static_cast<ComparisonResult>(lhs.Compare(rhs));
 }
 
 ComparisonResult CompareNumbers(const google_firestore_v1_Value& left,

Firestore/core/src/util/quadruple_builder.cc

@@ -179,11 +179,11 @@ bool is_gte(int64_t s, uint64_t u) {
       mantissa[i] = 0;
     }
     // Skip leading zeroes
-    uint32_t firstDigit = 0;
-    while (firstDigit < (digits).size() && digits[firstDigit] == 0) {
+    int32_t firstDigit = 0;
+    while (firstDigit < static_cast<int32_t>(digits.size()) && digits[firstDigit] == 0) {
       firstDigit += 1;
     }
-    if (firstDigit == (digits).size()) {
+    if (firstDigit == static_cast<int32_t>(digits.size())) {
       return 0; // All zeroes
     }
     int32_t expCorr = -firstDigit;
@@ -200,7 +200,7 @@ bool is_gte(int64_t s, uint64_t u) {
       digits = truncated;
       firstDigit = 0;
     }
-    for (uint32_t i = ((digits).size()) - 1; i >= (firstDigit); i--) { // digits, starting from the last
+    for (int32_t i = static_cast<int32_t>((digits).size()) - 1; i >= (firstDigit); i--) { // digits, starting from the last
       mantissa[0] |= (static_cast<uint64_t>(digits[i])) << 32;
       divBuffBy10(mantissa);
     }
@@ -223,7 +223,7 @@ bool is_gte(int64_t s, uint64_t u) {
   // @param buffer the buffer to check
   // @return {@code true} if the buffer is empty, {@code false} otherwise
   template<std::size_t N> bool QuadrupleBuilder::isEmpty(std::array<uint64_t,N>& buffer) {
-    for (uint32_t i = (0); i < ((buffer).size()); i++) {
+    for (size_t i = (0); i < ((buffer).size()); i++) {
       if (buffer[i] != 0) {
         return false;
       }
@@ -340,7 +340,7 @@ bool is_gte(int64_t s, uint64_t u) {
   }
   // Copies from into to.
   template<std::size_t N> void QuadrupleBuilder::array_copy(std::array<uint64_t,N>& source,std::array<uint64_t,4>& dest) {
-    for (uint32_t i = (0); i < ((dest).size()); i++) {
+    for (size_t i = (0); i < ((dest).size()); i++) {
       dest[i] = source[i];
     }
   }
@@ -365,7 +365,7 @@ bool is_gte(int64_t s, uint64_t u) {
   // @param factor2 an array of longs containing factor 2 as packed quasidecimal
   // @param result an array of 12 longs filled with the product of mantissas
   void QuadrupleBuilder::multPacked3x64_simply(std::array<uint64_t,4>& factor1,std::array<uint64_t,4>& factor2,std::array<uint64_t,12>& result) {
-    for (uint32_t i = (0); i < ((result).size()); i++) {
+    for (size_t i = (0); i < ((result).size()); i++) {
       result[i] = 0;
     }
     // TODO2 19.01.16 21:23:06 for the next version -- rebuild the table of powers to make the
@@ -413,7 +413,7 @@ bool is_gte(int64_t s, uint64_t u) {
     // Multiplying a 128-bit number by another 192-bit number,
     // as well as multiplying of two 192-bit numbers,
     // can never produce 320 (or 384 bits, respectively) of 0x1999_9999L, 0x9999_9999L,
-    for (uint32_t i = (1); i < ((buffer).size()); i++) {
+    for (size_t i = (1); i < ((buffer).size()); i++) {
       // so this loop can't be covered entirely
       if (buffer[i] < 0x99999999LL) {
         return true;
@@ -431,7 +431,7 @@ bool is_gte(int64_t s, uint64_t u) {
   // @param factor2 an array of 4 longs containing packed quasidecimal power of two
   // @param product a buffer of at least 12 longs to hold the product
   void QuadrupleBuilder::multUnpacked6x32byPacked(std::array<uint64_t,6>& factor1,std::array<uint64_t,4>& factor2,std::array<uint64_t,12>& product) {
-    for (uint32_t i = (0); i < ((product).size()); i++) {
+    for (size_t i = (0); i < ((product).size()); i++) {
       product[i] = 0;
     }
     std::array<uint64_t, 6>& unpacked2 = this->buffer6x32B;
@@ -572,4 +572,4 @@ bool is_gte(int64_t s, uint64_t u) {
   }
 }  // namespace util
 }  // namespace firestore
-}  // namespace firebase
+}  // namespace firebase