1 files changed, 77 insertions, 78 deletions
diff --git a/src/mongo/db/hasher.h b/src/mongo/db/hasher.h
index e5bbb39d116..fd634b69ba5 100644
--- a/src/mongo/db/hasher.h
+++ b/src/mongo/db/hasher.h
@@ -41,82 +41,81 @@
 
 namespace mongo {
 
-    typedef int HashSeed;
-    typedef unsigned char HashDigest[16];
-
-    class Hasher {
-        MONGO_DISALLOW_COPYING(Hasher);
-    public:
-
-        explicit Hasher( HashSeed seed );
-        ~Hasher() { };
-
-        //pointer to next part of input key, length in bytes to read
-        void addData( const void * keyData , size_t numBytes );
-
-        //finish computing the hash, put the result in the digest
-        //only call this once per Hasher
-        void finish( HashDigest out );
-
-    private:
-        md5_state_t _md5State;
-        HashSeed _seed;
-    };
-
-    class HasherFactory {
-        MONGO_DISALLOW_COPYING(HasherFactory);
-    public:
-        /* Eventually this may be a more sophisticated factory
-         * for creating other hashers, but for now use MD5.
-         */
-        static Hasher* createHasher( HashSeed seed ) {
-            return new Hasher( seed );
-        }
-
-    private:
-        HasherFactory();
-    };
-
-    class BSONElementHasher {
-        MONGO_DISALLOW_COPYING(BSONElementHasher);
-    public:
-
-        /* The hash function we use can be given a seed, to effectively randomize it
-         * by choosing from among a family of hash functions. When it is not specified,
-         * use this.
-         *
-         * WARNING: do not change the hash see value. Hash-based sharding clusters will
-         * expect that value to be zero.
-         */
-        static const int DEFAULT_HASH_SEED = 0;
-
-        /* This computes a 64-bit hash of the value part of BSONElement "e",
-         * preceded by the seed "seed".  Squashes element (and any sub-elements)
-         * of the same canonical type, so hash({a:{b:4}}) will be the same
-         * as hash({a:{b:4.1}}). In particular, this squashes doubles to 64-bit long
-         * ints via truncation, so floating point values round towards 0 to the
-         * nearest int representable as a 64-bit long.
-         *
-         * This function is used in the computation of hashed indexes
-         * and hashed shard keys, and thus should not be changed unless
-         * the associated "getKeys" and "makeSingleKey" method in the
-         * hashindex type is changed accordingly.
-         */
-        static long long int hash64( const BSONElement& e , HashSeed seed );
-
-        /* This incrementally computes the hash of BSONElement "e"
-         * using hash function "h".  If "includeFieldName" is true,
-         * then the name of the field is hashed in between the type of
-         * the element and the element value.  The hash function "h"
-         * is applied recursively to any sub-elements (arrays/sub-documents),
-         * squashing elements of the same canonical type.
-         * Used as a helper for hash64 above.
-         */
-        static void recursiveHash( Hasher* h , const BSONElement& e , bool includeFieldName );
-
-    private:
-        BSONElementHasher();
-
-    };
-
+typedef int HashSeed;
+typedef unsigned char HashDigest[16];
+
+class Hasher {
+    MONGO_DISALLOW_COPYING(Hasher);
+
+public:
+    explicit Hasher(HashSeed seed);
+    ~Hasher(){};
+
+    // pointer to next part of input key, length in bytes to read
+    void addData(const void* keyData, size_t numBytes);
+
+    // finish computing the hash, put the result in the digest
+    // only call this once per Hasher
+    void finish(HashDigest out);
+
+private:
+    md5_state_t _md5State;
+    HashSeed _seed;
+};
+
+class HasherFactory {
+    MONGO_DISALLOW_COPYING(HasherFactory);
+
+public:
+    /* Eventually this may be a more sophisticated factory
+     * for creating other hashers, but for now use MD5.
+     */
+    static Hasher* createHasher(HashSeed seed) {
+        return new Hasher(seed);
+    }
+
+private:
+    HasherFactory();
+};
+
+class BSONElementHasher {
+    MONGO_DISALLOW_COPYING(BSONElementHasher);
+
+public:
+    /* The hash function we use can be given a seed, to effectively randomize it
+     * by choosing from among a family of hash functions. When it is not specified,
+     * use this.
+     *
+     * WARNING: do not change the hash see value. Hash-based sharding clusters will
+     * expect that value to be zero.
+     */
+    static const int DEFAULT_HASH_SEED = 0;
+
+    /* This computes a 64-bit hash of the value part of BSONElement "e",
+     * preceded by the seed "seed".  Squashes element (and any sub-elements)
+     * of the same canonical type, so hash({a:{b:4}}) will be the same
+     * as hash({a:{b:4.1}}). In particular, this squashes doubles to 64-bit long
+     * ints via truncation, so floating point values round towards 0 to the
+     * nearest int representable as a 64-bit long.
+     *
+     * This function is used in the computation of hashed indexes
+     * and hashed shard keys, and thus should not be changed unless
+     * the associated "getKeys" and "makeSingleKey" method in the
+     * hashindex type is changed accordingly.
+     */
+    static long long int hash64(const BSONElement& e, HashSeed seed);
+
+    /* This incrementally computes the hash of BSONElement "e"
+     * using hash function "h".  If "includeFieldName" is true,
+     * then the name of the field is hashed in between the type of
+     * the element and the element value.  The hash function "h"
+     * is applied recursively to any sub-elements (arrays/sub-documents),
+     * squashing elements of the same canonical type.
+     * Used as a helper for hash64 above.
+     */
+    static void recursiveHash(Hasher* h, const BSONElement& e, bool includeFieldName);
+
+private:
+    BSONElementHasher();
+};
 }