Modernize std::type_info* usage in containers with std::type_index

Introduce operator<< for std::type_index for logging output
Utilize std::unordered_map inside llheteromap, llinitparam, llregistry
Remove unused Comparator template parameter from LLRegistry

5 files changed, 76 insertions, 116 deletions

diff --git a/indra/llcommon/llheteromap.cpp b/indra/llcommon/llheteromap.cpp
index 823bea7a3c..03dd7856b6 100644
--- a/indra/llcommon/llheteromap.cpp
+++ b/indra/llcommon/llheteromap.cpp
@@ -27,6 +27,6 @@ LLHeteroMap::~LLHeteroMap()
         // pair.second is the std::pair; pair.second.first is the void*;
         // pair.second.second points to the deleter function
         (pair.second.second)(pair.second.first);
-        pair.second.first = NULL;
+        pair.second.first = nullptr;
     }
 }
diff --git a/indra/llcommon/llheteromap.h b/indra/llcommon/llheteromap.h
index d8e6fefb17..211dfaae83 100644
--- a/indra/llcommon/llheteromap.h
+++ b/indra/llcommon/llheteromap.h
@@ -12,9 +12,10 @@
 #if ! defined(LL_LLHETEROMAP_H)
 #define LL_LLHETEROMAP_H
 
+#include <typeindex>
 #include <typeinfo>
 #include <utility>                  // std::pair
-#include <map>
+#include <unordered_map>
 
 /**
  * LLHeteroMap addresses an odd requirement. Usually when you want to put
@@ -43,7 +44,7 @@ public:
         // Look up map entry by typeid(T). We don't simply use mMap[typeid(T)]
         // because that requires default-constructing T on every lookup. For
         // some kinds of T, that could be expensive.
-        TypeMap::iterator found = mMap.find(&typeid(T));
+        TypeMap::iterator found = mMap.find(typeid(T));
         if (found == mMap.end())
         {
             // Didn't find typeid(T). Create an entry. Because we're storing
@@ -52,8 +53,8 @@ public:
             void* ptr = new T();
             void (*dlfn)(void*) = &deleter<T>;
             std::pair<TypeMap::iterator, bool> inserted =
-                mMap.insert(TypeMap::value_type(&typeid(T),
-                    TypeMap::mapped_type(ptr, dlfn)));
+                mMap.emplace(typeid(T),
+                    TypeMap::mapped_type(ptr, dlfn));
             // Okay, now that we have an entry, claim we found it.
             found = inserted.first;
         }
@@ -71,23 +72,9 @@ private:
         delete static_cast<T*>(p);
     }
 
-    // Comparing two std::type_info* values is tricky, because the standard
-    // does not guarantee that there will be only one type_info instance for a
-    // given type. In other words, &typeid(A) in one part of the program may
-    // not always equal &typeid(A) in some other part. Use special comparator.
-    struct type_info_ptr_comp
-    {
-        bool operator()(const std::type_info* lhs, const std::type_info* rhs) const
-        {
-            return lhs->before(*rhs);
-        }
-    };
-
-    // What we actually store is a map from std::type_info (permitting lookup
+    // What we actually store is a map from std::type_index (permitting lookup
     // by object type) to a void* pointer to the object PLUS its deleter.
-    typedef std::map<
-        const std::type_info*, std::pair<void*, void (*)(void*)>,
-        type_info_ptr_comp>
+    typedef std::unordered_map<std::type_index, std::pair<void*, void (*)(void*)>>
     TypeMap;
     TypeMap mMap;
 };
diff --git a/indra/llcommon/llinitparam.h b/indra/llcommon/llinitparam.h
index b01ea0bfb1..b220afadfc 100644
--- a/indra/llcommon/llinitparam.h
+++ b/indra/llcommon/llinitparam.h
@@ -34,7 +34,6 @@
 #include <list>
 #include <unordered_map>
 #include <boost/function.hpp>
-#include <boost/unordered_map.hpp>
 
 #include "llerror.h"
 #include "llstl.h"
@@ -267,7 +266,7 @@ namespace LLInitParam
     private:
         struct Inaccessable{};
     public:
-        typedef std::map<std::string, T> value_name_map_t;
+        typedef std::unordered_map<std::string, T> value_name_map_t;
         typedef Inaccessable name_t;
         typedef TypeValues<T> type_value_t;
         typedef ParamValue<typename LLTypeTags::Sorted<T>::value_t> param_value_t;
@@ -294,7 +293,7 @@ namespace LLInitParam
 
         static std::vector<std::string>* getPossibleValues()
         {
-            return NULL;
+            return nullptr;
         }
 
         void assignNamedValue(const Inaccessable& name)
@@ -310,7 +309,7 @@ namespace LLInitParam
             return param_value_t::getValue();
         }
 
-        static value_name_map_t* getValueNames() {return NULL;}
+        static value_name_map_t* getValueNames() { return nullptr; }
     };
 
     // helper class to implement name value lookups
@@ -321,7 +320,7 @@ namespace LLInitParam
     {
         typedef TypeValuesHelper<T, DERIVED_TYPE, IS_SPECIALIZED> self_t;
     public:
-        typedef typename std::map<std::string, T> value_name_map_t;
+        typedef typename std::unordered_map<std::string, T> value_name_map_t;
         typedef std::string name_t;
         typedef self_t type_value_t;
         typedef ParamValue<typename LLTypeTags::Sorted<T>::value_t> param_value_t;
@@ -497,9 +496,9 @@ namespace LLInitParam
         typedef bool (*parser_write_func_t)(Parser& parser, const void*, name_stack_t&);
         typedef std::function<void (name_stack_t&, S32, S32, const possible_values_t*)>   parser_inspect_func_t;
 
-        typedef std::map<const std::type_info*, parser_read_func_t>     parser_read_func_map_t;
-        typedef std::map<const std::type_info*, parser_write_func_t>    parser_write_func_map_t;
-        typedef std::map<const std::type_info*, parser_inspect_func_t>  parser_inspect_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_read_func_t>           parser_read_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_write_func_t>          parser_write_func_map_t;
+        typedef std::unordered_map<std::type_index, parser_inspect_func_t>        parser_inspect_func_map_t;
 
     public:
 
@@ -514,7 +513,7 @@ namespace LLInitParam
 
         template <typename T> bool readValue(T& param, typename std::enable_if_t<!std::is_enum_v<T>>* dummy = 0)
         {
-            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
+            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(typeid(T));
             if (found_it != mParserReadFuncs->end())
             {
                 return found_it->second(*this, (void*)&param);
@@ -525,14 +524,14 @@ namespace LLInitParam
 
         template <typename T> bool readValue(T& param, typename std::enable_if_t<std::is_enum_v<T> >* dummy = 0)
         {
-            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
+            parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(typeid(T));
             if (found_it != mParserReadFuncs->end())
             {
                 return found_it->second(*this, (void*)&param);
             }
             else
             {
-                found_it = mParserReadFuncs->find(&typeid(S32));
+                found_it = mParserReadFuncs->find(typeid(S32));
                 if (found_it != mParserReadFuncs->end())
                 {
                     S32 int_value;
@@ -546,7 +545,7 @@ namespace LLInitParam
 
         template <typename T> bool writeValue(const T& param, name_stack_t& name_stack)
         {
-            parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(&typeid(T));
+            parser_write_func_map_t::iterator found_it = mParserWriteFuncs->find(typeid(T));
             if (found_it != mParserWriteFuncs->end())
             {
                 return found_it->second(*this, (const void*)&param, name_stack);
@@ -557,7 +556,7 @@ namespace LLInitParam
         // dispatch inspection to registered inspection functions, for each parameter in a param block
         template <typename T> bool inspectValue(name_stack_t& name_stack, S32 min_count, S32 max_count, const possible_values_t* possible_values)
         {
-            parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(&typeid(T));
+            parser_inspect_func_map_t::iterator found_it = mParserInspectFuncs->find(typeid(T));
             if (found_it != mParserInspectFuncs->end())
             {
                 found_it->second(name_stack, min_count, max_count, possible_values);
@@ -574,16 +573,16 @@ namespace LLInitParam
 
     protected:
         template <typename T>
-        void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = NULL)
+        void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = nullptr)
         {
-            mParserReadFuncs->insert(std::make_pair(&typeid(T), read_func));
-            mParserWriteFuncs->insert(std::make_pair(&typeid(T), write_func));
+            mParserReadFuncs->emplace(typeid(T), read_func);
+            mParserWriteFuncs->emplace(typeid(T), write_func);
         }
 
         template <typename T>
         void registerInspectFunc(parser_inspect_func_t inspect_func)
         {
-            mParserInspectFuncs->insert(std::make_pair(&typeid(T), inspect_func));
+            mParserInspectFuncs->emplace(typeid(T), inspect_func);
         }
 
         bool                mParseSilently;
@@ -614,7 +613,7 @@ namespace LLInitParam
     {
         struct UserData
         {
-            virtual ~UserData() {}
+            virtual ~UserData() = default;
         };
 
         typedef bool(*merge_func_t)(Param&, const Param&, bool);
@@ -665,7 +664,7 @@ namespace LLInitParam
         void aggregateBlockData(BlockDescriptor& src_block_data);
         void addParam(ParamDescriptorPtr param, const char* name);
 
-        typedef boost::unordered_map<const std::string, ParamDescriptorPtr>                     param_map_t;
+        typedef std::unordered_map<std::string, ParamDescriptorPtr, ll::string_hash, std::equal_to<>> param_map_t;
         typedef std::vector<ParamDescriptorPtr>                                                 param_list_t;
         typedef std::list<ParamDescriptorPtr>                                                   all_params_list_t;
         typedef std::vector<std::pair<param_handle_t, ParamDescriptor::validation_func_t> >     param_validation_list_t;
@@ -679,38 +678,26 @@ namespace LLInitParam
         class BaseBlock*                mCurrentBlockPtr;       // pointer to block currently being constructed
     };
 
-        //TODO: implement in terms of owned_ptr
-        template<typename T>
+    // TODO: implement in terms of owned_ptr
+    template<typename T>
     class LazyValue
-        {
-        public:
-        LazyValue()
-                : mPtr(NULL)
-            {}
+    {
+    public:
+        LazyValue() = default;
 
-        ~LazyValue()
-            {
-                delete mPtr;
-            }
+        ~LazyValue() { delete mPtr; }
 
-        LazyValue(const T& value)
-            {
-            mPtr = new T(value);
-        }
+        LazyValue(const T& value) { mPtr = new T(value); }
 
-        LazyValue(const LazyValue& other)
-        :   mPtr(NULL)
-                {
-            *this = other;
-                }
+        LazyValue(const LazyValue& other) : mPtr(nullptr) { *this = other; }
 
-        LazyValue& operator = (const LazyValue& other)
-                {
+        LazyValue& operator=(const LazyValue& other)
+        {
             if (!other.mPtr)
             {
                 delete mPtr;
-                    mPtr = NULL;
-                }
+                mPtr = nullptr;
+            }
             else
             {
                 if (!mPtr)
@@ -721,23 +708,21 @@ namespace LLInitParam
                 {
                     *mPtr = *(other.mPtr);
                 }
-                }
-                return *this;
             }
+            return *this;
+        }
 
         bool operator==(const LazyValue& other) const
         {
-            if (empty() || other.empty()) return false;
+            if (empty() || other.empty())
+                return false;
             return *mPtr == *other.mPtr;
         }
 
-            bool empty() const
-            {
-                return mPtr == NULL;
-            }
+        bool empty() const { return mPtr == nullptr; }
 
-            void set(const T& other)
-            {
+        void set(const T& other)
+        {
             if (!mPtr)
             {
                 mPtr = new T(other);
@@ -748,36 +733,26 @@ namespace LLInitParam
             }
         }
 
-            const T& get() const
-            {
-            return *ensureInstance();
-            }
+        const T& get() const { return *ensureInstance(); }
 
-            T& get()
-            {
-            return *ensureInstance();
-        }
+        T& get() { return *ensureInstance(); }
 
-        operator const T&() const
-        {
-            return get();
-            }
+        operator const T&() const { return get(); }
 
-        private:
-            // lazily allocate an instance of T
-            T* ensureInstance() const
+    private:
+        // lazily allocate an instance of T
+        T* ensureInstance() const
+        {
+            if (mPtr == nullptr)
             {
-                if (mPtr == NULL)
-                {
-                    mPtr = new T();
-                }
-                return mPtr;
+                mPtr = new T();
             }
+            return mPtr;
+        }
 
-        private:
-
-            mutable T* mPtr;
-        };
+    private:
+        mutable T* mPtr = nullptr;
+    };
 
     // root class of all parameter blocks
 
@@ -864,7 +839,7 @@ namespace LLInitParam
             mParamProvided(false)
         {}
 
-        virtual ~BaseBlock() {}
+        virtual ~BaseBlock() = default;
         bool submitValue(Parser::name_stack_t& name_stack, Parser& p, bool silent=false);
 
         param_handle_t getHandleFromParam(const Param* param) const;
diff --git a/indra/llcommon/llregistry.h b/indra/llcommon/llregistry.h
index 35335e1213..92f8ae3245 100644
--- a/indra/llcommon/llregistry.h
+++ b/indra/llcommon/llregistry.h
@@ -32,21 +32,11 @@
 #include "llsingleton.h"
 #include "llstl.h"
 
-template <typename T>
-struct LLRegistryDefaultComparator
-{
-    bool operator()(const T& lhs, const T& rhs) const
-    {
-        using std::less;
-        return less<T>()(lhs, rhs);
-    }
-};
-
-template <typename KEY, typename VALUE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
+template <typename KEY, typename VALUE>
 class LLRegistry
 {
 public:
-    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
+    typedef LLRegistry<KEY, VALUE>      registry_t;
     typedef const KEY&                              ref_const_key_t;
     typedef const VALUE&                            ref_const_value_t;
     typedef const VALUE*                            ptr_const_value_t;
@@ -54,9 +44,9 @@ public:
 
     class Registrar
     {
-        friend class LLRegistry<KEY, VALUE, COMPARATOR>;
+        friend class LLRegistry<KEY, VALUE>;
     public:
-        typedef std::map<KEY, VALUE, COMPARATOR> registry_map_t;
+        typedef std::map<KEY, VALUE> registry_map_t;
 
         bool add(ref_const_key_t key, ref_const_value_t value)
         {
@@ -234,9 +224,9 @@ private:
     Registrar       mDefaultRegistrar;
 };
 
-template <typename KEY, typename VALUE, typename DERIVED_TYPE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
+template <typename KEY, typename VALUE, typename DERIVED_TYPE>
 class LLRegistrySingleton
-    :   public LLRegistry<KEY, VALUE, COMPARATOR>,
+    :   public LLRegistry<KEY, VALUE>,
         public LLSingleton<DERIVED_TYPE>
 {
     // This LLRegistrySingleton doesn't use LLSINGLETON(LLRegistrySingleton)
@@ -244,7 +234,7 @@ class LLRegistrySingleton
     // LLRegistrySingleton. So each concrete subclass needs
     // LLSINGLETON(whatever) -- not this intermediate base class.
 public:
-    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
+    typedef LLRegistry<KEY, VALUE>      registry_t;
     typedef const KEY&                              ref_const_key_t;
     typedef const VALUE&                            ref_const_value_t;
     typedef VALUE*                                  ptr_value_t;
@@ -309,7 +299,7 @@ public:
     };
 
     // convenience functions
-    typedef typename LLRegistry<KEY, VALUE, COMPARATOR>::Registrar& ref_registrar_t;
+    typedef typename LLRegistry<KEY, VALUE>::Registrar& ref_registrar_t;
     static ref_registrar_t currentRegistrar()
     {
         return singleton_t::instance().registry_t::currentRegistrar();
diff --git a/indra/llcommon/llstl.h b/indra/llcommon/llstl.h
index f8a468a132..7a1c7caf82 100644
--- a/indra/llcommon/llstl.h
+++ b/indra/llcommon/llstl.h
@@ -34,6 +34,7 @@
 #include <vector>
 #include <list>
 #include <set>
+#include <typeindex>
 #include <typeinfo>
 
 #ifdef LL_LINUX
@@ -718,4 +719,11 @@ namespace ll
     };
 } // namespace ll
 
+// Specialize ostream for std::type_index to allow log output
+inline std::ostream& operator<<(std::ostream& s, std::type_index type)
+{
+    s << type.name();
+    return s;
+}
+
 #endif // LL_LLSTL_H