libevent C++面向对象的封装

libevent C++面向对象的封装

作者：方振涛
对event_base操作的封装如下：

class TEventContext
{
public:
static void InitLib()
{
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
WSAStartup(wVersionRequested, &wsaData);
}

public:
TEventContext(event_base* evbase=NULL):m_evBase(evbase){}
~TEventContext(){
if (m_evBase)
{
event_base_free(m_evBase);
}
}
bool Init()
{
if(m_evBase)
return false;
m_evBase=event_base_new();
return m_evBase!=NULL;
}
bool ReInit()
{
return event_reinit(m_evBase)==0;
}
bool Dispatch()//进入事件处理循环
{
return event_base_dispatch(m_evBase)==0;
}
const char*GetMethod()
{
return event_base_get_method(m_evBase);
}
int GetFeatures(){return event_base_get_features(m_evBase);}

enum
{
FLoopOnce=EVLOOP_ONCE,
FLoopNonBlock=EVLOOP_NONBLOCK,
};
//进入事件循环
bool Loop(int flags)
{
return event_base_loop(m_evBase,flags)==0;
}

//退出循环
bool ExitLoop( const struct timeval *timev)
{
return event_base_loopexit(m_evBase,timev)==0;
}
bool BreakLoop()
{
return event_base_loopbreak(m_evBase)==0;

}

bool GotExit()
{
return event_base_got_exit(m_evBase)!=0;
}

bool GotBreak()
{
return event_base_got_break(m_evBase)!=0;
}

event_base* GetEvBase()
{
return m_evBase;
}

private:
event_base* m_evBase;
};

封装对event的操作：

class TEvent
{
public:
TEvent()
{
memset(&m_event,0,sizeof(m_event));
}

template<class EventHandler>
bool Assign(TEventContext* ctx,EventHandler* handler)
{
return event_assign(&m_event,ctx->GetEvBase(),handler->GetFd(),handler->GetType(),EventHandler::HandlerFunc,handler)==0;
}

bool Add(const struct timeval *tmv)
{
return event_add(&m_event,tmv)==0;
}

bool Remove()
{
return event_del(&m_event)==0;
}

void Active(int res, short ncalls)
{
event_active(&m_event,res,ncalls);
}

bool CheckPending(short events, struct timeval *tv)
{
return event_pending(&m_event,events,tv)!=0;
}

bool IsInitialized()
{
return event_initialized(&m_event)!=0;
}

evutil_socket_t GetFd()
{
return event_get_fd(&m_event);
}

short GetEvent()
{
return event_get_events(&m_event);
}
private:
TEvent(TEvent&){}
TEvent& operator=(TEvent&){}
struct event m_event;//仅保存数据
};

下面来说说关于如何处理到来的事件：

一般很容易会想到事件到来后通过虚函数来实现对事件的处理，但对于服务器来说尽量做到高效率，使用虚函数会造成不必要的性能损失。

受到WTL库使用模板来替代虚函数，来完成对事件的处理。

事件的处理实现如下：

template<class Handler>
class TEventHandler
{
public:
enum EventFlag
{
FTimeOut=EV_TIMEOUT,
FRead=EV_READ,
FWrite=EV_WRITE,
FSignal=EV_SIGNAL,
FPersist=EV_PERSIST,
FEt=EV_ET,
};

public:
TEventHandler(evutil_socket_t fd,short type):m_fd(fd),m_type(type){}

static void HandlerFunc(evutil_socket_t fd, short eventType, void *arg)
{
TEventHandler* handler=(TEventHandler*)arg;

handler->m_fd=fd;
handler->m_type=eventType;
handler->OnEventHandle();
}

inline void OnEventHandle()//不能使用OnHandle，防止子类未重写导致死循环
{
Handler* chandler= static_cast<Handler*>(this);
chandler->OnHandle();
}

evutil_socket_t GetFd(){return m_fd;}
short GetType(){return m_type;}
protected:
evutil_socket_t m_fd;
short m_type;
};

在OnEventHandle函数中通过转换来实现调用相应子类实现的处理函数

template<class Handler>
class TTimerHandler:public TEventHandler<Handler>
{
public:
TTimerHandler():TEventHandler(-1,0){}
};

template<class Handler>
class TSingalHandler:public TEventHandler<Handler>
{
public:
TSingalHandler(evutil_socket_t fd):TEventHandler(fd,EV_SIGNAL|EV_PERSIST){}
};

测试代码如下：

struct timeval lasttime;

int event_is_persistent;

class MyHandler:public TTimerHandler<MyHandler>
{
public:
TEvent* m_event;
MyHandler(TEvent *ev):m_event(ev)
{}

void OnHandle()
{
struct timeval newtime, difference;
double elapsed;

evutil_gettimeofday(&newtime, NULL);
evutil_timersub(&newtime, &lasttime, &difference);
elapsed = difference.tv_sec +
(difference.tv_usec / 1.0e6);

printf("timeout_cb called at %d: %.3f seconds elapsed.\n",
(int)newtime.tv_sec, elapsed);
lasttime = newtime;

if (! event_is_persistent) {
struct timeval tv;
evutil_timerclear(&tv);
tv.tv_sec = 2;
m_event->Add(&tv);
}

}

};

int _tmain(int argc, char* argv[])
{

if (argc == 2 && !strcmp(argv[1], "-p")) {
event_is_persistent = 1;
} else {
event_is_persistent = 0;
}

TEventContext::InitLib();

TEventContext base;

base.Init();

TEvent ev;

MyHandler handler(&ev);
ev.Assign(&base,&handler);

struct timeval tv;
evutil_timerclear(&tv);
tv.tv_sec = 2;
ev.Add(&tv);

evutil_gettimeofday(&lasttime, NULL);

base.Dispatch();
return 0;
}

此文档属本人原创，欢迎转载。