From: Michal Voců <michal@ruk.cuni.cz>
Date: Fri, 24 Aug 2007 15:16:39 +0000 (+0000)
Subject: some ideas for event handling
X-Git-Tag: glite-yaim-myproxy_R_4_0_1_1~38
X-Git-Url: http://scientific.zcu.cz/git/?a=commitdiff_plain;h=507e4233c8bc0358c6507882ce941b3d5be50e8e;p=jra1mw.git

some ideas for event handling
---

diff --git a/org.glite.lb.logger/src-nt/EventManager.H b/org.glite.lb.logger/src-nt/EventManager.H
index 355260d..ca37bf4 100644
--- a/org.glite.lb.logger/src-nt/EventManager.H
+++ b/org.glite.lb.logger/src-nt/EventManager.H
@@ -6,39 +6,87 @@
 
 // interface
 
+/**
+ * Base class of event hierarchy.
+ */
 class Event {
+public:
+    virtual ~Event() {}
 };
 
 
-template <class THandler, class TEvent>
+/**
+ * Base class for event handler address.
+ */
 class EventHandler {
 public:
-	typedef int (THandler::*EventHandlerType)(TEvent* &);
+    // constants for event handler return codes
+    static const int NOT_HANDLED = 0;
+    static const int HANDLED = 1;
+    static const int HANDLED_FINAL = 2;
+    static const int HANDLED_NEW = 3;
+
+    virtual int handleEvent(Event* &e) {}
+    virtual ~EventHandler() {}
+};
 
-	
 
+/**
+ * Holds addres of event handler, ie. pointer to member function of T 
+ * that takes E* & as an argument.
+ */
+template<class T, class E>
+class TypedEventHandler: public EventHandler {
+public:
+    typedef int (T::*handlerType)(E* &);
+    
+    TypedEventHandler(T handler, handlerType method) 
+	: m_handler(handler), m_handleEvent(method) {
+    }
+
+    virtual int handleEvent(Event* &e) {
+	E *ne = dynamic_cast<E*>e;
+	int result = EventHandler::NOT_HANDLED;
+	if(ne) {
+	    result = (m_handler->*m_handleEvent)(ne);
+	    if((result == EventHandler::HANDLED_NEW) && 
+	       !(ne == e)) {
+		delete e;
+		e = ne;
+	    }
+	}
+	return result;
+    }
+    
 private:
-	std::list<EventHandlerType> m_handlers;
+    handlerType m_handleEvent;
+    T *m_handler;
 };
 
 
 class EventManager {
 public:
-	// constants for event handler return codes
-	static const int NOT_HANDLED = 0;
-	static const int HANDLED = 1;
-	static const int HANDLED_FINAL = 2;
-	static const int HANDLED_NEW = 3;
-
-	int postEvent(Event* &event);
-	
-	template<class T>
-	registerHandler(, int priority);
+    
+    int postEvent(Event* &event);
+    
+    template<class T, class E>
+    EventHandler& registerHandler(T *handler, int (T::*method)(E* &)) {
+	EventHandler *h = new TypedEventHandler<T,E>(handler, method)
+	addHandler(h);
+	return *h;
+    }
+    
+    template<class T>
+    EventHandler& registerHandler(T *handler) {
+	return registerHandler(handler, &T::handleEvent);
+    }
 
 private:
-	std::list<
-};
+    std::list<EventHandler*> handlers;
 
+    void addHandler(EventHandler*);
+    void removeHandler(EventHandler *);
+};
 
 
 // implementation