00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 #ifndef SYSTEMEVENT_H_
00040 #define SYSTEMEVENT_H_
00041
00042 #include <boost/date_time.hpp>
00043 #include <iostream>
00044 #include "SystemEventType.h"
00045
00046 using boost::posix_time::ptime;
00047
00048 namespace ariba {
00049 namespace utility {
00050
00051 class SystemQueue;
00052 class SystemEventListener;
00053
00054 class SystemEvent {
00055 friend class SystemQueue;
00056 private:
00057 SystemEventListener* listener;
00058 SystemEventType type;
00059 const void* data;
00060
00061 public:
00062
00063
00064
00065 ptime scheduledTime;
00066 uint32_t delayTime;
00067 uint32_t remainingDelay;
00068
00069 public:
00070 inline SystemEvent(
00071 SystemEventListener* mlistener,
00072 SystemEventType mtype = SystemEventType::DEFAULT,
00073 void* mdata = NULL)
00074 : scheduledTime(boost::posix_time::not_a_date_time),
00075 delayTime(0),
00076 remainingDelay(0),
00077 listener(mlistener),
00078 type(mtype),
00079 data(mdata) {
00080 }
00081
00082 template<typename T>
00083 inline SystemEvent( SystemEventListener* mlistener,
00084 SystemEventType mtype = SystemEventType::DEFAULT,
00085 T* mdata = NULL)
00086 : scheduledTime(boost::posix_time::not_a_date_time),
00087 delayTime(0),
00088 remainingDelay(0),
00089 listener(mlistener),
00090 type(mtype),
00091 data((void*)mdata) {
00092 }
00093
00094
00095
00096 inline SystemEvent(const SystemEvent& copy) {
00097 this->scheduledTime = copy.scheduledTime;
00098 this->delayTime = copy.delayTime;
00099 this->remainingDelay = copy.remainingDelay;
00100 this->listener = copy.listener;
00101 this->type = copy.type;
00102 this->data = copy.data;
00103 }
00104
00105 inline void operator=(const SystemEvent& right) {
00106 this->scheduledTime = right.scheduledTime;
00107 this->delayTime = right.delayTime;
00108 this->remainingDelay = right.remainingDelay;
00109 this->listener = right.listener;
00110 this->type = right.type;
00111 this->data = right.data;
00112 }
00113
00114 inline ~SystemEvent() {
00115 }
00116
00117 template<typename T>
00118 inline operator T() const {
00119 return (T) (data);
00120 }
00121
00122 inline SystemEventListener* getListener() const {
00123 return listener;
00124 }
00125
00126 template<typename T>
00127 inline T* getData() const {
00128 return (T*)*this;
00129 }
00130
00131 inline const SystemEventType getType() const {
00132 return type;
00133 }
00134
00135 inline const ptime getScheduledTime() const {
00136 return scheduledTime;
00137 }
00138
00139 inline const uint32_t getRemainingDelay() const {
00140 return remainingDelay;
00141 }
00142
00143 inline bool operator<(const SystemEvent& right) const {
00144 return remainingDelay < right.remainingDelay;
00145 }
00146
00147 };
00148
00149 }}
00150
00151 #endif