Changeset 3330

Timestamp:

01/30/10 13:18:29 (7 weeks ago)

Author:

trichards

Message:

Refactored the Event framework so that I_Event is created in EventService? instead of EventQueue?.

Location:

Core/branches/0075_TR_SCRIPTING/Event

Files:

• I_Event.hpp (modified) (2 diffs)
• I_EventQueue.hpp (modified) (2 diffs)
• I_EventService.hpp (modified) (2 diffs)
• src/Event.cpp (modified) (6 diffs)
• src/EventQueue.cpp (modified) (2 diffs)
• src/EventQueue.hpp (modified) (3 diffs)
• src/EventService.cpp (modified) (5 diffs)
• src/EventService.hpp (modified) (4 diffs)
• src/Event_impl.hpp (modified) (5 diffs)

Core/branches/0075_TR_SCRIPTING/Event/I_Event.hpp

@@ -38 +38 @@
 class I_Connection;
 class I_Action;
+class I_EventQueue;
 
 /// @brief Event interface
@@ -56 +57 @@
 public:
     /// Connect an action to an event.
+    /// @param _pAction Action that will be invoked when the event is fired.
+    /// @param _queue The event queue that will be used to dispatch the action.
+    ///         If this parameter is NULL, the default event queue is used.
     /// @return I_Connection that represents the connected event and action.
     ///         Use this to disconnect the connection.
-    virtual I_Connection& connect(pAction_type _pAction) = 0;
+    virtual I_Connection& connect(pAction_type _pAction, I_EventQueue* _pQueue = NULL) = 0;
 
     /// Fire an event.

Core/branches/0075_TR_SCRIPTING/Event/I_EventQueue.hpp

@@ -44 +44 @@
 //-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
 class I_Action;
-class I_Event;
 
 class EVENT_DLL_LINK I_EventQueue
@@ -62 +61 @@
     /// @{
 public:
-    /// Create an event by name.
-    virtual I_Event& createEvent(const std::string& _name) = 0;
-
-    /// Get an event by name.
-    virtual I_Event& getEvent(const std::string& _name) = 0;
-
     /// Dispatch the next event in this queue.
     /// Call this from the thread that needs to dispatch this

Core/branches/0075_TR_SCRIPTING/Event/I_EventService.hpp

@@ -43 +43 @@
 class I_EventQueue;
 class I_ActionMap;
+class I_Event;
 
 /// Event Service.
@@ -62 +63 @@
     /// @{
 public:
+    /// Create an event by name.
+    virtual I_Event& createEvent(const std::string& _name) = 0;
+
+    /// Get an event by name.
+    virtual I_Event& getEvent(const std::string& _name) = 0;
+
     /// Get an event queue by name.
+    /// There are two special event queues. "default" and "script".
+    /// The default event queue is used if I_Event::connect() has a NULL
+    /// for the event queue.  The script event queue is used as the default
+    /// event queue for scripted actions.  If either of these
+    /// event queues are created by either of these use cases, make
+    /// sure you process events on those queues, otherwise the queues will
+    /// fill up and consume memory.
     virtual I_EventQueue& getEventQueue(const std::string& _queueName) = 0;
 

Core/branches/0075_TR_SCRIPTING/Event/src/Event.cpp

@@ -34 +34 @@
 
 #include "EventQueue.hpp"
+#include "EventService.hpp"
 
 #include <Zen/Core/Scripting/forward_declarations.hpp>
@@ -44 +45 @@
 namespace Event {
 //-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-Event_impl::Event_impl(EventQueue& _queue)
-:   m_queue(_queue)
+Event_impl::Event_impl(EventService& _service)
+:   m_service(_service)
 ,   m_connections()
 ,   m_pMutex(Threading::MutexFactory::create())
@@ -114 +115 @@
 Event_impl::getScriptModule()
 {
-    return m_queue.getScriptModule();
+    return m_service.getScriptModule();
 }
 
 //-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
 I_Connection&
-Event_impl::connect(pAction_type _pAction)
+Event_impl::connect(pAction_type _pAction, I_EventQueue* _pQueue)
 {
     pConnection_type pConnection = new Connection_type(this, _pAction);
 
     Threading::CriticalSection guard(m_pMutex);
+
     m_connections.push_back(pConnection);
+    if (_pQueue)
+    {
+        EventQueue* pQueue = dynamic_cast<EventQueue*>(_pQueue);
+
+        if (pQueue)
+        {
+            m_queues.insert(pQueue);
+        }
+    }
+    else
+    {
+        // Dispatch to the default queue.
+        m_queues.insert(dynamic_cast<EventQueue*>(&m_service.getEventQueue("default")));
+    }
 
     return *pConnection;
@@ -133 +149 @@
 Event_impl::disconnect(Connection_impl* _pConnection)
 {
+    // TODO Keep a refrence count for the queues and
+    // when the last connection is disconnected for a
+    // given queue, remove it from the set.
+
     Threading::CriticalSection guard(m_pMutex);
 
@@ -146 +166 @@
 Event_impl::fireEvent(boost::any _argument)
 {
-    m_queue.queueEvent(this, _argument);
+    Threading::CriticalSection guard(m_pMutex);
+
+    for(Queues_type::iterator iter = m_queues.begin(); iter != m_queues.end(); iter++)
+    {
+        (*iter)->queueEvent(this, _argument);
+    }    
 }
 
@@ -182 +207 @@
 Event_impl::connectScript(boost::any _scriptObject, boost::any _scriptFunction)
 {
-    ScriptAction* pRawAction = new ScriptAction(m_queue.getScriptObject()->getModule(),
+    ScriptAction* pRawAction = new ScriptAction(m_service.getScriptObject()->getModule(),
         _scriptObject, _scriptFunction);
 
     pAction_type pAction(pRawAction, boost::bind(&Event_impl::destroyScriptAction, this, _1));
-    return connect(pAction);
+
+    return connect(pAction, &m_service.getEventQueue("script"));
 }
 

Core/branches/0075_TR_SCRIPTING/Event/src/EventQueue.cpp

@@ -46 +46 @@
 ,   m_pScriptObject(NULL)
 ,   m_eventQueue()
-,   m_pEventsMutex(Threading::MutexFactory::create())
 {
 }
@@ -53 +52 @@
 EventQueue::~EventQueue()
 {
-    Threading::MutexFactory::destroy(m_pEventsMutex);
-}
-
-//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-I_Event&
-EventQueue::createEvent(const std::string& _name)
-{
-    // Since getEvent() will create the event if
-    // it doesn't exist, just call it.
-    return getEvent(_name);
-}
-
-//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
-I_Event&
-EventQueue::getEvent(const std::string& _name)
-{
-    Threading::CriticalSection guard(m_pEventsMutex);
-
-    // TODO Make sure the event has been created.
-    Events_type::iterator iter = m_events.find(_name);
-    
-    if (iter == m_events.end())
-    {
-        Event_impl* pEvent = new Event_impl(*this);
-
-        m_events[_name] = pEvent;
-
-        return *pEvent;
-    }
-    else
-    {
-        return *iter->second;
-    }
 }
 

Core/branches/0075_TR_SCRIPTING/Event/src/EventQueue.hpp

@@ -55 +55 @@
     typedef std::pair<Event_impl*, boost::any>              Event_type;
     typedef Threading::SynchronizedQueue<Event_type>        EventQueue_type;
-    typedef std::map<std::string, Event_impl*>              Events_type;
 
     typedef Memory::managed_ptr<Scripting::I_ScriptModule>  pScriptModule_type;
@@ -63 +62 @@
     /// @{
 public:
-    virtual I_Event& createEvent(const std::string& _name);
-    virtual I_Event& getEvent(const std::string& _name);
     virtual bool dispatchOneEvent();
     virtual void dispatchAllEvents(bool _wait);
@@ -101 +98 @@
     EventQueue_type                 m_eventQueue;
 
-    /// Collection of all registered events.
-    Events_type                     m_events;
-
-    /// Mutex for guarding m_events
-    Threading::I_Mutex*             m_pEventsMutex;
     // @}
 

Core/branches/0075_TR_SCRIPTING/Event/src/EventService.cpp

@@ -47 +47 @@
 EventService::EventService()
 :   m_pScriptObject(NULL)
+,   m_pEventsMutex(Threading::MutexFactory::create())
 {
 }
@@ -70 +71 @@
         }
     }
+
+    Threading::MutexFactory::destroy(m_pEventsMutex);
 }
 
@@ -117 +120 @@
 
     module.addType<I_EventService>(getScriptTypeName(), "Event Service")
+        .addMethod("createEvent", &I_EventService::createEvent)
+        .addMethod("getEvent", &I_EventService::getEvent)
         .addMethod("getEventQueue", &I_EventService::getEventQueue)
         .addMethod("getActionMap", &I_EventService::getActionMap)
@@ -123 +128 @@
 
     // EventQueue
-    module.addType<I_EventQueue>("EventQueue", "Event Queue")
-        .addMethod("createEvent", &I_EventQueue::createEvent)
-        .addMethod("getEvent", &I_EventQueue::getEvent)
-        .addMethod("dispatchOneEvent", &I_EventQueue::dispatchOneEvent)
-        .addMethod("dispatchAllEvents", &I_EventQueue::dispatchAllEvents)
+    module.addType<EventQueue>("EventQueue", "Event Queue")
+        .addMethod("dispatchOneEvent", &EventQueue::dispatchOneEvent)
+        .addMethod("dispatchAllEvents", &EventQueue::dispatchAllEvents)
     ;
 
@@ -159 +162 @@
 
 //-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
+I_Event&
+EventService::createEvent(const std::string& _name)
+{
+    // Since getEvent() will create the event if
+    // it doesn't exist, just call it.
+    return getEvent(_name);
+}
+
+//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
+I_Event&
+EventService::getEvent(const std::string& _name)
+{
+    Threading::CriticalSection guard(m_pEventsMutex);
+
+    // TODO Make sure the event has been created.
+    Events_type::iterator iter = m_events.find(_name);
+    
+    if (iter == m_events.end())
+    {
+        Event_impl* pEvent = new Event_impl(*this);
+
+        m_events[_name] = pEvent;
+
+        return *pEvent;
+    }
+    else
+    {
+        return *iter->second;
+    }
+}
+
+//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
 I_EventQueue&
 EventService::getEventQueue(const std::string& _queueName)

Core/branches/0075_TR_SCRIPTING/Event/src/EventService.hpp

@@ -39 +39 @@
 class ActionMap;
 class EventQueue;
+class Event_impl;
 
 /// Event Service implementation.
@@ -51 +52 @@
     typedef std::map<std::string, EventQueue*>          EventQueues_type;
     typedef std::map<std::string, ActionMap*>           ActionMaps_type;
+    typedef std::map<std::string, Event_impl*>          Events_type;
     /// @}
 
@@ -69 +71 @@
     /// @{
 public:
+    virtual I_Event& createEvent(const std::string& _name);
+    virtual I_Event& getEvent(const std::string& _name);
     virtual I_EventQueue& getEventQueue(const std::string& _queueName);
     virtual I_ActionMap& getActionMap(const std::string& _actionMapName);
@@ -96 +100 @@
     EventQueues_type                    m_eventQueues;
     ActionMaps_type                     m_actionMaps;
+
+    /// Collection of all registered events.
+    Events_type                         m_events;
+
+    /// Mutex for guarding m_events
+    Threading::I_Mutex*                 m_pEventsMutex;
+
     /// @}
 

Core/branches/0075_TR_SCRIPTING/Event/src/Event_impl.hpp

@@ -27 +27 @@
 #include "../I_Event.hpp"
 
+#include <set>
+
 //-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
 namespace Zen {
@@ -48 +50 @@
     typedef std::list<pConnection_type>                 container_type;
     typedef Zen::Memory::managed_ptr<Scripting::I_ScriptModule> pScriptModule_type;
+    typedef std::set<EventQueue*>                       Queues_type;
     /// @}
 
@@ -53 +56 @@
     /// @{
 public:
-    virtual I_Connection& connect(pAction_type _pAction);
+    virtual I_Connection& connect(pAction_type _pAction, I_EventQueue* _pQueue = NULL);
     virtual void fireEvent(boost::any _argument);
     /// @}
@@ -88 +91 @@
     /// @{
 protected:
-             Event_impl(EventQueue& _queue);
+    friend class EventService;
+             Event_impl(EventService& _service);
     virtual ~Event_impl();
     /// @}
@@ -95 +99 @@
     /// @{
 private:
-    /// Queue that owns this event.
-    EventQueue&                         m_queue;
+    /// Service that owns this event.
+    EventService&                       m_service;
 
     /// Connections for this event.
     container_type                      m_connections;
 
-    /// Mutex to guard m_connections.
+    Queues_type                         m_queues;
+
+    /// Mutex to guard m_connections and m_queues
     pMutex_type                         m_pMutex;