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);
}
