Changes based on review comments, including:

* replace murmurhash with std::unordered_map
* plug potential leak from unique_ptr release
* replacing some sections with cleaner code

CMakeLists.txt

@@ -536,7 +536,6 @@ endif (CMAKE_CXX_COMPILER_ID STREQUAL GNU OR CMAKE_CXX_COMPILER_ID STREQUAL Clan
 add_subdirectory (extern/osg-ffmpeg-videoplayer)
 add_subdirectory (extern/oics)
 add_subdirectory (extern/Base64)
-add_subdirectory (extern/murmurhash)
 if (BUILD_OPENCS)
     add_subdirectory (extern/osgQt)
 endif()

apps/opencs/CMakeLists.txt

@@ -226,7 +226,6 @@ target_link_libraries(openmw-cs
     ${OSGTEXT_LIBRARIES}
     ${OSG_LIBRARIES}
     ${EXTERN_OSGQT_LIBRARY}
-    ${MURMURHASH_LIBRARIES}
     ${Boost_SYSTEM_LIBRARY}
     ${Boost_FILESYSTEM_LIBRARY}
     ${Boost_PROGRAM_OPTIONS_LIBRARY}

apps/opencs/model/world/infocollection.cpp

@@ -99,8 +99,8 @@ void CSMWorld::InfoCollection::load (const Info& record, bool base)
 int CSMWorld::InfoCollection::getInfoIndex (const std::string& id, const std::string& topic) const
 {
     // find the topic first
-    std::map<StringHash, std::vector<std::pair<std::string, int> > >::const_iterator iter
+    std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator iter
-        = mInfoIndex.find(StringHash(std::make_shared<std::string>(Misc::StringUtils::lowerCase(topic))));
+        = mInfoIndex.find(Misc::StringUtils::lowerCase(topic));
 
     if (iter == mInfoIndex.end())
         return -1;
@@ -187,16 +187,10 @@ bool CSMWorld::InfoCollection::reorderRows (int baseIndex, const std::vector<int
 
     // adjust index
     int size = static_cast<int>(newOrder.size());
-    for (std::map<StringHash, std::vector<std::pair<std::string, int> > >::iterator iter
+    for (auto& [hash, infos] : mInfoIndex)
-            = mInfoIndex.begin(); iter != mInfoIndex.end(); ++iter)
+        for (auto& [a, b] : infos)
-    {
+            if (b >= baseIndex && b < baseIndex + size)
-        for (std::vector<std::pair<std::string, int> >::iterator it = iter->second.begin();
+                b = newOrder.at(b - baseIndex) + baseIndex;
-                it != iter->second.end(); ++it)
-        {
-            if (it->second >= baseIndex && it->second < baseIndex+size)
-                it->second = newOrder.at(it->second-baseIndex)+baseIndex;
-        }
-    }
 
     return true;
 }
@@ -244,8 +238,8 @@ CSMWorld::InfoCollection::Range CSMWorld::InfoCollection::getTopicRange (const s
     std::string lowerTopic = Misc::StringUtils::lowerCase (topic);
 
     // find the topic
-    std::map<StringHash, std::vector<std::pair<std::string, int> > >::const_iterator iter
+    std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::const_iterator iter
-        = mInfoIndex.find(StringHash(std::make_shared<std::string>(lowerTopic)));
+        = mInfoIndex.find(lowerTopic);
 
     if (iter == mInfoIndex.end())
         return Range (getRecords().end(), getRecords().end());
@@ -310,7 +304,7 @@ void CSMWorld::InfoCollection::removeRows (int index, int count)
 {
     Collection<Info, IdAccessor<Info> >::removeRows(index, count); // erase records only
 
-    for (std::map<StringHash, std::vector<std::pair<std::string, int> > >::iterator iter
+    for (std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::iterator iter
         = mInfoIndex.begin(); iter != mInfoIndex.end();)
     {
         for (std::vector<std::pair<std::string, int> >::iterator it = iter->second.begin();
@@ -383,7 +377,7 @@ void CSMWorld::InfoCollection::insertRecord (std::unique_ptr<RecordBase> record,
     // adjust index
     if (index < size-1)
     {
-        for (std::map<StringHash, std::vector<std::pair<std::string, int> > >::iterator iter
+        for (std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::iterator iter
             = mInfoIndex.begin(); iter != mInfoIndex.end(); ++iter)
         {
             for (std::vector<std::pair<std::string, int> >::iterator it = iter->second.begin();
@@ -397,9 +391,9 @@ void CSMWorld::InfoCollection::insertRecord (std::unique_ptr<RecordBase> record,
 
     // get iterator for existing topic or a new topic
     std::string lowerId = Misc::StringUtils::lowerCase(id);
-    std::pair<std::map<StringHash, std::vector<std::pair<std::string, int> > >::iterator, bool> res
+    std::pair<std::unordered_map<std::string, std::vector<std::pair<std::string, int> > >::iterator, bool> res
         = mInfoIndex.insert(
-                std::make_pair(StringHash(std::make_shared<std::string>(lowerId.substr(0, separator))),
+                std::make_pair(lowerId.substr(0, separator),
                                std::vector<std::pair<std::string, int> >())); // empty vector
 
     // insert info and index

apps/opencs/model/world/infocollection.hpp

@@ -1,8 +1,6 @@
 #ifndef CSM_WOLRD_INFOCOLLECTION_H
 #define CSM_WOLRD_INFOCOLLECTION_H
 
-#include <extern/murmurhash/MurmurHash2.h>
-
 #include "collection.hpp"
 #include "info.hpp"
 
@@ -11,37 +9,6 @@ namespace ESM
     struct Dialogue;
 }
 
-namespace CSMWorld
-{
-    struct StringHash
-    {
-        uint64_t mHash;
-        std::shared_ptr<std::string> mString;
-
-        StringHash (std::shared_ptr<std::string> str) : mString(str)
-        {
-            mHash = MurmurHash64A(str->c_str(), str->size(), /*seed*/1);
-        }
-    };
-}
-
-namespace std
-{
-    template<> struct less<CSMWorld::StringHash>
-    {
-        bool operator() (const CSMWorld::StringHash& lhs, const CSMWorld::StringHash& rhs) const
-        {
-            if (lhs.mHash < rhs.mHash)
-                return true;
-
-            if (lhs.mHash > rhs.mHash)
-                return false;
-
-            return *lhs.mString < *rhs.mString;
-        }
-    };
-}
-
 namespace CSMWorld
 {
     template<>
@@ -69,8 +36,8 @@ namespace CSMWorld
             // each topic has a small number of infos, which allows the use of vectors for
             // iterating through them without too much penalty.
             //
-            // NOTE: hashed topic string as well as id string are stored in lower case.
+            // NOTE: topic string as well as id string are stored in lower case.
-            std::map<StringHash, std::vector<std::pair<std::string, int> > > mInfoIndex;
+            std::unordered_map<std::string, std::vector<std::pair<std::string, int> > > mInfoIndex;
 
             void load (const Info& record, bool base);
 

apps/opencs/model/world/refcollection.cpp

@@ -1,5 +1,7 @@
 #include "refcollection.hpp"
 
+#include <charconv>
+
 #include <components/esm/loadcell.hpp>
 
 #include "ref.hpp"
@@ -120,9 +122,9 @@ void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool
             }
             else
             {
-                std::unique_ptr<Record<CellRef> > record2(new Record<CellRef>(getRecord(index)));
+                std::unique_ptr<Record<CellRef> > record(new Record<CellRef>(getRecord(index)));
-                record2->mState = RecordBase::State_Deleted;
+                record->mState = RecordBase::State_Deleted;
-                setRecord(index, std::move(record2));
+                setRecord(index, std::move(record));
             }
 
             continue;
@@ -181,14 +183,19 @@ std::string CSMWorld::RefCollection::getNewId()
     return "ref#" + std::to_string(mNextId++);
 }
 
-unsigned int CSMWorld::RefCollection::extractIdNum (const std::string& id) const
+unsigned int CSMWorld::RefCollection::extractIdNum(std::string_view id) const
 {
-    std::string::size_type separator = id.find_last_of('#');
+    const auto separator = id.find_last_of('#');
 
-    if (separator == std::string::npos)
+    if (separator == std::string_view::npos)
-        throw std::runtime_error("invalid ref ID: " + id);
+        throw std::runtime_error("invalid ref ID: " + std::string(id));
 
-    return static_cast<unsigned int>(std::stoi(id.substr(separator+1)));
+    const std::string_view number = id.substr(separator + 1);
+    unsigned int result;
+    if (std::from_chars(number.data(), number.data() + number.size(), result).ec != std::errc())
+        throw std::runtime_error("invalid ref ID number: " + std::string(number));
+
+    return result;
 }
 
 int CSMWorld::RefCollection::getIntIndex (unsigned int id) const
@@ -235,15 +242,15 @@ void CSMWorld::RefCollection::removeRows (int index, int count)
 
 void  CSMWorld::RefCollection::appendBlankRecord (const std::string& id, UniversalId::Type type)
 {
-    std::unique_ptr<Record<CellRef> > record2(new Record<CellRef>);
+    std::unique_ptr<Record<CellRef> > record(new Record<CellRef>);
 
-    record2->mState = Record<CellRef>::State_ModifiedOnly;
+    record->mState = Record<CellRef>::State_ModifiedOnly;
-    record2->mModified.blank();
+    record->mModified.blank();
 
-    record2->get().mId = id;
+    record->get().mId = id;
-    record2->get().mIdNum = extractIdNum(id);
+    record->get().mIdNum = extractIdNum(id);
 
-    Collection<CellRef, IdAccessor<CellRef> >::appendRecord(std::move(record2));
+    Collection<CellRef, IdAccessor<CellRef> >::appendRecord(std::move(record));
 }
 
 void CSMWorld::RefCollection::cloneRecord (const std::string& origin,

apps/opencs/model/world/refcollection.hpp

@@ -29,7 +29,7 @@ namespace CSMWorld
 
             int mNextId;
 
-            unsigned int extractIdNum(const std::string& id) const;
+            unsigned int extractIdNum(std::string_view id) const;
 
             int getIntIndex (unsigned int id) const;
 

apps/opencs/model/world/refiddata.hpp

@@ -94,13 +94,13 @@ namespace CSMWorld
     template<typename RecordT>
     void RefIdDataContainer<RecordT>::insertRecord(std::unique_ptr<RecordBase> record)
     {
-        Record<RecordT> *tmp = dynamic_cast<Record<RecordT>*>(record.get());
+        // convert base pointer to record type pointer first
-        if(tmp != nullptr)
+        if(Record<RecordT> *tmp = dynamic_cast<Record<RecordT>*>(record.get()))
         {
-            record.release();
             std::unique_ptr<Record<RecordT> > newRecord;
             newRecord.reset(tmp);
             mContainer.push_back(std::move(newRecord));
+            record.release();
         }
         else
             throw std::runtime_error ("invalid record for RefIdDataContainer");

extern/murmurhash/CMakeLists.txt

@@ -1,17 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-
-# This is NOT intended as a stand-alone build system! Instead, you should include this from the main CMakeLists of your project.
-
-set(MURMURHASH_LIBRARY "murmurhash")
-
-# Sources
-set(SOURCE_FILES
-    MurmurHash2.cpp
-)
-
-add_library(${MURMURHASH_LIBRARY} STATIC ${SOURCE_FILES})
-
-set(MURMURHASH_LIBRARIES ${MURMURHASH_LIBRARY})
-
-link_directories(${CMAKE_CURRENT_BINARY_DIR})
-set(MURMURHASH_LIBRARIES ${MURMURHASH_LIBRARIES} PARENT_SCOPE)

extern/murmurhash/MurmurHash2.cpp

@@ -1,522 +0,0 @@
-//-----------------------------------------------------------------------------
-// MurmurHash2 was written by Austin Appleby, and is placed in the public
-// domain. The author hereby disclaims copyright to this source code.
-
-// Note - This code makes a few assumptions about how your machine behaves -
-
-// 1. We can read a 4-byte value from any address without crashing
-// 2. sizeof(int) == 4
-
-// And it has a few limitations -
-
-// 1. It will not work incrementally.
-// 2. It will not produce the same results on little-endian and big-endian
-//    machines.
-
-#include "MurmurHash2.h"
-
-//-----------------------------------------------------------------------------
-// Platform-specific functions and macros
-
-// Microsoft Visual Studio
-
-#if defined(_MSC_VER)
-
-#define BIG_CONSTANT(x) (x)
-
-// Other compilers
-
-#else   // defined(_MSC_VER)
-
-#define BIG_CONSTANT(x) (x##LLU)
-
-#endif // !defined(_MSC_VER)
-
-//-----------------------------------------------------------------------------
-
-uint32_t MurmurHash2 ( const void * key, int len, uint32_t seed )
-{
-  // 'm' and 'r' are mixing constants generated offline.
-  // They're not really 'magic', they just happen to work well.
-
-  const uint32_t m = 0x5bd1e995;
-  const int r = 24;
-
-  // Initialize the hash to a 'random' value
-
-  uint32_t h = seed ^ len;
-
-  // Mix 4 bytes at a time into the hash
-
-  const unsigned char * data = (const unsigned char *)key;
-
-  while(len >= 4)
-  {
-    uint32_t k = *(uint32_t*)data;
-
-    k *= m;
-    k ^= k >> r;
-    k *= m;
-
-    h *= m;
-    h ^= k;
-
-    data += 4;
-    len -= 4;
-  }
-
-  // Handle the last few bytes of the input array
-
-  switch(len)
-  {
-  case 3: h ^= data[2] << 16;
-  case 2: h ^= data[1] << 8;
-  case 1: h ^= data[0];
-      h *= m;
-  };
-
-  // Do a few final mixes of the hash to ensure the last few
-  // bytes are well-incorporated.
-
-  h ^= h >> 13;
-  h *= m;
-  h ^= h >> 15;
-
-  return h;
-}
-
-//-----------------------------------------------------------------------------
-// MurmurHash2, 64-bit versions, by Austin Appleby
-
-// The same caveats as 32-bit MurmurHash2 apply here - beware of alignment
-// and endian-ness issues if used across multiple platforms.
-
-// 64-bit hash for 64-bit platforms
-
-uint64_t MurmurHash64A ( const void * key, int len, uint64_t seed )
-{
-  const uint64_t m = BIG_CONSTANT(0xc6a4a7935bd1e995);
-  const int r = 47;
-
-  uint64_t h = seed ^ (len * m);
-
-  const uint64_t * data = (const uint64_t *)key;
-  const uint64_t * end = data + (len/8);
-
-  while(data != end)
-  {
-    uint64_t k = *data++;
-
-    k *= m;
-    k ^= k >> r;
-    k *= m;
-
-    h ^= k;
-    h *= m;
-  }
-
-  const unsigned char * data2 = (const unsigned char*)data;
-
-  switch(len & 7)
-  {
-  case 7: h ^= uint64_t(data2[6]) << 48;
-  case 6: h ^= uint64_t(data2[5]) << 40;
-  case 5: h ^= uint64_t(data2[4]) << 32;
-  case 4: h ^= uint64_t(data2[3]) << 24;
-  case 3: h ^= uint64_t(data2[2]) << 16;
-  case 2: h ^= uint64_t(data2[1]) << 8;
-  case 1: h ^= uint64_t(data2[0]);
-          h *= m;
-  };
-
-  h ^= h >> r;
-  h *= m;
-  h ^= h >> r;
-
-  return h;
-}
-
-
-// 64-bit hash for 32-bit platforms
-
-uint64_t MurmurHash64B ( const void * key, int len, uint64_t seed )
-{
-  const uint32_t m = 0x5bd1e995;
-  const int r = 24;
-
-  uint32_t h1 = uint32_t(seed) ^ len;
-  uint32_t h2 = uint32_t(seed >> 32);
-
-  const uint32_t * data = (const uint32_t *)key;
-
-  while(len >= 8)
-  {
-    uint32_t k1 = *data++;
-    k1 *= m; k1 ^= k1 >> r; k1 *= m;
-    h1 *= m; h1 ^= k1;
-    len -= 4;
-
-    uint32_t k2 = *data++;
-    k2 *= m; k2 ^= k2 >> r; k2 *= m;
-    h2 *= m; h2 ^= k2;
-    len -= 4;
-  }
-
-  if(len >= 4)
-  {
-    uint32_t k1 = *data++;
-    k1 *= m; k1 ^= k1 >> r; k1 *= m;
-    h1 *= m; h1 ^= k1;
-    len -= 4;
-  }
-
-  switch(len)
-  {
-  case 3: h2 ^= ((unsigned char*)data)[2] << 16;
-  case 2: h2 ^= ((unsigned char*)data)[1] << 8;
-  case 1: h2 ^= ((unsigned char*)data)[0];
-      h2 *= m;
-  };
-
-  h1 ^= h2 >> 18; h1 *= m;
-  h2 ^= h1 >> 22; h2 *= m;
-  h1 ^= h2 >> 17; h1 *= m;
-  h2 ^= h1 >> 19; h2 *= m;
-
-  uint64_t h = h1;
-
-  h = (h << 32) | h2;
-
-  return h;
-}
-
-//-----------------------------------------------------------------------------
-// MurmurHash2A, by Austin Appleby
-
-// This is a variant of MurmurHash2 modified to use the Merkle-Damgard
-// construction. Bulk speed should be identical to Murmur2, small-key speed
-// will be 10%-20% slower due to the added overhead at the end of the hash.
-
-// This variant fixes a minor issue where null keys were more likely to
-// collide with each other than expected, and also makes the function
-// more amenable to incremental implementations.
-
-#define mmix(h,k) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
-
-uint32_t MurmurHash2A ( const void * key, int len, uint32_t seed )
-{
-  const uint32_t m = 0x5bd1e995;
-  const int r = 24;
-  uint32_t l = len;
-
-  const unsigned char * data = (const unsigned char *)key;
-
-  uint32_t h = seed;
-
-  while(len >= 4)
-  {
-    uint32_t k = *(uint32_t*)data;
-
-    mmix(h,k);
-
-    data += 4;
-    len -= 4;
-  }
-
-  uint32_t t = 0;
-
-  switch(len)
-  {
-  case 3: t ^= data[2] << 16;
-  case 2: t ^= data[1] << 8;
-  case 1: t ^= data[0];
-  };
-
-  mmix(h,t);
-  mmix(h,l);
-
-  h ^= h >> 13;
-  h *= m;
-  h ^= h >> 15;
-
-  return h;
-}
-
-//-----------------------------------------------------------------------------
-// CMurmurHash2A, by Austin Appleby
-
-// This is a sample implementation of MurmurHash2A designed to work
-// incrementally.
-
-// Usage -
-
-// CMurmurHash2A hasher
-// hasher.Begin(seed);
-// hasher.Add(data1,size1);
-// hasher.Add(data2,size2);
-// ...
-// hasher.Add(dataN,sizeN);
-// uint32_t hash = hasher.End()
-
-class CMurmurHash2A
-{
-public:
-
-  void Begin ( uint32_t seed = 0 )
-  {
-    m_hash  = seed;
-    m_tail  = 0;
-    m_count = 0;
-    m_size  = 0;
-  }
-
-  void Add ( const unsigned char * data, int len )
-  {
-    m_size += len;
-
-    MixTail(data,len);
-
-    while(len >= 4)
-    {
-      uint32_t k = *(uint32_t*)data;
-
-      mmix(m_hash,k);
-
-      data += 4;
-      len -= 4;
-    }
-
-    MixTail(data,len);
-  }
-
-  uint32_t End ( void )
-  {
-    mmix(m_hash,m_tail);
-    mmix(m_hash,m_size);
-
-    m_hash ^= m_hash >> 13;
-    m_hash *= m;
-    m_hash ^= m_hash >> 15;
-
-    return m_hash;
-  }
-
-private:
-
-  static const uint32_t m = 0x5bd1e995;
-  static const int r = 24;
-
-  void MixTail ( const unsigned char * & data, int & len )
-  {
-    while( len && ((len<4) || m_count) )
-    {
-      m_tail |= (*data++) << (m_count * 8);
-
-      m_count++;
-      len--;
-
-      if(m_count == 4)
-      {
-        mmix(m_hash,m_tail);
-        m_tail = 0;
-        m_count = 0;
-      }
-    }
-  }
-
-  uint32_t m_hash;
-  uint32_t m_tail;
-  uint32_t m_count;
-  uint32_t m_size;
-};
-
-//-----------------------------------------------------------------------------
-// MurmurHashNeutral2, by Austin Appleby
-
-// Same as MurmurHash2, but endian- and alignment-neutral.
-// Half the speed though, alas.
-
-uint32_t MurmurHashNeutral2 ( const void * key, int len, uint32_t seed )
-{
-  const uint32_t m = 0x5bd1e995;
-  const int r = 24;
-
-  uint32_t h = seed ^ len;
-
-  const unsigned char * data = (const unsigned char *)key;
-
-  while(len >= 4)
-  {
-    uint32_t k;
-
-    k  = data[0];
-    k |= data[1] << 8;
-    k |= data[2] << 16;
-    k |= data[3] << 24;
-
-    k *= m;
-    k ^= k >> r;
-    k *= m;
-
-    h *= m;
-    h ^= k;
-
-    data += 4;
-    len -= 4;
-  }
-
-  switch(len)
-  {
-  case 3: h ^= data[2] << 16;
-  case 2: h ^= data[1] << 8;
-  case 1: h ^= data[0];
-          h *= m;
-  };
-
-  h ^= h >> 13;
-  h *= m;
-  h ^= h >> 15;
-
-  return h;
-}
-
-//-----------------------------------------------------------------------------
-// MurmurHashAligned2, by Austin Appleby
-
-// Same algorithm as MurmurHash2, but only does aligned reads - should be safer
-// on certain platforms.
-
-// Performance will be lower than MurmurHash2
-
-#define MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
-
-
-uint32_t MurmurHashAligned2 ( const void * key, int len, uint32_t seed )
-{
-  const uint32_t m = 0x5bd1e995;
-  const int r = 24;
-
-  const unsigned char * data = (const unsigned char *)key;
-
-  uint32_t h = seed ^ len;
-
-  int align = (uint64_t)data & 3;
-
-  if(align && (len >= 4))
-  {
-    // Pre-load the temp registers
-
-    uint32_t t = 0, d = 0;
-
-    switch(align)
-    {
-      case 1: t |= data[2] << 16;
-      case 2: t |= data[1] << 8;
-      case 3: t |= data[0];
-    }
-
-    t <<= (8 * align);
-
-    data += 4-align;
-    len -= 4-align;
-
-    int sl = 8 * (4-align);
-    int sr = 8 * align;
-
-    // Mix
-
-    while(len >= 4)
-    {
-      d = *(uint32_t *)data;
-      t = (t >> sr) | (d << sl);
-
-      uint32_t k = t;
-
-      MIX(h,k,m);
-
-      t = d;
-
-      data += 4;
-      len -= 4;
-    }
-
-    // Handle leftover data in temp registers
-
-    d = 0;
-
-    if(len >= align)
-    {
-      switch(align)
-      {
-      case 3: d |= data[2] << 16;
-      case 2: d |= data[1] << 8;
-      case 1: d |= data[0];
-      }
-
-      uint32_t k = (t >> sr) | (d << sl);
-      MIX(h,k,m);
-
-      data += align;
-      len -= align;
-
-      //----------
-      // Handle tail bytes
-
-      switch(len)
-      {
-      case 3: h ^= data[2] << 16;
-      case 2: h ^= data[1] << 8;
-      case 1: h ^= data[0];
-          h *= m;
-      };
-    }
-    else
-    {
-      switch(len)
-      {
-      case 3: d |= data[2] << 16;
-      case 2: d |= data[1] << 8;
-      case 1: d |= data[0];
-      case 0: h ^= (t >> sr) | (d << sl);
-          h *= m;
-      }
-    }
-
-    h ^= h >> 13;
-    h *= m;
-    h ^= h >> 15;
-
-    return h;
-  }
-  else
-  {
-    while(len >= 4)
-    {
-      uint32_t k = *(uint32_t *)data;
-
-      MIX(h,k,m);
-
-      data += 4;
-      len -= 4;
-    }
-
-    //----------
-    // Handle tail bytes
-
-    switch(len)
-    {
-    case 3: h ^= data[2] << 16;
-    case 2: h ^= data[1] << 8;
-    case 1: h ^= data[0];
-        h *= m;
-    };
-
-    h ^= h >> 13;
-    h *= m;
-    h ^= h >> 15;
-
-    return h;
-  }
-}
-
-//-----------------------------------------------------------------------------

extern/murmurhash/MurmurHash2.h

@@ -1,38 +0,0 @@
-//-----------------------------------------------------------------------------
-// MurmurHash2 was written by Austin Appleby, and is placed in the public
-// domain. The author hereby disclaims copyright to this source code.
-
-#ifndef _MURMURHASH2_H_
-#define _MURMURHASH2_H_
-
-//-----------------------------------------------------------------------------
-// Platform-specific functions and macros
-
-// Microsoft Visual Studio
-
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-
-typedef unsigned char uint8_t;
-typedef unsigned int uint32_t;
-typedef unsigned __int64 uint64_t;
-
-// Other compilers
-
-#else   // defined(_MSC_VER)
-
-#include <stdint.h>
-
-#endif // !defined(_MSC_VER)
-
-//-----------------------------------------------------------------------------
-
-uint32_t MurmurHash2        ( const void * key, int len, uint32_t seed );
-uint64_t MurmurHash64A      ( const void * key, int len, uint64_t seed );
-uint64_t MurmurHash64B      ( const void * key, int len, uint64_t seed );
-uint32_t MurmurHash2A       ( const void * key, int len, uint32_t seed );
-uint32_t MurmurHashNeutral2 ( const void * key, int len, uint32_t seed );
-uint32_t MurmurHashAligned2 ( const void * key, int len, uint32_t seed );
-
-//-----------------------------------------------------------------------------
-
-#endif // _MURMURHASH2_H_