void
TestEventQueue::cleanupQuitTimeout()
{
removeHandler(Event::kTimer, m_quitTimeoutTimer);
delete m_quitTimeoutTimer;
m_quitTimeoutTimer = nullptr;
}
int32_t IOLoop::addSignalHandler(int signum, HandlerCallback&& handler)
{
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, signum);
// block watched signals: otherwise the default handler is called
if(sigprocmask(SIG_BLOCK, &mask, 0))
{
TORNADO_LOG_ERROR("sigprocmask faild err=%s", STR_ERRNO);
return -1;
}
int32_t sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
if(sfd < 0)
{
TORNADO_LOG_ERROR("signalfd faild err=%s", STR_ERRNO);
return sfd;
}
if( addHandler(sfd, std::move(handler), IOLoop::READ) )
{
TORNADO_LOG_ERROR("addHandler faild sfd=%d", sfd);
removeHandler(sfd);
::close(sfd);
return -1;
}
return sfd;
}
void
Logger::removeConsoleHandler()
{
Guard g(m_handler_mutex);
if (removeHandler(m_pConsoleHandler))
{
m_pConsoleHandler = NULL;
}
}
void
Logger::removeSyslogHandler()
{
Guard g(m_handler_mutex);
if (removeHandler(m_pSyslogHandler))
{
m_pSyslogHandler = NULL;
}
}
/*!
\qmlmethod bool IdentifiableContentItem::remove()
Removes the object from the social network.
The default implementation sends a HTTP DELETE request for the
specified object identifier.
*/
bool IdentifiableContentItemInterface::remove()
{
Q_D(IdentifiableContentItemInterface);
if (!request(IdentifiableContentItemInterface::Delete, d->identifier))
return false;
connect(d->reply(), SIGNAL(finished()), this, SLOT(removeHandler()));
d->connectErrors();
return true;
}
void EventManager::loop(unsigned long time) {
if (!isRunning_) start(time);
long elapsed = time - lastLoopTime_;
handlerList_.resetIterator();
while (EventHandler* handler = handlerList_.next()) handler->countdown_ -= elapsed;
handlerList_.resetIterator();
while (EventHandler* handler = handlerList_.next()) {
if (handler->countdown_ <= 0) {
handler->fire();
if (handler->period_ > 0)
handler->countdown_ += handler->period_;
else {
removeHandler(handler);
free(handler);
}
}
}
lastLoopTime_ = time;
}
void FileTransferHandlerManager::removeHandlers(Account account)
{
for (auto &&transfer : m_fileTransferManager->items())
if (transfer.peer().contactAccount() == account)
removeHandler(transfer);
}
void FileTransferHandlerManager::fileTransferRemoved(FileTransfer fileTransfer)
{
removeHandler(fileTransfer);
}
void SDLContext::registerHandler(SDLEventHandler *handler) {
removeHandler(handler);
mHandlers.push_back(handler);
}
void ObjectCreationEvent::operator-=( const Delegate<void, const UID&>& d ) {
EventManager::getInstance()->removeHandler<Delegate<void, const UID&>, ObjectCreationEvent>( d, getType() );
removeHandler(d);
}
URIProcessor::~URIProcessor()
{
while (!handlersM.empty())
removeHandler(handlersM.front());
}
int CwxAppEpoll::poll(REACTOR_CALLBACK callback, void* arg, CWX_UINT32 uiMiliTimeout)
{
static CWX_UINT64 ullLastTime=0;
bool bClockChange = false;
int i = 0;
int num = 0;
CWX_UINT64 ullNow = 0;
CWX_UINT64 ullTimeout = 0;
int tv=-1;
struct epoll_event *event=NULL;
CwxAppHandler4Base* handler = NULL;
m_current.now();
ullNow = m_current.to_usec();
if (ullLastTime > ullNow + 1000000){ ///多余1秒
ullLastTime = ullNow;
bClockChange = true;
}else{
bClockChange = false;
ullLastTime = ullNow;
}
///计算超时时间
timeout(ullTimeout);
if (ullTimeout){
if (ullTimeout < ullNow){
tv =1;
}else{
ullTimeout -= ullNow;
tv = ullTimeout/1000;
if (tv < 1) tv = 1;
}
if (uiMiliTimeout && (tv > (int)uiMiliTimeout)) tv = uiMiliTimeout;
}else if (uiMiliTimeout){
tv = uiMiliTimeout;
}
m_bStop = false;
num = epoll_wait(m_epfd, m_events, CWX_APP_MAX_IO_NUM, tv);
if (num > 0){
for (i = 0; i < num; i++){
int mask = 0;
if (m_bStop) return 0;
event = &m_events[i];
/* if (m_signalFd[0] == event->data.fd)
{
CWX_ASSERT(event->events == EPOLLIN);
continue;
}*/
CWX_ASSERT(m_eHandler[event->data.fd].m_handler);
if (event->events & EPOLLIN) mask |= CwxAppHandler4Base::READ_MASK;
if (event->events & EPOLLOUT) mask |= CwxAppHandler4Base::WRITE_MASK;
handler = m_eHandler[event->data.fd].m_handler;
//检测timeout
if (m_eHandler[event->data.fd].m_handler->index()>=0)
{//从heap中删除
if (0 != cancelTimer(m_eHandler[event->data.fd].m_handler))
{
CWX_ERROR(("Failure to cancel hander's timer, fd[%d]", event->data.fd));
}
}
if (!CWX_CHECK_ATTR(m_eHandler[event->data.fd].m_mask, CwxAppHandler4Base::PERSIST_MASK))
{
if (removeHandler(event->data.fd) != handler)
{
CWX_ASSERT(0);
CWX_ERROR(("handler[%d] is not right", event->data.fd));
return -1;
}
}
callback(handler,
mask,
CWX_CHECK_ATTR(m_eHandler[event->data.fd].m_mask, CwxAppHandler4Base::PERSIST_MASK),
arg);
}
}
//检测signal
if (m_bSignal && m_bEnableSignal)
{
if (m_bStop) return 0;
m_bSignal = 0;
for (i=0; i<CWX_APP_MAX_SIGNAL_ID; i++)
{
if (m_arrSignals[i])
{
m_arrSignals[i] = 0;
CWX_ASSERT(m_sHandler[i]);
callback(m_sHandler[i],
CwxAppHandler4Base::SIGNAL_MASK,
true,
arg);
}
}
}
//检测超时
if (bClockChange){
list<CwxAppHandler4Base*> handles;
while(!m_timeHeap.isEmpty()){
if (m_bStop) return 0;
if (m_timeHeap.top()->getHandle() != CWX_INVALID_HANDLE){
handler = removeHandler(m_timeHeap.top()->getHandle());
if (!handler){
CWX_ERROR(("Failure to remove timeout handler, fd[%d]", event->data.fd));
}
}else{
handler = m_timeHeap.pop();
}
handles.push_back(handler);
}
list<CwxAppHandler4Base*>::iterator iter = handles.begin();
while(iter != handles.end()){
callback(*iter,
CwxAppHandler4Base::TIMEOUT_MASK,
false,
arg);
iter++;
}
}else{
while (!m_timeHeap.isEmpty() && (m_timeHeap.top()->getTimeout() < ullNow)){
if (m_bStop) return 0;
if (m_timeHeap.top()->getHandle() != CWX_INVALID_HANDLE){
handler = removeHandler(m_timeHeap.top()->getHandle());
if (!handler){
CWX_ERROR(("Failure to remove timeout handler, fd[%d]", event->data.fd));
}
}else{
handler = m_timeHeap.pop();
}
callback(handler,
CwxAppHandler4Base::TIMEOUT_MASK,
false,
arg);
}
}
return 0;
}
