SERVER-16708 Make Value::compare match BSON woCompare behavior

1 files changed, 1 insertions, 48 deletions

diff --git a/src/mongo/bson/bsonelement.cpp b/src/mongo/bson/bsonelement.cpp
index 243ad2395b8..0502038e668 100644
--- a/src/mongo/bson/bsonelement.cpp
+++ b/src/mongo/bson/bsonelement.cpp
@@ -33,6 +33,7 @@
 
 #include <boost/functional/hash.hpp>
 
+#include "mongo/base/compare_numbers.h"
 #include "mongo/base/data_cursor.h"
 #include "mongo/db/jsobj.h"
 #include "mongo/util/base64.h"
@@ -819,54 +820,6 @@ namespace mongo {
         return ret.str();
     }
 
-namespace {
-    int compareInts(int lhs, int rhs) { return lhs == rhs ? 0 : lhs < rhs ? -1 : 1; }
-    int compareLongs(long long lhs, long long rhs) { return lhs == rhs ? 0 : lhs < rhs ? -1 : 1; }
-    int compareDoubles(double lhs, double rhs) {
-        if (lhs == rhs) return 0;
-        if (lhs < rhs) return -1;
-        if (lhs > rhs) return 1;
-
-        // If none of the above cases returned, lhs or rhs must be NaN.
-        if (isNaN(lhs)) return isNaN(rhs) ? 0 : -1;
-        dassert(isNaN(rhs));
-        return 1;
-    }
-
-    // This is the tricky one. Needs to support the following cases:
-    // * Doubles with a fractional component.
-    // * Longs that can't be precisely represented as a double.
-    // * Doubles outside of the range of Longs (including +/- Inf).
-    // * NaN (defined by us as less than all Longs)
-    // * Return value is always -1, 0, or 1 to ensure it is safe to negate.
-    int compareLongToDouble(long long lhs, double rhs) {
-        // All Longs are > NaN
-        if (isNaN(rhs)) return 1;
-
-        // Ints with magnitude <= 2**53 can be precisely represented as doubles.
-        // Additionally, doubles outside of this range can't have a fractional component.
-        static const long long kEndOfPreciseDoubles = 1ll << 53;
-        if (lhs <= kEndOfPreciseDoubles && lhs >= -kEndOfPreciseDoubles) {
-            return compareDoubles(lhs, rhs);
-        }
-
-        // Large magnitude doubles (including +/- Inf) are strictly > or < all Longs.
-        static const double kBoundOfLongRange = -static_cast<double>(LLONG_MIN); // positive 2**63
-        if (rhs >= kBoundOfLongRange) return -1; // Can't be represented in a Long.
-        if (rhs < -kBoundOfLongRange) return 1; // Can be represented in a Long.
-
-        // Remaining Doubles can have their integer component precisely represented as long longs.
-        // If they have a fractional component, they must be strictly > or < lhs even after
-        // truncation of the fractional component since low-magnitude lhs were handled above.
-        return compareLongs(lhs, rhs);
-    }
-
-    int compareDoubleToLong(double lhs, long long rhs) {
-        // Only implement the real logic once.
-        return -compareLongToDouble(rhs, lhs);
-    }
-} // namespace
-
     /**
      * l and r must be same canonicalType when called.
      */