• Main Page
  • Related Pages
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

src/Event.cpp

00001 #include <sstream>
00002 #include <stdarg.h>
00003 
00004 #include "FCam/Event.h"
00005 #include "Debug.h"
00006 
00007 namespace FCam {
00008 
00009     // Gets the next pending event. Returns false if there are no
00010     // outstanding events. 
00011     bool getNextEvent(Event *e) {        
00012         return _eventQueue.tryPull(e);
00013     }
00014 
00015     // Filter the event queue for specific types of events, several variants
00016     bool getNextEvent(Event *e, int type) {
00017         TSQueue<Event>::locking_iterator i = _eventQueue.begin();
00018         for (; i != _eventQueue.end(); i++) {
00019             if (i->type == type) {
00020                 Event eTemp = *i;
00021                 if (!_eventQueue.erase(i)) {
00022                     dprintf(4, "getNextEvent: Skipping 'reserved' event.\n");
00023                     return false;
00024                 }
00025                 *e = eTemp;
00026                 return true;
00027             }
00028         }
00029         return false;
00030     }
00031 
00032     bool getNextEvent(Event *e, int type, int data) {
00033         TSQueue<Event>::locking_iterator i = _eventQueue.begin();
00034         for (; i != _eventQueue.end(); i++) {
00035             if (i->type == type && i->data == data) {
00036                 Event eTemp = *i;
00037                 if (!_eventQueue.erase(i)) {
00038                     dprintf(4, "getNextEvent: Skipping 'reserved' event.\n");
00039                     return false; // Can't erase == 'doesn't actually exist'
00040                 }
00041                 *e = eTemp;
00042                 return true;
00043             }
00044         }
00045         return false;
00046     }
00047 
00048     bool getNextEvent(Event *e, int type, EventGenerator *creator) {
00049         TSQueue<Event>::locking_iterator i = _eventQueue.begin();
00050         for (; i != _eventQueue.end(); i++) {
00051             if (i->type == type && i->creator == creator) {
00052                 Event eTemp = *i;
00053                 if (!_eventQueue.erase(i)) {
00054                     dprintf(4, "getNextEvent: Skipping 'reserved' event.\n");
00055                     return false;
00056                 }
00057                 *e = eTemp;
00058                 return true;
00059             }
00060         }
00061         return false;
00062     }
00063 
00064     bool getNextEvent(Event *e, int type, int data, EventGenerator *creator) {
00065         TSQueue<Event>::locking_iterator i = _eventQueue.begin();
00066         for (; i != _eventQueue.end(); i++) {
00067             if (i->type == type && i->data == data && i->creator == creator) {
00068                 Event eTemp = *i;
00069                 if (!_eventQueue.erase(i)) {
00070                     dprintf(4, "getNextEvent: Skipping 'reserved' event.\n");
00071                     return false; // Can't erase == 'doesn't actually exist'
00072                 }
00073                 *e = eTemp;
00074                 return true;
00075             }
00076         }
00077         return false;
00078     }
00079 
00080     bool getNextEvent(Event *e, EventGenerator *creator) {
00081         TSQueue<Event>::locking_iterator i = _eventQueue.begin();
00082         for (; i != _eventQueue.end(); i++) {
00083             if (i->creator == creator) {
00084                 Event eTemp = *i;
00085                 if (!_eventQueue.erase(i)) {
00086                     dprintf(4, "getNextEvent: Skipping 'reserved' event.\n");
00087                     return false; // Can't erase == 'doesn't actually exist'
00088                 }
00089                 *e = eTemp;
00090                 return true;
00091             }
00092         }
00093         return false;
00094     }
00095 
00096     void postEvent(Event e) {        
00097         if (e.type == Event::Error) _dprintf(DBG_ERROR, "Error (Event)", "%s\n", e.description.c_str());
00098         else if (e.type == Event::Warning) _dprintf(DBG_WARN, "Warning (Event)", "%s\n", e.description.c_str());
00099         else _dprintf(DBG_MINOR, "Event", "%s\n", e.description.c_str());
00100         _eventQueue.push(e);
00101     }
00102 
00103     void postEvent(int type, int data, const std::string &msg, EventGenerator *creator) {
00104         Event e;
00105         e.creator = creator;
00106         e.type = type;
00107         e.description = msg;
00108         e.data = data;
00109         e.time = Time::now();
00110         postEvent(e);
00111     }
00112 
00113     void error(int code, const char *fmt, ...) {
00114         char buf[256];
00115         va_list arglist;
00116         va_start(arglist, fmt);
00117         vsnprintf(buf, 256, fmt, arglist);
00118         va_end(arglist);
00119         postEvent(Event::Error, code, buf);
00120     }
00121 
00122     void warning(int code, const char *fmt, ...) {
00123         char buf[256];
00124         va_list arglist;
00125         va_start(arglist, fmt);
00126         vsnprintf(buf, 256, fmt, arglist);
00127         va_end(arglist);
00128         postEvent(Event::Warning, code, buf);
00129     }
00130 
00131     void error(int code, EventGenerator *creator, const char *fmt, ...) {
00132         char buf[256];
00133         va_list arglist;
00134         va_start(arglist, fmt);
00135         vsnprintf(buf, 256, fmt, arglist);
00136         va_end(arglist);
00137         postEvent(Event::Error, code, buf, creator);        
00138     }
00139 
00140     void warning(int code, EventGenerator *creator, const char *fmt, ...) {
00141         char buf[256];
00142         va_list arglist;
00143         va_start(arglist, fmt);
00144         vsnprintf(buf, 256, fmt, arglist);
00145         va_end(arglist);
00146         postEvent(Event::Warning, code, buf, creator);        
00147     }
00148 
00149     TSQueue<Event> _eventQueue;
00150 }
00151 
00152 

Generated on Fri Sep 24 2010 15:53:00 for FCam by  doxygen 1.7.1