C++ EventPtr::get方法代码示例

bool EventComparator::operator() (EventPtr& evt1, EventPtr& evt2)
{
	if (!evt1.get()) return true;
	if (!evt2.get()) return false;
	// The more or less standard definition for a priority queue
	// assigns more priority to values with lower numbers.
	// However, the STL implementation does the opposite.
	// To stick with the more familiar convention, the comparison operator
	// used for this method is > instead of <, so that the queue ordering 
	// gets reversed.
	return evt1->getPriority()>evt2->getPriority();
}

UUID SubgraphNode::addForwardingSlot(const UUID& internal_uuid, const TokenDataConstPtr& type, const std::string& label)
{
    graph_->registerUUID(internal_uuid);

    EventPtr relay = createInternalEvent(type, internal_uuid, label);

    auto cb = [relay](const TokenConstPtr& data) {
        relay->triggerWith(std::make_shared<Token>(*data));
        relay->message_processed(relay);
    };

    Slot* external_slot = VariadicSlots::createVariadicSlot(type, label, cb, false, false);

    relay->message_processed.connect(std::bind(&Slot::notifyEventHandled, external_slot));

    crossConnectLabelChange(external_slot, relay.get());

    external_to_internal_events_[external_slot->getUUID()] = relay;

    relay_to_external_slot_[internal_uuid] = external_slot->getUUID();

    forwarding_connector_added(relay);

    return external_slot->getUUID();
}

void* DemoStateMachine::threadMethod(void* userArgs)
{
	cout << "DemoStateMachine, internal thread started ..." << endl;
	bool terminate = false;

	initialize();

	while(!terminate && !isFinalized())
	{
		if(eventQueue.waitForEvents())
		{
			if(!eventQueue.empty())
			{
				cout << "DemoStateMachine, received event ..." << endl;
				EventPtr eventPtr = eventQueue.front();
				eventQueue.pop_front();

				if(dynamic_cast<InputEvent*>(eventPtr.get()))
				{
					sttcl::RefCountPtr<InputEvent> inputEvent(eventPtr);
					cout << "Sending command from input '" << inputEvent->getInput() << "'" << std::endl;
					terminate = cmdInterpreter->sendCmd(inputEvent->getInput(),inputEvent);
				}
				else if(dynamic_cast<SubStateMachineCompletedEvent*>(eventPtr.get()))
				{
					sttcl::RefCountPtr<SubStateMachineCompletedEvent> subStateMachineCompletedEvent(eventPtr);
					cout << "DemoStateMachine, sub statemachine completed, finalizing ..." << endl;
					cout << "*** Press <ENTER> once more to end the program ***" << endl;
					finalize();
				}
			}
		}
	}

	{ AutoLocker<SttclMutex<> > lock(threadMutex);
		terminated = true;
	}

	cout << "DemoStateMachine, internal thread exiting ..." << endl;
	if(!isFinalized())
	{
		finalize();
	}

	return 0;
}

inline void Simulator::dispatchEvent(EventPtr event)
{
	assert(event.get() != 0);
	SimTime fireTime = event->getFireTime();
	assert(m_clock <= fireTime);

	m_clock = fireTime;
	event->execute();
}

	void Impl_CameraController_FirstPerson::_on_mouse_move(EventPtr pEvent)
	{
		Event_MouseState* pState = (Event_MouseState*)pEvent.get();
		
		float dx = pState->mouse_state->dx;
		float dy = pState->mouse_state->dy;

		UpdateRotating(dx, dy);

	}

/*!
 * Method called by Application::handleMessage if object already exists.
 */
void VsMagnitude::updateObject(const string &parentID, Object *obj) {
    EventPtr event = Event::Cast(obj);
    if ( event ) {
        SEISCOMP_DEBUG("Event updated");
        // Get the already cached event instance and not the temporary instance
        // in the message
        event = _cache.get<Event>(event->publicID());
        handleEvent(event.get());
        return;
    }
}

/*!
 \brief Process all events in the cache
 */
void VsMagnitude::processEvents() {
    _lastProcessingTime = _currentTime;
    VsEvents::iterator it;
    for ( it = _events.begin(); it != _events.end(); ) {
        VsEvent *evt = it->second.get();
        EventPtr event = _cache.get<Event>(it->first);
        if ( event != NULL ) {
            if ( _currentTime < evt->expirationTime ) {
                process(evt, event.get());
                // only send the message / update the database if the event has a VS magnitude
                if ( evt->vsMagnitude ) {
                    evt->update++;
                    updateVSMagnitude(event.get(), evt);
                }
            } else {
                process(evt, event.get());
                // only send the message / update the database if the event has a VS magnitude
                if ( evt->vsMagnitude )
                    updateVSMagnitude(event.get(), evt);
                _events.erase(it++);
                _publishedEvents[event->publicID()] = _currentTime;
                SEISCOMP_LOG(_processingInfoChannel,
                             "Processing of event %s is finished.", event->publicID().c_str());
                // erase outdated events
                EventIDBuffer::iterator cev;
                for ( cev = _publishedEvents.begin();
                        cev != _publishedEvents.end(); ) {
                    if ( cev->second
                            < (_currentTime - Core::TimeSpan(_timeout)) ) {
                        _publishedEvents.erase(cev++);
                        continue;
                    }
                    ++cev;
                }
                continue;
            }
        } else
            SEISCOMP_WARNING("%s: event not found", it->first.c_str());
        ++it;
    }
}

	void Impl_CameraController_FirstPerson::_on_key(EventPtr pEvent)
	{
		using namespace math;

		Event_KeyboardState* pState = (Event_KeyboardState*)pEvent.get();

		m_forward						= pState->keyboard_state->KeyDown(key_w);
		m_backward						= pState->keyboard_state->KeyDown(key_s);
		m_left							= pState->keyboard_state->KeyDown(key_a);
		m_right							= pState->keyboard_state->KeyDown(key_d);

	}

///
/// タッチ点移動イベントハンドラ
void Button::onPointingMoving(
    const EventPtr eve
) {
    //  最初のタッチで触ってない場合は無反応
    if (!first_touch_) {
        return;
    }

    
    auto move_event = static_cast<const event::PointingMovingEvent*>(eve.get());
    
    if (isHitPointRectangle(move_event->position(), hit_area_)) {
        hover();
    }
    else {
        unhover();
    }



}

///
/// トリガイベントハンドラ
void Button::onPointingTrigger(
    const EventPtr eve
) {
    if (!sprite_) {
        //  スプライトの設定がまだ
        return;
    }
    
    
    //  スプライトがアクティブじゃない場合スキップ
    if (!sprite_->isVisible()) {
        return;
    }
    
    auto trg_event = static_cast<const event::PointingTriggeredEvent*>(eve.get());
    if (isHitPointRectangle(trg_event->position(), hit_area_)) {
        //  ファーストタッチで触っていた
        first_touch_ = true;
        hover();
    }
}

  void AbstractDevice::eventThread() {
    ADR_GUARD("AbstractDevice::eventThread");
    m_thread_exists = true;
    while (!m_thread_should_die) {
      m_event_mutex.lock();
      while (m_events.empty()) {
        m_events_available.wait(m_event_mutex, 1);
        if (m_thread_should_die) {
          break;
        }
      }
      if (m_thread_should_die) {
        m_event_mutex.unlock();
        break;
      }

      // Make a local copy of the events so they can be processed without
      // leaving the mutex locked.
      EventQueue events = m_events;

      // Queues don't support clear().  o_o
      while (!m_events.empty()) {
        m_events.pop();
      }

      m_event_mutex.unlock();

      // Process the events.
      while (!events.empty()) {
        EventPtr event = events.front();
        events.pop();
        processEvent(event.get());
      }
    }
    m_thread_exists = false;
  }

	void DebugPanel::_on_resize(EventPtr pEvent)
	{
		Event_ResizeFrameBuffer* pResize = (Event_ResizeFrameBuffer*)pEvent.get();
		
		m_pOverlay->Resize(pResize->w, pResize->h / 2);
	}