add an extra queue for pending events. That way I achive a better ballance betwe…

…en reading and processing and i don
't need the additional timeout for polls

@@ -48,11 +48,10 @@ TR_CLASS(TR_EventDispatcher) {
 	TR_EXTENDS(TR_EventSubject);
 	TR_EXTENDS(TR_EventSubject);
 
 
 	TR_Queue               events;
 	TR_Queue               events;
+	TR_Queue               pending;
 	TR_Hash                handler;
 	TR_Hash                handler;
 	TR_EventHandler        default_handler;
 	TR_EventHandler        default_handler;
 	int                    running;
 	int                    running;
-	int                    pollinterval; // milliseconds
-	int                    nextpoll;     // milliseconds
 	int                    heartbeat;    // milliseconds
 	int                    heartbeat;    // milliseconds
 	int                    nextbeat;     // milliseconds
 	int                    nextbeat;     // milliseconds
 	TR_EventDispatcherMode mode;
 	TR_EventDispatcherMode mode;
@@ -72,12 +71,13 @@ void TR_eventDispatcherRegisterHandler(TR_EventDispatcher, TR_EventHandler);
 void TR_eventDispatcherSetHeartbeat(TR_EventDispatcher, int);
 void TR_eventDispatcherSetHeartbeat(TR_EventDispatcher, int);
 int  TR_eventDispatcherGetBeatTime(TR_EventDispatcher);
 int  TR_eventDispatcherGetBeatTime(TR_EventDispatcher);
 int  TR_eventDispatcherGetDataWaitTime(TR_EventDispatcher);
 int  TR_eventDispatcherGetDataWaitTime(TR_EventDispatcher);
-void TR_eventDispatcherUpdateNextPoll(TR_EventDispatcher);
 void TR_eventDispatcherStart(TR_EventDispatcher);
 void TR_eventDispatcherStart(TR_EventDispatcher);
 void TR_eventDispatcherShutdown(TR_EventDispatcher);
 void TR_eventDispatcherShutdown(TR_EventDispatcher);
 
 
 #define TR_eventDispatcherEnqueueEvent(disp,ev)	\
 #define TR_eventDispatcherEnqueueEvent(disp,ev)	\
 	(TR_queuePut((disp)->events, (ev)))
 	(TR_queuePut((disp)->events, (ev)))
+#define TR_eventDispatcherEnqueuePending(disp,ev)	\
+	(TR_queuePut((disp)->pending, (ev)))
 #define TR_eventDispatcherStop(disp) \
 #define TR_eventDispatcherStop(disp) \
 	(((TR_EventDispatcher)disp)->running = 0)
 	(((TR_EventDispatcher)disp)->running = 0)
 
 

@@ -9,7 +9,6 @@ TREVENT = event.c \
 	  event_dispatcher_set_hearbeat.c \
 	  event_dispatcher_set_hearbeat.c \
 	  event_dispatcher_get_beat_time.c \
 	  event_dispatcher_get_beat_time.c \
 	  event_dispatcher_get_data_wait_time.c \
 	  event_dispatcher_get_data_wait_time.c \
-	  event_dispatcher_update_next_poll.c \
 	  event_dispatcher_start.c \
 	  event_dispatcher_start.c \
 	  event_dispatcher_shutdown.c \
 	  event_dispatcher_shutdown.c \
 	  event_handler.c \
 	  event_handler.c \

@@ -64,22 +64,15 @@ static
 int
 int
 eventDispatcherCtor(void * _this, va_list * params) {
 eventDispatcherCtor(void * _this, va_list * params) {
 	TR_EventDispatcher this = _this;
 	TR_EventDispatcher this = _this;
-	struct timespec    tp;
-	int                now; // milliseconds
 
 
 	this->events          = TR_new(TR_Queue);
 	this->events          = TR_new(TR_Queue);
+	this->pending         = TR_new(TR_Queue);
 	this->handler         = TR_new(TR_Hash);
 	this->handler         = TR_new(TR_Hash);
 	this->mode            = va_arg(*params, TR_EventDispatcherMode);
 	this->mode            = va_arg(*params, TR_EventDispatcherMode);
 	this->default_handler = va_arg(*params, TR_EventHandler);
 	this->default_handler = va_arg(*params, TR_EventHandler);
 	this->running         = 0;
 	this->running         = 0;
 	this->heartbeat       = 0;
 	this->heartbeat       = 0;
 	this->nextbeat        = 0;
 	this->nextbeat        = 0;
-	this->pollinterval    = va_arg(*params, int);
-
-	clock_gettime(CLOCK_REALTIME, &tp);
-	now = tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
-
-	this->nextpoll        = now + this->pollinterval;
 
 
 	if (! _TR_controlDispatcher) {
 	if (! _TR_controlDispatcher) {
 		_TR_controlDispatcher = this;
 		_TR_controlDispatcher = this;
@@ -105,6 +98,7 @@ eventDispatcherDtor(void * _this) {
 
 
 	TR_hashCleanup(this->handler);
 	TR_hashCleanup(this->handler);
 	TR_delete(this->handler);
 	TR_delete(this->handler);
+	TR_delete(this->pending);
 	TR_delete(this->events);
 	TR_delete(this->events);
 }
 }
 
 

@@ -53,11 +53,18 @@ TR_eventDispatcherStart(TR_EventDispatcher this)
 					(TR_EventSubject)this,
 					(TR_EventSubject)this,
 					TR_DISPATCHER_EVENT_HEARTBEAT,
 					TR_DISPATCHER_EVENT_HEARTBEAT,
 					NULL);
 					NULL);
-		} else if (TR_queueEmpty(this->events) || this->nextpoll <= now) {
+		} else if (TR_queueEmpty(this->events)) {
 			int evtid = TR_EVD_CLIENT == this->mode
 			int evtid = TR_EVD_CLIENT == this->mode
 				? TR_DISPATCHER_EVENT_USER_WAIT
 				? TR_DISPATCHER_EVENT_USER_WAIT
 				: TR_DISPATCHER_EVENT_DATA_WAIT;
 				: TR_DISPATCHER_EVENT_DATA_WAIT;
-			int * toutptr = TR_queueEmpty(this->events) ? NULL : &ZERO;
+			int * toutptr = NULL;
+
+			if (! TR_queueEmpty(this->pending)) {
+				toutptr = &ZERO;
+				TR_delete(this->events);
+				this->events  = this->pending;
+				this->pending = TR_new(TR_Queue);
+			}
 
 
 			event = TR_eventSubjectEmit((TR_EventSubject)this, evtid, toutptr);
 			event = TR_eventSubjectEmit((TR_EventSubject)this, evtid, toutptr);
 		} else {
 		} else {
@@ -91,7 +98,7 @@ TR_eventDispatcherStart(TR_EventDispatcher this)
 			if (TR_EVENT_DONE == done) {
 			if (TR_EVENT_DONE == done) {
 				TR_delete(event);
 				TR_delete(event);
 			} else {
 			} else {
-				TR_eventDispatcherEnqueueEvent(this, event);
+				TR_eventDispatcherEnqueuePending(this, event);
 			}
 			}
 		}
 		}
 	}
 	}

-/**
- * \file
- *
- * \author	Georg Hopp
- *
- * \copyright
- * Copyright © 2014 Georg Hopp
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <time.h>
-
-#include "trbase.h"
-
-#include "tr/event_dispatcher.h"
-
-void
-TR_eventDispatcherUpdateNextPoll(TR_EventDispatcher this)
-{
-	struct timespec tp;
-	int             now; // milliseconds
-
-	clock_gettime(CLOCK_REALTIME, &tp);
-	now = tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
-
-	while(this->nextpoll <= now) this->nextpoll += this->pollinterval;
-}
-
-// vim: set ts=4 sw=4: