bool Timer::add(Event* e, int id, int64_t cycle, void* param) { const intptr_t key((intptr_t)e); auto ib = m_clients.find(key); if ( ib == m_clients.end() ) { auto res = m_clients.insert(client_cont::value_type(key, event_cont())); if ( res.second == false ) { PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param); return false; } event_cont& ec(res.first->second); // 이후 코드는 insert 성공 여부와 상관 없이 반복자가 무효하다. invalidateIterator(); if ( false == ec.insert(event_cont::value_type(id, event_type(param, cycle, s_getNow()))).second ) { PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param); m_clients.erase(ib); return false; } //PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle); return true; } auto& ec = ib->second; auto ib_event = ec.find(id); if ( ec.end() == ib_event ) { if ( false == ec.insert(event_cont::value_type(id, event_type(param, cycle, s_getNow()))).second ) { PWLOGLIB("failed to insert timer event: e:%p id:%d cycle:%jd param:%p", e, id, intmax_t(cycle), param); return false; } invalidateIterator(); //PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle); return true; } // 반복자를 건들지 않았으므로 invalidateIterator를 호출하지 않는다. auto& et = ib_event->second; et.param = param; et.cycle = cycle; et.start = s_getNow(); //PWTRACE("add new timer event: e:%p type:%s id:%d cycle:%jdms", e, typeid(*e).name(), id, cycle); return true; }
static int syslog(int level, char *fmt, ...) { va_list argptr; char sbuf[1024]; char* p=sbuf; int retval; static HANDLE event_handle; va_start(argptr,fmt); retval=vsnprintf(sbuf,sizeof(sbuf),fmt,argptr); sbuf[sizeof(sbuf)-1]=0; va_end(argptr); if(event_handle == NULL) event_handle = RegisterEventSource( NULL, // server name for source (NULL = local computer) TITLE); // source name for registered handle if(event_handle != NULL) ReportEvent(event_handle, // event log handle event_type(level), // event type 0, // category zero 0, // event identifier NULL, // no user security identifier 1, // one string 0, // no data &p, // pointer to string array NULL); // pointer to data return(retval); }
bool os::task_control_block::execute(const os::tick_type& timepoint_of_ckeck_ready_task) const { // Check for a task event. const bool task_does_have_event = (my_event != event_type(0U)); if(task_does_have_event) { // Set the global task index equal to the index of the running task. os_task_global_index() = my_index; // Call the task function because of an event. my_func(); } // Check for a task timeout. const bool task_does_have_timeout = ( (my_cycle != os::tick_type(0U)) && my_timer.timeout_of_specific_timepoint(timepoint_of_ckeck_ready_task)); if(task_does_have_timeout) { // Increment the task's interval timer with the task cycle. my_timer.start_interval(my_cycle); // Set the global task index equal to the index of the running task. os_task_global_index() = my_index; // Call the task function because of a timer timeout. my_func(); } return (task_does_have_event || task_does_have_timeout); }
INPUT_RECORD *TThreads::get_next_event(void) { if (evpending) return &ir; PeekConsoleInput(chandle[cnInput],&ir,1,&evpending); if (evpending) { int code = event_type(ir); // printf("evtype = %d\n",code); switch (code) { case IO_RAW_EVENT: ReadConsoleInput(chandle[cnInput],&ir,1,&evpending); break; case IO_CHR_EVENT: char chr; // printf("before readconsole\n"); ReadConsole(chandle[cnInput],&chr,1,&evpending,NULL); // printf("key %x %d\n",chr,evpending); ir.Event.KeyEvent.uChar.AsciiChar = chr; break; case IO_IGN_EVENT: ReadConsoleInput(chandle[cnInput],&ir,1,&evpending); accept_event(); break; } } return evpending ? &ir : NULL; }
int unexpected_event(struct streamstate* stp) { fprintf(stderr, "%s:%zu:%zu:unexpected event: %s\n", stp->filename, stp->event.start_mark.line+1, stp->event.start_mark.column+1, event_type(&stp->event)); return 1; }
void EventDispatcherBase<TDerived>::enterInitialStates() { // TODO: Would be nice, if the state machine had an initial // transition similar to initial transitions of states. clearTransientStateFlags(); derived().m_flags |= state_type::InEnterSet; markDescendantsForEntry(); enterStatesInEnterSet(event_type()); }
void EventDispatcherBase<TDerived>::runToCompletion(bool changedConfiguration) { // We are in microstepping mode: follow all eventless transitions. while (1) { clearTransientStateFlags(); selectTransitions(true, event_type()); if (!m_enabledTransitions) break; changedConfiguration |= microstep(event_type()); clearEnabledTransitionsSet(); } // Synchronize the visible state active flag with the internal // state active flag. for (auto iter = derived().begin(); iter != derived().end(); ++iter) iter->m_visibleActive = (iter->m_flags & state_type::Active) != 0; // Call the invoke() methods of all currently active states. for (auto iter = derived().begin(); iter != derived().end(); ++iter) { if (iter->m_flags & state_type::StartInvoke) { iter->enterInvoke(); iter->m_flags &= ~state_type::StartInvoke; iter->m_flags |= state_type::Invoked; } } // If we followed at least one transition, which was not target-less, // invoke the configuration change callback. if (changedConfiguration) { ++m_numConfigurationChanges; derived().invokeConfigurationChangeCallback(); } }
void EventDispatcherBase<TDerived>::leaveConfiguration() { for (auto iter = derived().begin(); iter != derived().end(); ++iter) { if (iter->m_flags & state_type::Active) iter->m_flags |= state_type::InExitSet; } leaveStatesInExitSet(event_type()); for (auto iter = derived().begin(); iter != derived().end(); ++iter) iter->m_visibleActive = false; ++m_numConfigurationChanges; derived().invokeConfigurationChangeCallback(); //! \todo Clear the event list? Or document that the event list is //! preserved when the FSM is stopped? }
void debug_event_type(yaml_event_t* ep) { printf("%s", event_type(ep)); }
static void upnm_handler(state_t s, event_t e) { switch(event_type(e)) { case EVENT_FAIL: assert(bool_array_super(event_failures(e), s->failed, s->vs->nmembers)) ; bool_array_copy_into(s->failed, event_failures(e), s->vs->nmembers) ; upnm(s, e) ; break ; case EVENT_INIT: dnnm(s, event_timer_time(time_zero())) ; upnm(s, e) ; break ; case EVENT_TIMER: { etime_t time = event_time(e) ; item_t item ; while (priq_get_upto(s->priq, time, NULL, (void**)&item)) { s->acct_delivered ++ ; switch(item->type) { case DROP_UP: { rank_t origin = event_peer(item->u.up.event) ; if (origin >= 0 && array_get(s->failed, origin)) { up_free(item->u.up.event, item->u.up.abv) ; } else { up(s, item->u.up.event, item->u.up.abv) ; } } break ; case DROP_UPNM: upnm(s, item->u.upnm.event) ; break ; OTHERWISE_ABORT() ; } record_free(item) ; } if (time_ge(time, s->next_sweep)) { if (!time_is_zero(s->next_sweep) && sys_random(5) == 1) { rank_t i ; bool_array_t suspects = bool_array_create_init(s->vs->nmembers, FALSE) ; for(i=0;i<s->vs->nmembers;i++) { if (i == s->ls->rank) { continue ; } if (sys_random(4) == 0) { array_set(suspects, i, TRUE) ; } } if (bool_array_exists(suspects, s->vs->nmembers)) { dnnm(s, event_suspect_reason_create(suspects, name)) ; } else { array_free(suspects) ; } } #if 0 /* Suspicions are randomly generated every 0-8 seconds. */ s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<23/*8M*/))) ; #else s->next_sweep = time_add(time, time_of_usecs(sys_random(1<<20/*1M*/))) ; #endif dnnm(s, event_timer_time(s->next_sweep)) ; /* request next sweep */ } upnm(s, e) ; } break ; case EVENT_GOSSIP_EXT: { /*endpt_id_t origin = NULL ;*/ etime_t delay ; /* let origin = getExtender (function | HealGos(_,(_,endpt),_,_) -> Some (Some endpt) | SwitchGos(_,(_,endpt),_) -> Some (Some endpt) | _ -> None ) None ev in */ if (1 /*!origin*/) { upnm(s, e) ; } else if (s->partition) { sys_abort() ; } else if (!distrib(s, &delay)) { event_free(e) ; } else { /* Deliver after a certain delay.... */ etime_t when = time_add(alarm_gettime(s->alarm), delay) ; item_t item = record_create(item_t, item) ; item->type = DROP_UPNM ; item->u.upnm.event = e ; priq_add(s->priq, when, item) ; dnnm(s, event_timer_time(when)) ; } } break ; case EVENT_ACCOUNT: log(("delivered=%d dropped=%d", s->acct_delivered, s->acct_dropped)) ; upnm(s, e) ; break ; EVENT_DUMP_HANDLE() ; default: upnm(s, e) ; break ; } }
proton_event::proton_event(pn_event_t *ce, pn_event_type_t t, class container *c) : pn_event_(ce), type_(event_type(t)), container_(c) {}
QBindDelegate( const boost::function<void()>& f ) :QEvent( (QEvent::Type)event_type() ),run(f){}