1 files changed, 0 insertions, 175 deletions
diff --git a/Firestore/Source/Util/FSTComparison.m b/Firestore/Source/Util/FSTComparison.m
deleted file mode 100644
index 9c5c3eb..0000000
--- a/Firestore/Source/Util/FSTComparison.m
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright 2017 Google
- *
- * 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.
- */
-
-#import "Firestore/Source/Util/FSTComparison.h"
-
-NS_ASSUME_NONNULL_BEGIN
-
-union DoubleBits {
-  double d;
-  uint64_t bits;
-};
-
-const NSComparator FSTNumberComparator = ^NSComparisonResult(NSNumber *left, NSNumber *right) {
-  return [left compare:right];
-};
-
-const NSComparator FSTStringComparator = ^NSComparisonResult(NSString *left, NSString *right) {
-  return FSTCompareStrings(left, right);
-};
-
-NSComparisonResult FSTCompareStrings(NSString *left, NSString *right) {
-  // NOTE: NSLiteralSearch is necessary to compare the raw character codes. By default,
-  // precomposed characters are considered equivalent to their decomposed equivalents.
-  return [left compare:right options:NSLiteralSearch];
-}
-
-NSComparisonResult FSTCompareBools(BOOL left, BOOL right) {
-  if (!left) {
-    return right ? NSOrderedAscending : NSOrderedSame;
-  } else {
-    return right ? NSOrderedSame : NSOrderedDescending;
-  }
-}
-
-NSComparisonResult FSTCompareInts(int left, int right) {
-  if (left > right) {
-    return NSOrderedDescending;
-  }
-  if (right > left) {
-    return NSOrderedAscending;
-  }
-  return NSOrderedSame;
-}
-
-NSComparisonResult FSTCompareInt32s(int32_t left, int32_t right) {
-  if (left > right) {
-    return NSOrderedDescending;
-  }
-  if (right > left) {
-    return NSOrderedAscending;
-  }
-  return NSOrderedSame;
-}
-
-NSComparisonResult FSTCompareInt64s(int64_t left, int64_t right) {
-  if (left > right) {
-    return NSOrderedDescending;
-  }
-  if (right > left) {
-    return NSOrderedAscending;
-  }
-  return NSOrderedSame;
-}
-
-NSComparisonResult FSTCompareUIntegers(NSUInteger left, NSUInteger right) {
-  if (left > right) {
-    return NSOrderedDescending;
-  }
-  if (right > left) {
-    return NSOrderedAscending;
-  }
-  return NSOrderedSame;
-}
-
-NSComparisonResult FSTCompareDoubles(double left, double right) {
-  // NaN sorts equal to itself and before any other number.
-  if (left < right) {
-    return NSOrderedAscending;
-  } else if (left > right) {
-    return NSOrderedDescending;
-  } else if (left == right) {
-    return NSOrderedSame;
-  } else {
-    // One or both left and right is NaN.
-    if (isnan(left)) {
-      return isnan(right) ? NSOrderedSame : NSOrderedAscending;
-    } else {
-      return NSOrderedDescending;
-    }
-  }
-}
-
-static const double LONG_MIN_VALUE_AS_DOUBLE = (double)LLONG_MIN;
-static const double LONG_MAX_VALUE_AS_DOUBLE = (double)LLONG_MAX;
-
-NSComparisonResult FSTCompareMixed(double doubleValue, int64_t longValue) {
-  // LLONG_MIN has an exact representation as double, so to check for a value outside the range
-  // representable by long, we have to check for strictly less than LLONG_MIN. Note that this also
-  // handles negative infinity.
-  if (doubleValue < LONG_MIN_VALUE_AS_DOUBLE) {
-    return NSOrderedAscending;
-  }
-
-  // LLONG_MAX has no exact representation as double (casting as we've done makes 2^63, which is
-  // larger than LLONG_MAX), so consider any value greater than or equal to the threshold to be out
-  // of range. This also handles positive infinity.
-  if (doubleValue >= LONG_MAX_VALUE_AS_DOUBLE) {
-    return NSOrderedDescending;
-  }
-
-  // In Firestore NaN is defined to compare before all other numbers.
-  if (isnan(doubleValue)) {
-    return NSOrderedAscending;
-  }
-
-  int64_t doubleAsLong = (int64_t)doubleValue;
-  NSComparisonResult cmp = FSTCompareInt64s(doubleAsLong, longValue);
-  if (cmp != NSOrderedSame) {
-    return cmp;
-  }
-
-  // At this point the long representations are equal but this could be due to rounding.
-  double longAsDouble = (double)longValue;
-  return FSTCompareDoubles(doubleValue, longAsDouble);
-}
-
-NSComparisonResult FSTCompareBytes(NSData *left, NSData *right) {
-  NSUInteger minLength = MIN(left.length, right.length);
-  int result = memcmp(left.bytes, right.bytes, minLength);
-  if (result < 0) {
-    return NSOrderedAscending;
-  } else if (result > 0) {
-    return NSOrderedDescending;
-  } else if (left.length < right.length) {
-    return NSOrderedAscending;
-  } else if (left.length > right.length) {
-    return NSOrderedDescending;
-  } else {
-    return NSOrderedSame;
-  }
-}
-
-/** Helper to normalize a double and then return the raw bits as a uint64_t. */
-uint64_t FSTDoubleBits(double d) {
-  if (isnan(d)) {
-    d = NAN;
-  }
-  union DoubleBits converter = {.d = d};
-  return converter.bits;
-}
-
-BOOL FSTDoubleBitwiseEquals(double left, double right) {
-  return FSTDoubleBits(left) == FSTDoubleBits(right);
-}
-
-NSUInteger FSTDoubleBitwiseHash(double d) {
-  uint64_t bits = FSTDoubleBits(d);
-  // Note that x ^ (x >> 32) works fine for both 32 and 64 bit definitions of NSUInteger
-  return (((NSUInteger)bits) ^ (NSUInteger)(bits >> 32));
-}
-
-NS_ASSUME_NONNULL_END