lleventdispatcher.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:7k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /**
  2.  * @file   lleventdispatcher.h
  3.  * @author Nat Goodspeed
  4.  * @date   2009-06-18
  5.  * @brief  Central mechanism for dispatching events by string name. This is
  6.  *         useful when you have a single LLEventPump listener on which you can
  7.  *         request different operations, vs. instantiating a different
  8.  *         LLEventPump for each such operation.
  9.  * 
  10.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  11.  * 
  12.  * Copyright (c) 2009-2010, Linden Research, Inc.
  13.  * 
  14.  * Second Life Viewer Source Code
  15.  * The source code in this file ("Source Code") is provided by Linden Lab
  16.  * to you under the terms of the GNU General Public License, version 2.0
  17.  * ("GPL"), unless you have obtained a separate licensing agreement
  18.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  19.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  20.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  21.  * 
  22.  * There are special exceptions to the terms and conditions of the GPL as
  23.  * it is applied to this Source Code. View the full text of the exception
  24.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  25.  * online at
  26.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  27.  * 
  28.  * By copying, modifying or distributing this software, you acknowledge
  29.  * that you have read and understood your obligations described above,
  30.  * and agree to abide by those obligations.
  31.  * 
  32.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  33.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  34.  * COMPLETENESS OR PERFORMANCE.
  35.  * $/LicenseInfo$
  36.  */
  37. #if ! defined(LL_LLEVENTDISPATCHER_H)
  38. #define LL_LLEVENTDISPATCHER_H
  39. #include <string>
  40. #include <map>
  41. #include <boost/function.hpp>
  42. #include <boost/bind.hpp>
  43. #include <boost/iterator/transform_iterator.hpp>
  44. #include <typeinfo>
  45. #include "llevents.h"
  46. class LLSD;
  47. /**
  48.  * Given an LLSD map, examine a string-valued key and call a corresponding
  49.  * callable. This class is designed to be contained by an LLEventPump
  50.  * listener class that will register some of its own methods, though any
  51.  * callable can be used.
  52.  */
  53. class LL_COMMON_API LLEventDispatcher
  54. {
  55. public:
  56.     LLEventDispatcher(const std::string& desc, const std::string& key);
  57.     virtual ~LLEventDispatcher();
  58.     /// Accept any C++ callable, typically a boost::bind() expression
  59.     typedef boost::function<void(const LLSD&)> Callable;
  60.     /**
  61.      * Register a @a callable by @a name. The optional @a required parameter
  62.      * is used to validate the structure of each incoming event (see
  63.      * llsd_matches()).
  64.      */
  65.     void add(const std::string& name,
  66.              const std::string& desc,
  67.              const Callable& callable,
  68.              const LLSD& required=LLSD());
  69.     /**
  70.      * Special case: a subclass of this class can pass an unbound member
  71.      * function pointer without explicitly specifying the
  72.      * <tt>boost::bind()</tt> expression.
  73.      */
  74.     template <class CLASS>
  75.     void add(const std::string& name,
  76.              const std::string& desc,
  77.              void (CLASS::*method)(const LLSD&),
  78.              const LLSD& required=LLSD())
  79.     {
  80.         addMethod<CLASS>(name, desc, method, required);
  81.     }
  82.     /// Overload for both const and non-const methods
  83.     template <class CLASS>
  84.     void add(const std::string& name,
  85.              const std::string& desc,
  86.              void (CLASS::*method)(const LLSD&) const,
  87.              const LLSD& required=LLSD())
  88.     {
  89.         addMethod<CLASS>(name, desc, method, required);
  90.     }
  91.     /// Convenience: for LLEventDispatcher, not every callable needs a
  92.     /// documentation string.
  93.     template <typename CALLABLE>
  94.     void add(const std::string& name,
  95.              CALLABLE callable,
  96.              const LLSD& required=LLSD())
  97.     {
  98.         add(name, "", callable, required);
  99.     }
  100.     /// Unregister a callable
  101.     bool remove(const std::string& name);
  102.     /// Call a registered callable with an explicitly-specified name. If no
  103.     /// such callable exists, die with LL_ERRS. If the @a event fails to match
  104.     /// the @a required prototype specified at add() time, die with LL_ERRS.
  105.     void operator()(const std::string& name, const LLSD& event) const;
  106.     /// Extract the @a key value from the incoming @a event, and call the
  107.     /// callable whose name is specified by that map @a key. If no such
  108.     /// callable exists, die with LL_ERRS. If the @a event fails to match the
  109.     /// @a required prototype specified at add() time, die with LL_ERRS.
  110.     void operator()(const LLSD& event) const;
  111.     /// @name Iterate over defined names
  112.     //@{
  113.     typedef std::pair<std::string, std::string> NameDesc;
  114. private:
  115.     struct DispatchEntry
  116.     {
  117.         DispatchEntry(const Callable& func, const std::string& desc, const LLSD& required):
  118.             mFunc(func),
  119.             mDesc(desc),
  120.             mRequired(required)
  121.         {}
  122.         Callable mFunc;
  123.         std::string mDesc;
  124.         LLSD mRequired;
  125.     };
  126.     typedef std::map<std::string, DispatchEntry> DispatchMap;
  127. public:
  128.     /// We want the flexibility to redefine what data we store per name,
  129.     /// therefore our public interface doesn't expose DispatchMap iterators,
  130.     /// or DispatchMap itself, or DispatchEntry. Instead we explicitly
  131.     /// transform each DispatchMap item to NameDesc on dereferencing.
  132.     typedef boost::transform_iterator<NameDesc(*)(const DispatchMap::value_type&), DispatchMap::const_iterator> const_iterator;
  133.     const_iterator begin() const
  134.     {
  135.         return boost::make_transform_iterator(mDispatch.begin(), makeNameDesc);
  136.     }
  137.     const_iterator end() const
  138.     {
  139.         return boost::make_transform_iterator(mDispatch.end(), makeNameDesc);
  140.     }
  141.     //@}
  142.     /// Fetch the Callable for the specified name. If no such name was
  143.     /// registered, return an empty() Callable.
  144.     Callable get(const std::string& name) const;
  145.     /// Get information about a specific Callable
  146.     LLSD getMetadata(const std::string& name) const;
  147.     /// Retrieve the LLSD key we use for one-arg <tt>operator()</tt> method
  148.     std::string getDispatchKey() const { return mKey; }
  149. private:
  150.     template <class CLASS, typename METHOD>
  151.     void addMethod(const std::string& name, const std::string& desc,
  152.                    const METHOD& method, const LLSD& required)
  153.     {
  154.         CLASS* downcast = dynamic_cast<CLASS*>(this);
  155.         if (! downcast)
  156.         {
  157.             addFail(name, typeid(CLASS).name());
  158.         }
  159.         else
  160.         {
  161.             add(name, desc, boost::bind(method, downcast, _1), required);
  162.         }
  163.     }
  164.     void addFail(const std::string& name, const std::string& classname) const;
  165.     /// try to dispatch, return @c true if success
  166.     bool attemptCall(const std::string& name, const LLSD& event) const;
  167.     std::string mDesc, mKey;
  168.     DispatchMap mDispatch;
  169.     static NameDesc makeNameDesc(const DispatchMap::value_type& item)
  170.     {
  171.         return NameDesc(item.first, item.second.mDesc);
  172.     }
  173. };
  174. /**
  175.  * Bundle an LLEventPump and a listener with an LLEventDispatcher. A class
  176.  * that contains (or derives from) LLDispatchListener need only specify the
  177.  * LLEventPump name and dispatch key, and add() its methods. Incoming events
  178.  * will automatically be dispatched.
  179.  */
  180. class LL_COMMON_API LLDispatchListener: public LLEventDispatcher
  181. {
  182. public:
  183.     LLDispatchListener(const std::string& pumpname, const std::string& key);
  184.     std::string getPumpName() const { return mPump.getName(); }
  185. private:
  186.     bool process(const LLSD& event);
  187.     LLEventStream mPump;
  188.     LLTempBoundListener mBoundListener;
  189. };
  190. #endif /* ! defined(LL_LLEVENTDISPATCHER_H) */