C++ Events类代码示例

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

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

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