diff --git a/indra/llcommon/llinitparam.h b/indra/llcommon/llinitparam.h
index 99983a19cb8925843453489259c8bda126660aab..66c72c2d9f864aa9d618c2248a7de66c9747f56e 100644
--- a/indra/llcommon/llinitparam.h
+++ b/indra/llcommon/llinitparam.h
@@ -212,14 +212,6 @@ namespace LLInitParam
public:
- struct CompareTypeID
- {
- bool operator()(const std::type_info* lhs, const std::type_info* rhs) const
- {
- return lhs->before(*rhs);
- }
- };
-
typedef std::vector<std::pair<std::string, bool> > name_stack_t;
typedef std::pair<name_stack_t::iterator, name_stack_t::iterator> name_stack_range_t;
typedef std::vector<std::string> possible_values_t;
@@ -242,20 +234,20 @@ namespace LLInitParam
template <typename T> bool readValue(T& param)
{
- parser_read_func_map_t::iterator found_it = mParserReadFuncs->find(&typeid(T));
- if (found_it != mParserReadFuncs->end())
+ boost::optional<parser_read_func_t> found_it = mParserReadFuncs->find<T>();
+ if (found_it)
{
- return found_it->second(*this, (void*)¶m);
+ return (*found_it)(*this, (void*)¶m);
}
return false;
}
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));
- if (found_it != mParserWriteFuncs->end())
+ boost::optional<parser_write_func_t> found_it = mParserWriteFuncs->find<T>();
+ if (found_it)
{
- return found_it->second(*this, (const void*)¶m, name_stack);
+ return (*found_it)(*this, (const void*)¶m, name_stack);
}
return false;
}
@@ -263,10 +255,10 @@ 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));
- if (found_it != mParserInspectFuncs->end())
+ boost::optional<parser_inspect_func_t> found_it = mParserInspectFuncs->find<T>();
+ if (found_it)
{
- found_it->second(name_stack, min_count, max_count, possible_values);
+ (*found_it)(name_stack, min_count, max_count, possible_values);
return true;
}
return false;
@@ -281,14 +273,14 @@ namespace LLInitParam
template <typename T>
void registerParserFuncs(parser_read_func_t read_func, parser_write_func_t write_func = NULL)
{
- mParserReadFuncs->insert(std::make_pair(&typeid(T), read_func));
- mParserWriteFuncs->insert(std::make_pair(&typeid(T), write_func));
+ mParserReadFuncs->insert<T>(read_func);
+ mParserWriteFuncs->insert<T>(write_func);
}
template <typename T>
void registerInspectFunc(parser_inspect_func_t inspect_func)
{
- mParserInspectFuncs->insert(std::make_pair(&typeid(T), inspect_func));
+ mParserInspectFuncs->insert<T>(inspect_func);
}
bool mParseSilently;
diff --git a/indra/llcommon/llregistry.h b/indra/llcommon/llregistry.h
index 36d7f7a44c89617b6f34c0a11698eb6b06367a54..2df9bc65415dbb70b63ed486a092816641febd12 100644
--- a/indra/llcommon/llregistry.h
+++ b/indra/llcommon/llregistry.h
@@ -34,9 +34,21 @@
#include "lltypeinfolookup.h"
template <typename T>
-class LLRegistryDefaultComparator
+struct LLRegistryDefaultComparator
{
- bool operator()(const T& lhs, const T& rhs) { return lhs < rhs; }
+ // It would be Bad if this comparison were used for const char*
+ BOOST_STATIC_ASSERT(! (boost::is_same<typename boost::remove_const<typename boost::remove_pointer<T>::type>::type, char>::value));
+ bool operator()(const T& lhs, const T& rhs) const { return lhs < rhs; }
+};
+
+// comparator for const char* registry keys
+template <>
+struct LLRegistryDefaultComparator<const char*>
+{
+ bool operator()(const char* lhs, const char* rhs) const
+ {
+ return strcmp(lhs, rhs) < 0;
+ }
};
template <typename KEY, typename VALUE>
@@ -72,7 +84,7 @@ class LLRegistry
{
friend class LLRegistry<KEY, VALUE, COMPARATOR>;
public:
- typedef typename LLRegistryMapSelector<KEY, VALUE>::type registry_map_t;
+ typedef std::map<KEY, VALUE, COMPARATOR> registry_map_t;
bool add(ref_const_key_t key, ref_const_value_t value)
{
diff --git a/indra/llcommon/lltypeinfolookup.h b/indra/llcommon/lltypeinfolookup.h
index 679cc51f1d864e6a2a4a4896536a3800e07e45a7..0b6862444ee76811b42d1c6383c223df04dcf414 100644
--- a/indra/llcommon/lltypeinfolookup.h
+++ b/indra/llcommon/lltypeinfolookup.h
@@ -13,11 +13,47 @@
#define LL_LLTYPEINFOLOOKUP_H
#include <boost/unordered_map.hpp>
-#include <boost/function.hpp>
-#include <boost/mem_fn.hpp>
-#include <boost/iterator/transform_iterator.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/optional.hpp>
+#include <functional> // std::binary_function
#include <typeinfo>
-#include <map>
+
+/**
+ * The following helper classes are based on the Boost.Unordered documentation:
+ * http://www.boost.org/doc/libs/1_45_0/doc/html/unordered/hash_equality.html
+ */
+
+/**
+ * Compute hash for a string passed as const char*
+ */
+struct const_char_star_hash: public std::unary_function<const char*, std::size_t>
+{
+ std::size_t operator()(const char* str) const
+ {
+ std::size_t seed = 0;
+ for ( ; *str; ++str)
+ {
+ boost::hash_combine(seed, *str);
+ }
+ return seed;
+ }
+};
+
+/**
+ * Compute equality for strings passed as const char*
+ *
+ * I (nat) suspect that this is where the default behavior breaks for the
+ * const char* values returned from std::type_info::name(). If you compare the
+ * two const char* pointer values, as a naive, unspecialized implementation
+ * will surely do, they'll compare unequal.
+ */
+struct const_char_star_equal: public std::binary_function<const char*, const char*, bool>
+{
+ bool operator()(const char* lhs, const char* rhs) const
+ {
+ return strcmp(lhs, rhs) == 0;
+ }
+};
/**
* LLTypeInfoLookup is specifically designed for use cases for which you might
@@ -26,87 +62,55 @@
* you can't rely on always getting the same std::type_info* for a given type:
* different load modules will produce different std::type_info*.
* LLTypeInfoLookup contains a workaround to address this issue.
+ *
+ * The API deliberately diverges from std::map in several respects:
+ * * It avoids iterators, not only begin()/end() but also as return values
+ * from insert() and find(). This bypasses transform_iterator overhead.
+ * * Since we literally use compile-time types as keys, the essential insert()
+ * and find() methods accept the key type as a @em template parameter,
+ * accepting and returning value_type as a normal runtime value. This is to
+ * permit future optimization (e.g. compile-time type hashing) without
+ * changing the API.
*/
template <typename VALUE>
class LLTypeInfoLookup
{
- // We present an interface like this:
- typedef std::map<const std::type_info*, VALUE> intf_map_type;
// Use this for our underlying implementation: lookup by
- // std::type_info::name() string. Note that we must store a std::pair<const
- // std::type_info*, VALUE> -- in other words, an intf_map_type::value_type
- // pair -- so we can present iterators that do the right thing.
- // (This might result in a lookup with one std::type_info* returning an
- // iterator to a different std::type_info*, but frankly, my dear, we don't
- // give a damn.)
- typedef boost::unordered_map<std::string, typename intf_map_type::value_type> impl_map_type;
- // Iterator shorthand
- typedef typename intf_map_type::iterator intf_iterator;
- typedef typename intf_map_type::const_iterator intf_const_iterator;
- typedef typename intf_map_type::value_type intf_value_type;
- typedef typename impl_map_type::iterator impl_iterator;
- typedef typename impl_map_type::const_iterator impl_const_iterator;
- typedef typename impl_map_type::value_type impl_value_type;
- // Type of function that transforms impl_value_type to intf_value_type
- typedef boost::function<intf_value_type&(impl_value_type&)> iterfunc;
- typedef boost::function<const intf_value_type&(const impl_value_type&)> const_iterfunc;
+ // std::type_info::name() string. This is one of the rare cases in which I
+ // dare use const char* directly, rather than std::string, because I'm
+ // sure that every value returned by std::type_info::name() is static.
+ // HOWEVER, specify our own hash + equality functors: naively comparing
+ // distinct const char* values won't work.
+ typedef boost::unordered_map<const char*, VALUE,
+ const_char_star_hash, const_char_star_equal> impl_map_type;
public:
- typedef LLTypeInfoLookup<VALUE> self;
- typedef typename intf_map_type::key_type key_type;
- typedef typename intf_map_type::mapped_type mapped_type;
- typedef intf_value_type value_type;
-
- // Iterators are different because we have to transform
- // impl_map_type::iterator to intf_map_type::iterator.
- typedef boost::transform_iterator<iterfunc, impl_iterator> iterator;
- typedef boost::transform_iterator<const_iterfunc, impl_const_iterator> const_iterator;
+ typedef VALUE value_type;
LLTypeInfoLookup() {}
- iterator begin() { return transform(mMap.begin()); }
- iterator end() { return transform(mMap.end()); }
- const_iterator begin() const { return const_transform(mMap.begin()); }
- const_iterator end() const { return const_transform(mMap.end()); }
bool empty() const { return mMap.empty(); }
std::size_t size() const { return mMap.size(); }
- // Shorthand -- I've always wished std::map supported this signature.
- std::pair<iterator, bool> insert(const std::type_info* key, const VALUE& value)
- {
- return insert(value_type(key, value));
- }
-
- std::pair<iterator, bool> insert(const value_type& pair)
+ template <typename KEY>
+ bool insert(const value_type& value)
{
// Obtain and store the std::type_info::name() string as the key.
- // Save the whole incoming pair as the value!
- std::pair<impl_iterator, bool>
- inserted(mMap.insert(impl_value_type(pair.first->name(), pair)));
- // Have to transform the iterator before returning.
- return std::pair<iterator, bool>(transform(inserted.first), inserted.second);
- }
-
- iterator find(const std::type_info* key)
- {
- return transform(mMap.find(key->name()));
+ // Return just the bool from std::map::insert()'s return pair.
+ return mMap.insert(typename impl_map_type::value_type(typeid(KEY).name(), value)).second;
}
- const_iterator find(const std::type_info* key) const
+ template <typename KEY>
+ boost::optional<value_type> find() const
{
- return const_transform(mMap.find(key->name()));
+ // Use the std::type_info::name() string as the key.
+ typename impl_map_type::const_iterator found = mMap.find(typeid(KEY).name());
+ if (found == mMap.end())
+ return boost::optional<value_type>();
+ return found->second;
}
private:
- iterator transform(impl_iterator iter)
- {
- return iterator(iter, boost::mem_fn(&impl_value_type::second));
- }
- const_iterator const_transform(impl_const_iterator iter)
- {
- return const_iterator(iter, boost::mem_fn(&impl_value_type::second));
- }
-
impl_map_type mMap;
};
diff --git a/indra/llui/lluictrlfactory.h b/indra/llui/lluictrlfactory.h
index d612ad5005d19afebbbdbbc15d92e008396e92ad..ab16805cb1abf917e417a62d21c60e81b986cb1e 100644
--- a/indra/llui/lluictrlfactory.h
+++ b/indra/llui/lluictrlfactory.h
@@ -34,15 +34,6 @@
class LLView;
-// sort functor for typeid maps
-struct LLCompareTypeID
-{
- bool operator()(const std::type_info* lhs, const std::type_info* rhs) const
- {
- return lhs->before(*rhs);
- }
-};
-
// lookup widget constructor funcs by widget name
template <typename DERIVED_TYPE>
class LLChildRegistry : public LLRegistrySingleton<std::string, LLWidgetCreatorFunc, DERIVED_TYPE>