void
SocketEventDispatcher::insert(const SharedPtr<AbstractSocketEvent>& socketEvent)
{
if (!socketEvent.valid())
return;
OpenRTIAssert(socketEvent->_socketEventDispatcher == 0);
socketEvent->_socketEventDispatcher = this;
socketEvent->_iterator = _socketEventList.insert(_socketEventList.begin(), socketEvent);
}
void
SocketEventDispatcher::erase(const SharedPtr<AbstractSocketEvent>& socketEvent)
{
if (!socketEvent.valid())
return;
if (socketEvent->_socketEventDispatcher == 0)
return;
OpenRTIAssert(socketEvent->_socketEventDispatcher == this);
socketEvent->_socketEventDispatcher = 0;
_socketEventList.erase(socketEvent->_iterator);
}
void
FDD1516EContentHandler::endDocument(void)
{
OpenRTIAssert(_modeStack.empty());
_fomStringModuleBuilder.validate();
}
void
FDD1516EContentHandler::startDocument(void)
{
OpenRTIAssert(_modeStack.empty());
}
int exec(SocketEventDispatcher& dispatcher, const Clock& absclock)
{
int retv = 0;
while (!dispatcher._done) {
_fdVector.resize(0);
_socketEventVector.resize(0);
_timerSocketEventVector.resize(0);
Clock timeout = absclock;
struct pollfd pfd;
std::memset(&pfd, 0, sizeof(pfd));
for (SocketEventList::const_iterator i = dispatcher._socketEventList.begin(); i != dispatcher._socketEventList.end(); ++i) {
AbstractSocketEvent* socketEvent = i->get();
bool included = false;
Socket* abstractSocket = socketEvent->getSocket();
if (abstractSocket) {
int fd = abstractSocket->_privateData->_fd;
if (fd != -1) {
pfd.fd = fd;
pfd.events = 0;
if (socketEvent->getEnableRead())
pfd.events |= POLLRDNORM;
if (socketEvent->getEnableWrite())
pfd.events |= POLLWRNORM;
if (pfd.events) {
included = true;
_fdVector.push_back(pfd);
_socketEventVector.push_back(socketEvent);
}
}
}
if (socketEvent->getTimeout() != Clock::max()) {
timeout = std::min(timeout, socketEvent->getTimeout());
if (!included)
_timerSocketEventVector.push_back(socketEvent);
}
}
// The wakeup event is always put at the end and does *not* have a
// corresponding _socketEventVector entry!
pfd.fd = _wakeupReadFd;
pfd.events = POLLRDNORM;
_fdVector.push_back(pfd);
int count;
if (timeout < Clock::max()) {
uint64_t now = ClockPosix::now();
if (timeout.getNSec() < now) {
count = 0;
} else {
count = ::poll(&_fdVector[0], _fdVector.size(), ClockPosix::toIntMSec(timeout.getNSec() - now));
}
} else {
count = ::poll(&_fdVector[0], _fdVector.size(), -1);
}
if (count == -1) {
int errorNumber = errno;
if (errorNumber != EINTR && errorNumber != EAGAIN) {
retv = -1;
break;
} else {
count = 0;
}
}
// Timeout
uint64_t now = ClockPosix::now();
if (absclock.getNSec() <= now) {
retv = 0;
break;
}
// We know the last one is from _fdVector is the wakup fd. Hence the _socketEventVector size is the one to walk.
for (SocketEventVector::size_type i = 0; i < _socketEventVector.size(); ++i) {
SharedPtr<AbstractSocketEvent> socketEvent;
socketEvent.swap(_socketEventVector[i]);
Socket* abstractSocket = socketEvent->getSocket();
if (abstractSocket) {
int fd = abstractSocket->_privateData->_fd;
if (fd != -1) {
OpenRTIAssert(fd == _fdVector[i].fd);
short revents = _fdVector[i].revents;
if (revents & POLLRDNORM)
dispatcher.read(socketEvent);
if (revents & POLLWRNORM)
dispatcher.write(socketEvent);
}
}
if (socketEvent->getTimeout().getNSec() <= now)
dispatcher.timeout(socketEvent);
}
for (SocketEventVector::size_type i = 0; i < _timerSocketEventVector.size(); ++i) {
SharedPtr<AbstractSocketEvent> socketEvent;
socketEvent.swap(_timerSocketEventVector[i]);
if (socketEvent->getTimeout().getNSec() <= now)
dispatcher.timeout(socketEvent);
}
OpenRTIAssert(!_fdVector.empty());
if (_fdVector.back().revents & POLLRDNORM) {
char dummy[64];
while (0 < ::read(_wakeupReadFd, dummy, sizeof(dummy)));
if (!_wokenUp.compareAndExchange(1, 0, Atomic::MemoryOrderAcqRel))
Log(Network, Warning) << "Having something to read from the wakeup pipe, but the flag is not set?" << std::endl;
retv = 0;
break;
}
}
_fdVector.resize(0);
_socketEventVector.resize(0);
_timerSocketEventVector.resize(0);
return retv;
}
