bool EventQueue::takeEvents(Events& events, double cutOffTime)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_eventQueueMutex);
if (!_eventQueue.empty())
{
bool eventsTaken = false;
Events::iterator itr = _eventQueue.begin();
for(;
itr != _eventQueue.end() && ((*itr)->getTime() <= cutOffTime);
++itr)
{
events.push_back(*itr);
eventsTaken = true;
}
if (eventsTaken)
{
_eventQueue.erase(_eventQueue.begin(), itr);
}
return eventsTaken;
}
else
{
return false;
}
}
void Epoll::wait(Events& p_events) const
{
boost::scoped_array<epoll_event> events(new epoll_event[m_size]);
::memset(events.get(), 0, m_size * sizeof (epoll_event));
int eventsLen = ::epoll_wait(m_epollFd, events.get(), m_size, -1);
if (eventsLen < 0)
{
throw std::runtime_error("Epoll wait failed");
}
for (int i = 0; i < eventsLen; ++i)
{
if (events[i].data.fd == m_selfStopPipes[0])
{
p_events.clear();
break;
}
else
{
EventTypes ets;
nativeEvents(events[i].events, ets);
p_events.push_back(Event(ets, events[i].data.fd));
}
}
}
//-------------------------------------------------------------------------------------------------
void TimerActor::do_setup (acto::actor_ref& sender, const TimerActor::msg_setup& msg) {
event_t* const p_event = new event_t( actor_ref() );
// -
p_event->actor = msg.actor;
p_event->once = msg.once;
p_event->time = msg.time;
p_event->owner = self;
// -
// core::set_notify( 0, acto::dereference(actor), MakeDelegate(this, &timer_t::do_delete) );
// Установить системный таймер
if ( 0 != ::CreateTimerQueueTimer( &p_event->timer,
// Очередь таймеров
m_timers,
// -
&TimerActor::TimerProc,
// Параметр для процедуры
p_event,
// Период первого вызова
msg.time,
// Повторы
(msg.once ? 0 : msg.time),
// Флаги
0 ) )
{
// -
m_events.push_back( p_event );
}
else {
// Ошибка. Таймер не был созда.
delete p_event;
}
}
int main() {
std::string line;
Events events;
while (std::getline(std::cin, line)) {
std::vector<std::string> elements;
boost::split(elements, line, boost::is_any_of("/"));
if (elements.size() != 4) {
std::cerr << "Warning: elements.size() != 4" << std::endl;
continue;
}
Event e;
e.player = elements[0];
e.map = elements[1];
e.lapTime = parseLapTime(elements[2]);
e.date = parseDate(elements[3]);
events.push_back(e);
}
std::cout << "Number of events: " << events.size() << std::endl;
std::sort(events.begin(), events.end());
std::cout << "Last event: " << events.back() << std::endl;
Ranking ranking = getRankings(events, boost::posix_time::time_from_string("2014-01-03 22:00:00.000"));
for ( unsigned i = 0; i < 20 && i < ranking.size(); ++i ) {
std::cout << i+1 << ".: " << ranking[i].getPlayer() << ", Time: " << ranking[i].getTotalLapTime() << std::endl;
}
std::cout << "Current leader = " << ranking[0].getTotalLapTime() << std::endl;
}
Events CEventLog::Get(EventLevel level, bool includeHigherLevels /* = false */) const
{
Events events;
CSingleLock lock(m_critical);
for (const auto& eventPtr : m_events)
{
if (eventPtr->GetLevel() == level ||
(includeHigherLevels && eventPtr->GetLevel() > level))
events.push_back(eventPtr);
}
return events;
}
// For devices with buffered data.
void forceButton(unsigned id, bool down, bool collectEvent)
{
buttons.at(id) = down;
if (!collectEvent)
return;
EventInfo newEvent;
if (down)
newEvent.action = EventInfo::buttonDown;
else
newEvent.action = EventInfo::buttonUp;
newEvent.id = id;
events.push_back(newEvent);
}
bool EventQueue::takeEvents(Events& events, double cutOffTime)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_eventQueueMutex);
if (!_eventQueue.empty())
{
// find last event if queue that came in before the cuttof.
Events::reverse_iterator ritr = _eventQueue.rbegin();
for(; ritr != _eventQueue.rend() && ((*ritr)->getTime() > cutOffTime); ++ritr) {}
if (ritr==_eventQueue.rend()) return false;
for(Events::iterator itr = _eventQueue.begin();
itr != ritr.base();
++itr)
{
events.push_back(*itr);
}
// make sure that the events are in ascending time order, and any out of out events
// have their time reset to the next valid time after them in the events list.
double previousTime = cutOffTime;
for(Events::reverse_iterator itr = events.rbegin();
itr != events.rend();
++itr)
{
if ((*itr)->getTime() > previousTime)
{
OSG_INFO<<"Reset event time from "<<(*itr)->getTime()<<" to "<<previousTime<<std::endl;
(*itr)->setTime(previousTime);
}
else
{
previousTime = (*itr)->getTime();
}
}
// remove the events we are taking from the original event queue.
_eventQueue.erase(_eventQueue.begin(), ritr.base());
return true;
}
else
{
return false;
}
}
void updateButtons(bool collectEvents)
{
DIDEVICEOBJECTDATA data[inputBufferSize];
DWORD inOut;
HRESULT hr;
RECT rect;
::GetClientRect(window, &rect);
bool ignoreClicks = mouseX < 0 || mouseX > rect.right || mouseY < 0 || mouseY > rect.bottom;
inOut = inputBufferSize;
hr = mouse->GetDeviceData(sizeof data[0], data, &inOut, 0);
switch(hr)
{
case DI_OK:
case DI_BUFFEROVERFLOW:
{
// Everything's ok: Update buttons and fire events.
for (unsigned i = 0; i < inOut; ++i)
{
bool down = (data[i].dwData & 0x80) != 0 && !ignoreClicks;
switch (data[i].dwOfs)
{
case DIMOFS_BUTTON0:
{
unsigned id = swapMouse ? msRight : msLeft;
setButton(id, down, collectEvents);
break;
}
case DIMOFS_BUTTON1:
{
unsigned id = swapMouse ? msLeft : msRight;
setButton(id, down, collectEvents);
break;
}
case DIMOFS_BUTTON2:
{
setButton(msMiddle, down, collectEvents);
break;
}
case DIMOFS_Z:
{
if (!collectEvents || data[i].dwData == 0)
break;
EventInfo event;
event.action = EventInfo::buttonDown;
if (int(data[i].dwData) < 0)
event.id = msWheelDown;
else
event.id = msWheelUp;
events.push_back(event);
event.action = EventInfo::buttonUp;
events.push_back(event);
break;
}
}
}
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
// Cannot fetch new events: Release all buttons.
for (unsigned id = msRangeBegin; id < msRangeEnd; ++id)
setButton(id, false, collectEvents);
mouse->Acquire();
break;
}
}
keyboard:
inOut = inputBufferSize;
hr = keyboard->GetDeviceData(sizeof data[0], data, &inOut, 0);
switch (hr)
{
case DI_OK:
case DI_BUFFEROVERFLOW:
{
for (unsigned i = 0; i < inOut; ++i)
forceButton(data[i].dwOfs, (data[i].dwData & 0x80) != 0, collectEvents);
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
for (unsigned id = kbRangeBegin; id < kbRangeEnd; ++id)
setButton(id, false, collectEvents);
keyboard->Acquire();
break;
}
}
boost::array<bool, gpNum> gpBuffer;
gpBuffer.assign(false);
for (unsigned gp = 0; gp < gamepads.size(); ++gp)
{
gamepads[gp]->Poll();
DIJOYSTATE joy;
hr = gamepads[gp]->GetDeviceState(sizeof joy, &joy);
switch (hr)
{
case DI_OK:
{
if (joy.lX < -stickThreshold)
gpBuffer[gpLeft - gpRangeBegin] = true;
else if (joy.lX > stickThreshold)
gpBuffer[gpRight - gpRangeBegin] = true;
if (joy.lY < -stickThreshold)
gpBuffer[gpUp - gpRangeBegin] = true;
else if (joy.lY > stickThreshold)
gpBuffer[gpDown - gpRangeBegin] = true;
for (unsigned id = gpButton0; id < gpRangeEnd; ++id)
if (joy.rgbButtons[id - gpButton0])
gpBuffer[id - gpRangeBegin] = true;
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
gamepads[gp]->Acquire();
break;
}
}
}
for (unsigned id = gpRangeBegin; id < gpRangeEnd; ++id)
setButton(id, gpBuffer[id - gpRangeBegin], collectEvents);
}
void updateButtons(bool collectEvents)
{
DIDEVICEOBJECTDATA data[inputBufferSize];
DWORD inOut;
HRESULT hr;
RECT rect;
::GetClientRect(window, &rect);
bool ignoreClicks = mouseX < 0 || mouseX > rect.right || mouseY < 0 || mouseY > rect.bottom;
inOut = inputBufferSize;
hr = mouse->GetDeviceData(sizeof data[0], data, &inOut, 0);
switch(hr)
{
case DI_OK:
case DI_BUFFEROVERFLOW:
{
// Everything's ok: Update buttons and fire events.
for (unsigned i = 0; i < inOut; ++i)
{
bool down = (data[i].dwData & 0x80) != 0 && !ignoreClicks;
// No switch statement here because it breaks compilation with MinGW.
if (data[i].dwOfs == DIMOFS_BUTTON0)
{
unsigned id = swapMouse ? msRight : msLeft;
setButton(id, down, collectEvents);
}
else if (data[i].dwOfs == DIMOFS_BUTTON1)
{
unsigned id = swapMouse ? msLeft : msRight;
setButton(id, down, collectEvents);
}
else if (data[i].dwOfs == DIMOFS_BUTTON2)
{
setButton(msMiddle, down, collectEvents);
}
else if (data[i].dwOfs == DIMOFS_Z &&
collectEvents && data[i].dwData)
{
EventInfo event;
event.action = EventInfo::buttonDown;
if (int(data[i].dwData) < 0)
event.id = msWheelDown;
else
event.id = msWheelUp;
events.push_back(event);
event.action = EventInfo::buttonUp;
events.push_back(event);
}
}
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
// Cannot fetch new events: Release all buttons.
for (unsigned id = msRangeBegin; id <= msRangeEnd; ++id)
setButton(id, false, collectEvents);
mouse->Acquire();
break;
}
}
inOut = inputBufferSize;
hr = keyboard->GetDeviceData(sizeof data[0], data, &inOut, 0);
switch (hr)
{
case DI_OK:
case DI_BUFFEROVERFLOW:
{
for (unsigned i = 0; i < inOut; ++i)
forceButton(data[i].dwOfs, (data[i].dwData & 0x80) != 0, collectEvents);
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
for (unsigned id = kbRangeBegin; id <= kbRangeEnd; ++id)
setButton(id, false, collectEvents);
keyboard->Acquire();
break;
}
}
std::tr1::array<bool, gpNum> gpBuffer = { false };
for (unsigned gp = 0; gp < gamepads.size() && gp < numGamepads; ++gp)
{
gamepads[gp]->Poll();
int rangeOffset = (gp + 1) * gpNumPerGamepad - gpRangeBegin;
DIJOYSTATE joy;
hr = gamepads[gp]->GetDeviceState(sizeof joy, &joy);
switch (hr)
{
case DI_OK:
{
if (joy.lX < -stickThreshold)
gpBuffer[gpLeft + rangeOffset] = true;
else if (joy.lX > stickThreshold)
gpBuffer[gpRight + rangeOffset] = true;
if (joy.lY < -stickThreshold)
gpBuffer[gpUp + rangeOffset] = true;
else if (joy.lY > stickThreshold)
gpBuffer[gpDown + rangeOffset] = true;
for (unsigned id = gpButton0; id <= gpButton15; ++id)
if (joy.rgbButtons[id - gpButton0])
gpBuffer[id + rangeOffset] = true;
break;
}
case DIERR_NOTACQUIRED:
case DIERR_INPUTLOST:
{
gamepads[gp]->Acquire();
break;
}
}
// Merge these results into the area for "all gamepads OR'ed together"
for (int index = 0; index < gpNumPerGamepad; ++index)
gpBuffer[index] = (gpBuffer[index] || gpBuffer[index + (gp + 1) * gpNumPerGamepad]);
}
for (unsigned id = gpRangeBegin; id <= gpRangeEnd; ++id)
setButton(id, gpBuffer[id - gpRangeBegin], collectEvents);
}
