Merge tag 'Second_Life_Release#3529bc5f-2026.02' into 2026.02

1 files changed, 52 insertions, 77 deletions

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;