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));
}
}
}
static void
list_assembly(const SqlDatabase::TransactionPtr &tx, int func_id)
{
Events events;
gather_events(tx, func_id);
load_events(tx, func_id, events);
SqlDatabase::StatementPtr stmt = tx->statement("select address, assembly from semantic_instructions where func_id = ?"
" order by position")->bind(0, func_id);
for (SqlDatabase::Statement::iterator insn=stmt->begin(); insn!=stmt->end(); ++insn) {
rose_addr_t addr = insn.get<rose_addr_t>(0);
std::string assembly = insn.get<std::string>(1);
Events::const_iterator ei=events.find(addr);
// Assembly line prefix
if (ei!=events.end() && ei->second.nexecuted>0) {
std::cout <<std::setw(9) <<std::right <<ei->second.nexecuted <<"x ";
} else {
std::cout <<std::string(11, ' ');
}
// Assembly instruction
std::cout <<"| " <<StringUtility::addrToString(addr) <<": " <<assembly <<"\n";
if (ei!=events.end())
show_events(ei->second);
}
}
void Client::init() {
Debug::log("INIT");
// INIT WINDOW
WSFML *window = WSFML::instance();
// CREATE CONTROL
c = Control::instance();
// CAMERA
cam = Camera::instance();
// TIME
t = new Timer();
hasStartEvent = false;
window->getWindow()->setActive(false);
sf::Thread thread_game(&Client::startGameLoop, this);
thread_game.launch();
Net *net = new Net();
sf::Thread thread_net(&Net::startNet, net);
thread_net.launch();
while(hasStartEvent == false)
sf::sleep(sf::milliseconds(1));
printf("START\n");
Events e;
e.startListening(w->getPlayer());
}
void clear()
{
while (!events.empty())
{
delete events.top();
events.pop();
}
}
int main(int, char**)
{
Events<> e0; Events<int> e1; Events<bool, int> e2; Variable<int> v; Variable<int*> va;
auto vf = constant([] (int x) { return x * 9; });
auto vb = constant([] (int x) { return x > 9; });
Events<Events<int>> ee;
Variable<Variable<int>> vv;
Events<void (*)()> ex;
Variable<Events<>> ve;
{
Events<int> a(e1);
Events<int> b = e1.mergedWith(a);
Events<bool> c = e2.transformedBy([] (bool b, int n) { return b || n > 9; });
Events<int> d = b.transformedBy(vf);
Events<bool, int> e = e2.filteredBy([] (bool b, int) { return b; });
//Events<bool, int> f = e.filteredBy(v.transformedBy([] (int n) { return n < 0; }));
//Events<int> g = e1.filteredBy(vb);
std::array<Events<int>, 4> h = e1.partitionedBy<4>([] (int n) { return n % 4; });
Events<bool> i = e0.taggedWith(false);
Events<bool, int> j = e1.taggedAtFrontWith(true);
Events<int> k = e0.withSnapshotOf(v);
Events<int, int> l = k.withSnapshotAtFrontOf(v);
Events<int, bool, bool, bool> m = e2.positions<1, 0, 0, 0>();
Events<std::tuple<bool, int>> n = e2.tupled();
Events<bool, int> o = n.untupled();
Events<int> p = ee.flattened();
Variable<int> q = e1.lastValueStartingWith(0);
Variable<std::array<int, 5>> r = e1.historyStartingWithDefaults<5>();
Variable<std::vector<int>> s = e1.history(9);
Variable<int> t = e2.count();
ex.exec();
Events<int> u = r.changes()[4];
Events<int> w = r.changes()[v];
Events<bool> x = vb.changes()(9);
Events<bool> y = vb.changes()(v);
Events<int> z = u * 9 - v;
}
{
Variable<int> a(5);
Variable<int> b(5, e1);
Variable<int> c(b);
Variable<bool> d = a.transformedBy([] (int n) { return n < 55; });
Variable<bool> e = b.transformedBy(vb);
Variable<int> f = vv.flattened();
Variable<int> g = va[5];
Variable<int> h = va[v];
Variable<bool> i = vb(9);
Variable<bool> j = vb(v);
Variable<bool> k = (vf((a + b * c) << 9) < g) || i;
Variable<std::tuple<bool, int, int>> l = tupled(d, b, a);
Variable<int> m = sample([] () { return 99; }, e0);
Events<> n = variableEvents(ve);
Mutable<int> o;
o /= 9;
}
}
Events Database::fillEvent()
{
Events e;
this->query.first();
this->record = this->query.record();
e.setId(this->query.value(this->record.indexOf("id")).toUInt());
e.setDescription(this->query.value(this->record.indexOf("name")).toString());
return e;
}
void Events::deviceEventCallback(int deviceId, int method, const char *data, int callbackId, void *context) {
Events *e = reinterpret_cast<Events *>(context);
if (e) {
/** Please note!
* We are here in another thread than the main. Some measures to syncronize
* this must be taken!
**/
e->deviceEvent(deviceId, method, data);
}
}
// Create the tmp_insns table to hold all the instructions for the function-to-be-listed and all the instructions of all
// the functions that are mentioned in events.
static void
gather_instructions(const SqlDatabase::TransactionPtr tx, int func_id, const Events &events)
{
std::set<std::string> func_ids;
func_ids.insert(StringUtility::numberToString(func_id));
for (Events::const_iterator ei=events.begin(); ei!=events.end(); ++ei)
func_ids.insert(StringUtility::numberToString(ei->second.func_id));
std::string sql = "create temporary table tmp_insns as"
" select * from semantic_instructions"
" where func_id in ("+StringUtility::join_range(", ", func_ids.begin(), func_ids.end())+")";
tx->execute(sql);
}
bool EventQueue::takeEvents(Events& events)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_eventQueueMutex);
if (!_eventQueue.empty())
{
events.splice(events.end(), _eventQueue);
return true;
}
else
{
return false;
}
}
bool EventQueue::copyEvents(Events& events) const
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_eventQueueMutex);
if (!_eventQueue.empty())
{
events.insert(events.end(),_eventQueue.begin(),_eventQueue.end());
return true;
}
else
{
return false;
}
}
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;
}
//-------------------------------------------------------------------------------------------------
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;
}
}
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;
}
}
static void
tox4j_self_connection_status_cb (Tox *tox, TOX_CONNECTION connection_status, Events &events)
{
unused (tox);
auto msg = events.add_self_connection_status ();
set_connection_status (msg, connection_status);
}
static void
tox4j_friend_read_receipt_cb (Tox *tox, uint32_t friend_number, uint32_t message_id, Events &events)
{
unused (tox);
auto msg = events.add_friend_read_receipt ();
msg->set_friend_number (friend_number);
msg->set_message_id (message_id);
}
Q_DECL_EXPORT int main(int argc, char *argv[]) {
QCoreApplication app(argc, argv);
app.setOrganizationName("cuteTube Events");
app.setApplicationName("cuteTube Events");
app.setApplicationVersion("0.1.0");
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
config.setProtocol(QSsl::TlsV1);
QSslConfiguration::setDefaultConfiguration(config);
Events events;
events.getEvents();
QObject::connect(&events, SIGNAL(finished()), &app, SLOT(quit()));
return app.exec();
}
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;
}
}
static void
tox4j_friend_lossless_packet_cb (Tox *tox, uint32_t friend_number, uint8_t const *data, size_t length, Events &events)
{
unused (tox);
auto msg = events.add_friend_lossless_packet ();
msg->set_friend_number (friend_number);
msg->set_data (data, length);
}
static void
tox4j_friend_status_message_cb (Tox *tox, uint32_t friend_number, uint8_t const *message, size_t length, Events &events)
{
unused (tox);
auto msg = events.add_friend_status_message ();
msg->set_friend_number (friend_number);
msg->set_message (message, length);
}
static void
tox4j_friend_connection_status_cb (Tox *tox, uint32_t friend_number, TOX_CONNECTION connection_status, Events &events)
{
unused (tox);
auto msg = events.add_friend_connection_status ();
msg->set_friend_number (friend_number);
set_connection_status (msg, connection_status);
}
static void
tox4j_friend_typing_cb (Tox *tox, uint32_t friend_number, bool is_typing, Events &events)
{
unused (tox);
auto msg = events.add_friend_typing ();
msg->set_friend_number (friend_number);
msg->set_is_typing (is_typing);
}
static void
tox4j_call_cb (ToxAV *av, uint32_t friend_number, bool audio_enabled, bool video_enabled, Events &events)
{
unused (av);
auto msg = events.add_call ();
msg->set_friendnumber (friend_number);
msg->set_audioenabled (audio_enabled);
msg->set_videoenabled (video_enabled);
}
static void
tox4j_friend_request_cb (Tox *tox, uint8_t const *public_key, /*uint32_t time_delta, */ uint8_t const *message, size_t length, Events &events)
{
unused (tox);
auto msg = events.add_friend_request ();
msg->set_public_key (public_key, TOX_PUBLIC_KEY_SIZE);
msg->set_time_delta (0);
msg->set_message (message, length);
}
//-------------------------------------------------------------------------------------------------
void TimerActor::delete_event(const acto::actor_ref& actor) {
for (Events::iterator i = m_events.begin(); i != m_events.end(); i++) {
if ((*i)->actor == actor) {
// 1. Удалить системный таймер
//
// NOTE: Так как последний параметр INVALID_HANDLE_VALUE, то
// функция возвратит управление только тогда, когда завершится
// выполнение соответствующей TimerProc.
::DeleteTimerQueueTimer( m_timers, (*i)->timer, INVALID_HANDLE_VALUE );
// 2. Удалить экземпляр события
delete (*i);
// 3. Удалить элемент из списка
m_events.erase( i );
// -
break;
}
}
}
static void
tox4j_file_chunk_request_cb (Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, size_t length, Events &events)
{
unused (tox);
auto msg = events.add_file_chunk_request ();
msg->set_friend_number (friend_number);
msg->set_file_number (file_number);
msg->set_position (position);
msg->set_length (length);
}
static void
tox4j_file_recv_chunk_cb (Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position, uint8_t const *data, size_t length, Events &events)
{
unused (tox);
auto msg = events.add_file_recv_chunk ();
msg->set_friend_number (friend_number);
msg->set_file_number (file_number);
msg->set_position (position);
msg->set_data (data, length);
}
static void
tox4j_file_recv_cb (Tox *tox, uint32_t friend_number, uint32_t file_number, uint32_t kind, uint64_t file_size, uint8_t const *filename, size_t filename_length, Events &events)
{
unused (tox);
auto msg = events.add_file_recv ();
msg->set_friend_number (friend_number);
msg->set_file_number (file_number);
msg->set_kind (kind);
msg->set_file_size (file_size);
msg->set_filename (filename, filename_length);
}
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;
}
static void
tox4j_video_bit_rate_status_cb (ToxAV *av,
uint32_t friend_number,
bool stable,
uint32_t bit_rate,
Events &events)
{
unused (av);
auto msg = events.add_videobitratestatus ();
msg->set_friendnumber (friend_number);
msg->set_stable (stable);
msg->set_bitrate (bit_rate);
}
int BasicEventSyntaxCheckerAppLayer::run(int argc, char * argv[])
{
//printf("BasicEventSyntaxCheckerAppLayer - version: %d.%d.%d (%s)\n",
// BASICEVENTSYNTAXCHECKER_MAJOR,
// BASICEVENTSYNTAXCHECKER_MINOR,
// BASICEVENTSYNTAXCHECKER_PATCH,
// BASICEVENTSYNTAXCHECKER_DebugFlag);
//printf("\n");
BasicEventHandling_ns::EventHandler_stderr handler_stderr;
handler_stderr.open(argv[0]);
std::string strEventDefSourceFile;
BasicEventSyntaxChecker checker;
checker.set_event_handler(&handler_stderr);
if (!checker.get_params(argc,
argv,
strEventDefSourceFile))
{
return 1;
}
Events events;
events.set_event_handler(&handler_stderr);
if (!events.ReadEventsSourceFile(strEventDefSourceFile))
{
return 2;
}
if (!checker.CreateEventsCPP(strEventDefSourceFile))
{
return 3;
}
return 0;
}