Replace usage of remaining boost::unordered containers with std

Replace LLUUID and LLMaterialID container hashing functions with more collision resistant versions
Utilize boost::hash_combine for TEMaterialPair to generate good hash distribution
Generalize is_in_map and get_if_there for usage with all mapped types

5 files changed, 30 insertions, 20 deletions

diff --git a/indra/llcommon/llpounceable.h b/indra/llcommon/llpounceable.h
index e86098f20b..20561b0c65 100644
--- a/indra/llcommon/llpounceable.h
+++ b/indra/llcommon/llpounceable.h
@@ -38,9 +38,9 @@
 #include "llsingleton.h"
 #include <boost/call_traits.hpp>
 #include <boost/utility/value_init.hpp>
-#include <boost/unordered_map.hpp>
 #include <boost/signals2/signal.hpp>
 
+#include <unordered_map>
 #include <type_traits>
 
 // Forward declare the user template, since we want to be able to point to it
@@ -86,7 +86,7 @@ class LLPounceableQueueSingleton:
     // instance will call on the SAME LLPounceableQueueSingleton instance --
     // given how class statics work. We must keep a separate queue for each
     // LLPounceable instance. Use a hash map for that.
-    typedef boost::unordered_map<owner_ptr, signal_t> map_t;
+    typedef std::unordered_map<owner_ptr, signal_t> map_t;
 
 public:
     // Disambiguate queues belonging to different LLPounceables.
diff --git a/indra/llcommon/llsingleton.h b/indra/llcommon/llsingleton.h
index 3fba8602ee..e6989211ae 100644
--- a/indra/llcommon/llsingleton.h
+++ b/indra/llcommon/llsingleton.h
@@ -25,10 +25,10 @@
 #ifndef LLSINGLETON_H
 #define LLSINGLETON_H
 
-#include <boost/unordered_set.hpp>
 #include <initializer_list>
 #include <list>
 #include <typeinfo>
+#include <unordered_set>
 #include <vector>
 #include "mutex.h"
 #include "lockstatic.h"
@@ -61,7 +61,7 @@ private:
     static vec_t dep_sort();
 
     // we directly depend on these other LLSingletons
-    typedef boost::unordered_set<LLSingletonBase*> set_t;
+    typedef std::unordered_set<LLSingletonBase*> set_t;
     set_t mDepends;
 
 protected:
diff --git a/indra/llcommon/llstaticstringtable.h b/indra/llcommon/llstaticstringtable.h
index 66ba3487c4..edff955ee7 100644
--- a/indra/llcommon/llstaticstringtable.h
+++ b/indra/llcommon/llstaticstringtable.h
@@ -29,9 +29,10 @@
 #define LL_STATIC_STRING_TABLE_H
 
 #include "lldefs.h"
-#include <boost/unordered_map.hpp>
 #include "llstl.h"
 
+#include <unordered_map>
+
 class LLStaticHashedString
 {
 public:
@@ -74,7 +75,7 @@ struct LLStaticStringHasher
 
 template< typename MappedObject >
 class LL_COMMON_API LLStaticStringTable
-    : public boost::unordered_map< LLStaticHashedString, MappedObject, LLStaticStringHasher >
+    : public std::unordered_map< LLStaticHashedString, MappedObject, LLStaticStringHasher >
 {
 };
 
diff --git a/indra/llcommon/llstl.h b/indra/llcommon/llstl.h
index 7d41c42ba7..9f3587886c 100644
--- a/indra/llcommon/llstl.h
+++ b/indra/llcommon/llstl.h
@@ -229,12 +229,10 @@ void delete_and_clear_array(T*& ptr)
 template <typename T>
 inline typename T::mapped_type get_ptr_in_map(const T& inmap, typename T::key_type const& key)
 {
-    // Typedef here avoids warnings because of new c++ naming rules.
-    typedef typename T::const_iterator map_iter;
-    map_iter iter = inmap.find(key);
+    auto iter = inmap.find(key);
     if(iter == inmap.end())
     {
-        return NULL;
+        return nullptr;
     }
     else
     {
@@ -243,8 +241,8 @@ inline typename T::mapped_type get_ptr_in_map(const T& inmap, typename T::key_ty
 };
 
 // helper function which returns true if key is in inmap.
-template <typename K, typename T>
-inline bool is_in_map(const std::map<K,T>& inmap, const K& key)
+template <typename T>
+inline bool is_in_map(const T& inmap, typename T::key_type const& key)
 {
     if(inmap.find(key) == inmap.end())
     {
@@ -260,12 +258,10 @@ inline bool is_in_map(const std::map<K,T>& inmap, const K& key)
 // To replace LLSkipMap getIfThere, use:
 //   get_if_there(map, key, 0)
 // WARNING: Make sure default_value (generally 0) is not a valid map entry!
-template <typename K, typename T>
-inline T get_if_there(const std::map<K,T>& inmap, const K& key, T default_value)
+template <typename T>
+inline typename T::mapped_type get_if_there(const T& inmap, typename T::key_type const& key, typename T::mapped_type default_value)
 {
-    // Typedef here avoids warnings because of new c++ naming rules.
-    typedef typename std::map<K,T>::const_iterator map_iter;
-    map_iter iter = inmap.find(key);
+    auto iter = inmap.find(key);
     if(iter == inmap.end())
     {
         return default_value;
diff --git a/indra/llcommon/lluuid.h b/indra/llcommon/lluuid.h
index ca1cf03c4d..f91aadccc0 100644
--- a/indra/llcommon/lluuid.h
+++ b/indra/llcommon/lluuid.h
@@ -26,6 +26,7 @@
 #ifndef LL_LLUUID_H
 #define LL_LLUUID_H
 
+#include <functional>
 #include <iostream>
 #include <set>
 #include <vector>
@@ -176,15 +177,27 @@ namespace std
     {
         inline size_t operator()(const LLUUID& id) const noexcept
         {
-            return (size_t)id.getDigest64();
+            size_t h = 0;
+            // Golden ratio hash with avalanche mixing
+            // Process 8 bytes at a time by manually constructing 64-bit values
+            // Shift by 31: mixes upper half into lower half for better bit distribution
+            // Shift by 47: ensures highest bits influence final hash output
+            for (int i = 0; i < UUID_BYTES; i += 8) {
+                size_t chunk = (size_t)id.mData[i] | ((size_t)id.mData[i+1] << 8) |
+                               ((size_t)id.mData[i+2] << 16) | ((size_t)id.mData[i+3] << 24) |
+                               ((size_t)id.mData[i+4] << 32) | ((size_t)id.mData[i+5] << 40) |
+                               ((size_t)id.mData[i+6] << 48) | ((size_t)id.mData[i+7] << 56);
+                h ^= (chunk * 0x9e3779b97f4a7c15ULL) ^ (h >> 31) ^ (h >> 47);
+            }
+            return h;
         }
     };
 }
 
-// For use with boost containers.
+// For use with boost::container_hash
 inline size_t hash_value(const LLUUID& id) noexcept
 {
-    return (size_t)id.getDigest64();
+    return std::hash<LLUUID>{}(id);
 }
 
 #endif // LL_LLUUID_H