Introduce LLEventDispatcher::begin()/end() to iterate over (name, desc) pairs

for all registered operations. (untested)
Introduce LLEventDispatcher::getMetadata(name) query so you can discover, for
a given named operation, its query string and required parameters. (untested)
Introduce LLEventDispatcher::add() convenience methods allowing you to omit
description strings. Fix LLLoginInstance (which uses a non-LLEventAPI
LLEventDispatcher) back to description-less add() calls.
However, filter LLEventDispatcher::add() methods inherited by LLEventAPI so
that an LLEventAPI subclass *must* provide a description string.

1 files changed, 53 insertions, 12 deletions

diff --git a/indra/llcommon/lleventdispatcher.h b/indra/llcommon/lleventdispatcher.h
index eba7b607f1..c8c4fe0c3c 100644
--- a/indra/llcommon/lleventdispatcher.h
+++ b/indra/llcommon/lleventdispatcher.h
@@ -19,6 +19,7 @@
 #include <map>
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
+#include <boost/iterator/transform_iterator.hpp>
 #include <typeinfo>
 #include "llevents.h"
 
@@ -73,6 +74,16 @@ public:
         addMethod<CLASS>(name, desc, method, required);
     }
 
+    /// Convenience: for LLEventDispatcher, not every callable needs a
+    /// documentation string.
+    template <typename CALLABLE>
+    void add(const std::string& name,
+             CALLABLE callable,
+             const LLSD& required=LLSD())
+    {
+        add(name, "", callable, required);
+    }
+
     /// Unregister a callable
     bool remove(const std::string& name);
 
@@ -87,10 +98,47 @@ public:
     /// @a required prototype specified at add() time, die with LL_ERRS.
     void operator()(const LLSD& event) const;
 
+    /// @name Iterate over defined names
+    //@{
+    typedef std::pair<std::string, std::string> NameDesc;
+
+private:
+    struct DispatchEntry
+    {
+        DispatchEntry(const Callable& func, const std::string& desc, const LLSD& required):
+            mFunc(func),
+            mDesc(desc),
+            mRequired(required)
+        {}
+        Callable mFunc;
+        std::string mDesc;
+        LLSD mRequired;
+    };
+    typedef std::map<std::string, DispatchEntry> DispatchMap;
+
+public:
+    /// We want the flexibility to redefine what data we store per name,
+    /// therefore our public interface doesn't expose DispatchMap iterators,
+    /// or DispatchMap itself, or DispatchEntry. Instead we explicitly
+    /// transform each DispatchMap item to NameDesc on dereferencing.
+    typedef boost::transform_iterator<NameDesc(*)(const DispatchMap::value_type&), DispatchMap::const_iterator> const_iterator;
+    const_iterator begin() const
+    {
+        return boost::make_transform_iterator(mDispatch.begin(), makeNameDesc);
+    }
+    const_iterator end() const
+    {
+        return boost::make_transform_iterator(mDispatch.end(), makeNameDesc);
+    }
+    //@}
+
     /// Fetch the Callable for the specified name. If no such name was
     /// registered, return an empty() Callable.
     Callable get(const std::string& name) const;
 
+    /// Get information about a specific Callable
+    LLSD getMetadata(const std::string& name) const;
+
 private:
     template <class CLASS, typename METHOD>
     void addMethod(const std::string& name, const std::string& desc,
@@ -111,19 +159,12 @@ private:
     bool attemptCall(const std::string& name, const LLSD& event) const;
 
     std::string mDesc, mKey;
-    struct DispatchEntry
-    {
-        DispatchEntry(const Callable& func, const std::string& desc, const LLSD& required):
-            mFunc(func),
-            mDesc(desc),
-            mRequired(required)
-        {}
-        Callable mFunc;
-        std::string mDesc;
-        LLSD mRequired;
-    };
-    typedef std::map<std::string, DispatchEntry> DispatchMap;
     DispatchMap mDispatch;
+
+    static NameDesc makeNameDesc(const DispatchMap::value_type& item)
+    {
+        return NameDesc(item.first, item.second.mDesc);
+    }
 };
 
 /**