void IceInternal::ThreadPool::update(const EventHandlerPtr& handler, SocketOperation remove, SocketOperation add) { Lock sync(*this); assert(!_destroyed); // Don't remove what needs to be added remove = static_cast<SocketOperation>(remove & ~add); // Don't remove/add if already un-registered or registered remove = static_cast<SocketOperation>(handler->_registered & remove); add = static_cast<SocketOperation>(~handler->_registered & add); if(remove == add) { return; } _selector.update(handler.get(), remove, add); #if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT) if(add & SocketOperationRead && handler->_hasMoreData && !(handler->_disabled & SocketOperationRead)) { if(_pendingHandlers.empty()) { _workQueue->queue(interruptWorkItem); // Interrupt select() } _pendingHandlers.insert(handler.get()); } else if(remove & SocketOperationRead) { _pendingHandlers.erase(handler.get()); } #endif }
EventHandlerWrapper::EventHandlerWrapper(const EventHandlerPtr& handler, Selector& selector) : _handler(handler), _streamNativeInfo(StreamNativeInfoPtr::dynamicCast(handler->getNativeInfo())), _selector(selector), _ready(SocketOperationNone), _finish(false), _socket(0), _source(0) { if(_streamNativeInfo) { _streamNativeInfo->initStreams(this); } else if(handler->getNativeInfo()) { SOCKET fd = handler->getNativeInfo()->fd(); CFSocketContext ctx = { 0, this, 0, 0, 0 }; _socket = CFSocketCreateWithNative(kCFAllocatorDefault, fd, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack, eventHandlerSocketCallback, &ctx); // Disable automatic re-enabling of callbacks and closing of the native socket. CFSocketSetSocketFlags(_socket, 0); CFSocketDisableCallBacks(_socket, kCFSocketReadCallBack | kCFSocketWriteCallBack | kCFSocketConnectCallBack); _source = CFSocketCreateRunLoopSource(kCFAllocatorDefault, _socket, 0); } }
void Selector::initialize(EventHandler* handler) { if(!handler->getNativeInfo()) { return; } #ifdef ICE_USE_IOCP HANDLE socket = reinterpret_cast<HANDLE>(handler->getNativeInfo()->fd()); if(CreateIoCompletionPort(socket, _handle, reinterpret_cast<ULONG_PTR>(handler), 0) == NULL) { Ice::SocketException ex(__FILE__, __LINE__); ex.error = GetLastError(); throw ex; } handler->getNativeInfo()->initialize(_handle, reinterpret_cast<ULONG_PTR>(handler)); #else # ifdef ICE_CPP11_MAPPING EventHandlerPtr h = dynamic_pointer_cast<EventHandler>(handler->shared_from_this()); # else EventHandlerPtr h = handler; # endif handler->getNativeInfo()->setCompletedHandler( ref new SocketOperationCompletedHandler( [=](int operation) { // // Use the reference counted handler to ensure it's not // destroyed as long as the callback lambda exists. // completed(h.get(), static_cast<SocketOperation>(operation)); })); #endif }
void IceInternal::ThreadPool::initialize(const EventHandlerPtr& handler) { Lock sync(*this); assert(!_destroyed); _selector.initialize(handler.get()); class ReadyCallbackI : public ReadyCallback { public: ReadyCallbackI(const ThreadPoolPtr& threadPool, const EventHandlerPtr& handler) : _threadPool(threadPool), _handler(handler) { } virtual void ready(SocketOperation op, bool value) { _threadPool->ready(_handler, op, value); } private: const ThreadPoolPtr _threadPool; const EventHandlerPtr _handler; }; handler->getNativeInfo()->setReadyCallback(new ReadyCallbackI(this, handler)); }
void HUDInGame::unregisterEventHandlers(EventManagerPtr evtMgr) { boost::shared_ptr<HUDInGame> this_ = shared_from_this(); if (evtMgr.get()) { EventHandlerPtr eh = EventHandlerPtr(new EventHandler<HUDInGame,ChangeWorldEvent>(this_,&HUDInGame::processChangeWorld)); evtMgr->unregisterHandler(eh,EVENT_TYPE_CHANGEWORLD); eh.reset(new EventHandler<HUDInGame,MsgBoxVisibilityChangedEvent>(this_,&HUDInGame::processMessageBoxVisibilityChanged)); evtMgr->unregisterHandler(eh,EVENT_TYPE_MSGBOX_VISIBILITY_CHANGED); } }
void CachedHandlerLocator::Remove(UniqueId id) { ehLocator_.Remove(id); EventHandlerPtr ehPtr = idToHandlerMap_.at(id); // check if we remove active handler and reset it if so if (ehPtr.get() == activeHandler_) { activeHandler_ = nullptr; } idToHandlerMap_.erase(id); }
void IceInternal::ThreadPool::initialize(const EventHandlerPtr& handler) { Lock sync(*this); assert(!_destroyed); _selector.initialize(handler.get()); }
void IceInternal::ThreadPool::ready(const EventHandlerPtr& handler, SocketOperation op, bool value) { Lock sync(*this); if(_destroyed) { return; } _selector.ready(handler.get(), op, value); }
bool IceInternal::ThreadPool::finish(const EventHandlerPtr& handler, bool closeNow) { Lock sync(*this); assert(!_destroyed); #if !defined(ICE_USE_IOCP) && !defined(ICE_OS_WINRT) closeNow = _selector.finish(handler.get(), closeNow); // This must be called before! _workQueue->queue(new FinishedWorkItem(handler, !closeNow)); return closeNow; #else // If there are no pending asynchronous operations, we can call finish on the handler now. if(!(handler->_pending & SocketOperationWaitForClose)) { _workQueue->queue(new FinishedWorkItem(handler, false)); _selector.finish(handler.get()); } else { handler->_finish = true; } return true; // Always close now to interrupt the pending call. #endif }
void IceInternal::ThreadPool::update(const EventHandlerPtr& handler, SocketOperation remove, SocketOperation add) { Lock sync(*this); assert(!_destroyed); // Don't remove what needs to be added remove = static_cast<SocketOperation>(remove & ~add); // Don't remove/add if already un-registered or registered remove = static_cast<SocketOperation>(handler->_registered & remove); add = static_cast<SocketOperation>(~handler->_registered & add); if(remove == add) { return; } _selector.update(handler.get(), remove, add); }