AxisEventPtr AxisEvent::from_string(const std::string& str) { AxisEventPtr ev; switch (get_event_type(str)) { case EV_ABS: ev.reset(new AxisEvent(AbsAxisEventHandler::from_string(str))); break; case EV_REL: ev.reset(new AxisEvent(RelAxisEventHandler::from_string(str))); break; case EV_KEY: ev.reset(new AxisEvent(KeyAxisEventHandler::from_string(str))); break; case -1: std::cout << "--------- invalid --------------" << std::endl; ev = invalid(); break; default: assert(!"AxisEvent::from_string(): should never be reached"); } //std::cout << "AxisEvent::from_string():\n in: " << str << "\n out: " << ev->str() << std::endl; return ev; }
bool operator==(const entry& other) const { return get_device_id() == other.get_device_id() && get_event_time_stamp() == other.get_event_time_stamp() && get_valid() == other.get_valid() && get_lazy() == other.get_lazy() && get_event() == other.get_event() && get_event_type() == other.get_event_type() && get_original_event() == other.get_original_event(); }
AxisEventPtr AxisEvent::from_string(const std::string& str) { AxisEventPtr ev; std::string::size_type p = str.find(':'); const std::string& token = str.substr(0, p); std::string rest; if (p != std::string::npos) rest = str.substr(p+1); if (token == "abs") { ev.reset(new AxisEvent(AbsAxisEventHandler::from_string(rest))); } else if (token == "rel") { ev.reset(new AxisEvent(RelAxisEventHandler::from_string(rest))); } else if (token == "rel-repeat") { ev.reset(new AxisEvent(RelRepeatAxisEventHandler::from_string(rest))); } else if (token == "key") { ev.reset(new AxisEvent(KeyAxisEventHandler::from_string(rest))); } else { // try to guess a type switch (get_event_type(str)) { case EV_ABS: ev.reset(new AxisEvent(AbsAxisEventHandler::from_string(str))); break; case EV_REL: ev.reset(new AxisEvent(RelAxisEventHandler::from_string(str))); break; case EV_KEY: ev.reset(new AxisEvent(KeyAxisEventHandler::from_string(str))); break; case -1: // void/none ev = invalid(); break; default: assert(!"should never be reached"); } } return ev; }
ButtonEventPtr ButtonEvent::from_string(const std::string& str, const std::string& directory) { std::string::size_type p = str.find(':'); const std::string& token = str.substr(0, p); std::string rest; if (p != std::string::npos) rest = str.substr(p+1); if (token == "abs") { return ButtonEvent::create(AbsButtonEventHandler::from_string(rest)); } else if (token == "rel") { return ButtonEvent::create(RelButtonEventHandler::from_string(rest)); } else if (token == "key") { return ButtonEvent::create(KeyButtonEventHandler::from_string(rest)); } else if (token == "cycle-key") { return ButtonEvent::create(CycleKeyButtonEventHandler::from_string(rest)); } else if (token == "cycle-key-named") { return ButtonEvent::create(CycleKeyButtonEventHandler::from_string_named(rest)); } else if (token == "cycle-key-ref") { return ButtonEvent::create(CycleKeyButtonEventHandler::from_string_ref(rest)); } else if (token == "exec") { return ButtonEvent::create(ExecButtonEventHandler::from_string(rest)); } else if (token == "macro") { return ButtonEvent::create(MacroButtonEventHandler::from_string(path::join(directory, rest))); } else { // try to guess the type of event on the type of the first event code switch(get_event_type(token)) { case EV_KEY: return ButtonEvent::create(KeyButtonEventHandler::from_string(str)); case EV_REL: return ButtonEvent::create(RelButtonEventHandler::from_string(str)); case EV_ABS: return ButtonEvent::create(AbsButtonEventHandler::from_string(str)); case -1: return ButtonEvent::invalid(); // void default: assert(!"unknown type"); } } }
nlohmann::json to_json(void) const { return nlohmann::json({ {"device_id", type_safe::get(get_device_id())}, {"event_time_stamp", get_event_time_stamp()}, {"valid", get_valid()}, {"lazy", get_lazy()}, {"event", get_event()}, {"event_type", get_event_type()}, {"original_event", get_original_event()}, }); }
UIEvent UIEvent::from_string(const std::string& str) { switch(get_event_type(str)) { case EV_REL: return str2rel_event(str); break; case EV_ABS: return str2abs_event(str); break; case EV_KEY: return str2key_event(str); break; default: throw std::runtime_error("unknown event type"); } }
static void ami_handle_event(ami_connection* con, char* message) { int idx = 0; ami_event_type type = get_event_type(message, &idx); ami_event event; memset(&event, 0, sizeof(event)); switch(type) { case BRCM: event = parse_brcm_event(&message[idx]); break; case CHANNELRELOAD: event = parse_channel_reload_event(&message[idx]); break; case FULLYBOOTED: event = parse_fully_booted_event(&message[idx]); break; case VARSET: event = parse_varset_event(&message[idx]); break; case REGISTRY: event = parse_registry_event(&message[idx]); break; case REGISTRY_ENTRY: event = parse_registry_entry_event(&message[idx]); break; case REGISTRATIONS_COMPLETE: /* * Probably not needed. * (this happens after all registry entry events have been received) * Event: RegistrationsComplete * EventList: Complete * ListItems: 1 */ event.type = REGISTRATIONS_COMPLETE; break; case UNKNOWN_EVENT: default: event.type = UNKNOWN_EVENT; break; } //Let client handle the event if (con->event_callback) { con->event_callback(con, event); } ami_free_event(event); }
void vcore_entry(void) { uint32_t vcoreid = vcore_id(); static bool first_time = TRUE; printf("GIANT WARNING: this is ancient shit\n"); /* begin: stuff userspace needs to do to handle events/notifications */ struct vcore *vc = &__procinfo.vcoremap[vcoreid]; struct preempt_data *vcpd; vcpd = &__procdata.vcore_preempt_data[vcoreid]; /* Ghetto way to get just an event number */ unsigned int ev_type = get_event_type(&vcpd->ev_mbox_public); /* ETHAUD app: process the packet if we got a notif */ if (ev_type == EV_FREE_APPLE_PIE) process_packet(); if (vc->preempt_pending) { printf("Oh crap, vcore %d is being preempted! Yielding\n", vcoreid); sys_yield(TRUE); printf("After yield on vcore %d. I wasn't being preempted.\n", vcoreid); } /* Lets try to restart vcore0's context. Note this doesn't do anything to * set the appropriate TLS. On x86, this will involve changing the LDT * entry for this vcore to point to the TCB of the new user-thread. */ if (vcoreid == 0) { handle_events(vcoreid); set_tls_desc(core0_tls, 0); assert(__vcoreid == 0); /* in case anyone uses this */ /* Load silly state (Floating point) too */ pop_user_ctx(&vcpd->uthread_ctx, vcoreid); printf("should never see me!"); } /* unmask notifications once you can let go of the uthread_ctx and it is * okay to clobber the transition stack. * Check Documentation/processes.txt: 4.2.4. In real code, you should be * popping the tf of whatever user process you want (get off the x-stack) */ vcpd->notif_disabled = FALSE; /* end: stuff userspace needs to do to handle notifications */ /* The other vcores will hit here. */ while (1) cpu_relax(); }
void print_profile(cl_event event, cl_int status, void* data) { cl_long t_enqueue, t_submit, t_start, t_end; CALL_CL_GUARDED(clGetEventProfilingInfo, (event, CL_PROFILING_COMMAND_QUEUED, sizeof(t_enqueue), &t_enqueue, NULL)); CALL_CL_GUARDED(clGetEventProfilingInfo, (event, CL_PROFILING_COMMAND_SUBMIT, sizeof(t_submit), &t_submit, NULL)); CALL_CL_GUARDED(clGetEventProfilingInfo, (event, CL_PROFILING_COMMAND_START, sizeof(t_start), &t_start, NULL)); CALL_CL_GUARDED(clGetEventProfilingInfo, (event, CL_PROFILING_COMMAND_END, sizeof(t_end), &t_end, NULL)); std::cout << get_event_type(event) << " status: " << status << std::endl; std::cout << "time on queue : " << (t_submit - t_enqueue) / 1.0e9 << "s" << std::endl; std::cout << "time submision: " << (t_start - t_submit) / 1.0e9 << "s" << std::endl; std::cout << "time execution: " << (t_end - t_start) / 1.0e9 << "s" << std::endl; }
static int ProcessFile(FILE *out,FILE *in) /*filter infile to outfile*/ { int b=0; char line_buffer[BufferSize]; int last_event=0; EventTypes current_event_type=ET_Unknown; while(1) { line_buffer[0]='\0'; if(NULL==fgets(line_buffer,sizeof(line_buffer),in)) last_event=1; else if(ValidTS(line_buffer)) { current_event_type=get_event_type(line_buffer); b++; } if(current_event_type==ET_Unknown && Wothers==Write) { if(0>fprintf(out,"%s",line_buffer))return ERR_WRITE; } else if(Wflags[current_event_type]==Write || (Wflags[current_event_type]==0 && Wothers==Write)) { if(0>fprintf(out,"%s",line_buffer))return ERR_WRITE; } if(last_event)break; } if(!b)return ERR_INVALID_LOG; else return ERR_NONE; }
static void continuous_cb (RestProxyCall *call, const gchar *buf, gsize len, const GError *error, GObject *weak_object, gpointer user_data) { CbUserStream *self = user_data; if (buf == NULL) { /* buff == NULL && error != NULL is what happens when the message gets cancelled. * This might happen a few seconds after the CbUserStream instance is finalized, so * make sure we don't use it here. */ if (error != NULL) return; if (self->state != STATE_STOPPING) { g_debug ("%u, buf(%s) == NULL. Starting timeout...", self->state, self->account_name); start_network_timeout (self); } return; } g_string_append_len (self->data, buf, len); /* Actual messages end with \r\n */ if ((len >= 2 && buf[len - 1] == '\n' && buf[len - 2] == '\r') || (len >= 1 && buf[len - 1] == '\r')) { if (self->restarting) { g_debug (G_STRLOC ": Resuming..."); g_signal_emit (self, user_stream_signals[RESUMED], 0); self->restarting = FALSE; } self->state = STATE_RUNNING; /* Just \r\n messages are heartbeats. */ if (len == 2 && buf[0] == '\r' && buf[1] == '\n') { #if DEBUG char *date; GDateTime *now = g_date_time_new_now_local (); date = g_date_time_format (now, "%k:%M:%S"); g_debug ("%u HEARTBEAT (%s) %s", self->state, self->account_name, date); g_free (date); g_date_time_unref (now); #endif g_string_erase (self->data, 0, -1); cb_clear_source (&self->heartbeat_timeout_id); start_heartbeat_timeout (self); return; } /* TODO: Bring "OK" check back? */ { JsonParser *parser; JsonNode *root_node; JsonObject *root_object; CbStreamMessageType message_type; GError *error = NULL; guint i; parser = json_parser_new (); json_parser_load_from_data (parser, self->data->str, -1, &error); if (error != NULL) { if (g_str_has_prefix (error->message, "Exceeded connection limit for user")) { /* Ignore this one, let the next reconnect handle it */ g_string_erase (self->data, 0, -1); return; } g_warning ("%s: %s", __FUNCTION__, error->message); g_warning ("\n%s\n", self->data->str); g_string_erase (self->data, 0, -1); return; } root_node = json_parser_get_root (parser); root_object = json_node_get_object (root_node); message_type = CB_STREAM_MESSAGE_UNSUPPORTED; if (json_object_has_member (root_object, "text")) { message_type = CB_STREAM_MESSAGE_TWEET; } else if (json_object_has_member (root_object, "delete")) { JsonObject *d = json_object_get_object_member (root_object, "delete"); if (json_object_has_member (d, "direct_message")) message_type = CB_STREAM_MESSAGE_DM_DELETE; else message_type = CB_STREAM_MESSAGE_DELETE; } else if (json_object_has_member (root_object, "scrub_geo")) { message_type = CB_STREAM_MESSAGE_SCRUB_GEO; } else if (json_object_has_member (root_object, "limit")) { message_type = CB_STREAM_MESSAGE_LIMIT; } else if (json_object_has_member (root_object, "disconnect")) { message_type = CB_STREAM_MESSAGE_DISCONNECT; } else if (json_object_has_member (root_object, "friends")) { message_type = CB_STREAM_MESSAGE_FRIENDS; } else if (json_object_has_member (root_object, "event")) { const char *event_name = json_object_get_string_member (root_object, "event"); message_type = get_event_type (event_name); } else if (json_object_has_member (root_object, "warning")) { message_type = CB_STREAM_MESSAGE_WARNING; } else if (json_object_has_member (root_object, "direct_message")) { message_type = CB_STREAM_MESSAGE_DIRECT_MESSAGE; } else if (json_object_has_member (root_object, "status_withheld")) { message_type = CB_STREAM_MESSAGE_UNSUPPORTED; } #if DEBUG g_print ("Message with type %d on stream @%s\n", message_type, self->account_name); g_print ("%s\n\n", self->data->str); #endif for (i = 0; i < self->receivers->len; i++) cb_message_receiver_stream_message_received (g_ptr_array_index (self->receivers, i), message_type, root_node); g_object_unref (parser); g_string_erase (self->data, 0, -1); } /* Local block */ } }
Modifier* Modifier::from_string(const std::string& name, const std::string& value) { if (name == "axismap") { return AxismapModifier::from_string(value); } else if (name == "buttonmap" || name == "btnmap") { return ButtonmapModifier::from_string(value); } else { typedef boost::tokenizer<boost::char_separator<char> > tokenizer; tokenizer tokens(value, boost::char_separator<char>(":", "", boost::keep_empty_tokens)); std::vector<std::string> args(tokens.begin(), tokens.end()); if (name == "dpad-rotation" || name == "dpad-rotate") { return DpadRotationModifier::from_string(args); } else if (name == "4wayrest" || name == "four-way-restrictor") { return FourWayRestrictorModifier::from_string(args); } else if (name == "square" || name == "square-axis") { return SquareAxisModifier::from_string(args); } else if (name == "rotate") { return RotateAxisModifier::from_string(args); } else if (name == "stat" || name == "statistic") { return StatisticModifier::from_string(args); } else if (name == "dpad-restrictor") { return DpadRestrictorModifier::from_string(args); } else if (name == "btn2axis" || name == "button2axis") { return Button2AxisModifier::from_string(args); } else if (name == "acc2axis") { return Acc2AxisModifier::from_string(args); } else if (name == "ir2axis") { return IR2AxisModifier::from_string(args); } else if (name == "stickzone") { return StickZoneModifier::from_string(args); } else if (name == "split-axis" || name == "splitaxis") { return SplitAxisModifier::from_string(args); } else if (name == "join-axis" || name == "joinaxis") { return JoinAxisModifier::from_string(args); } else if (name == "sector2btn" || name == "sector2button") { return Sector2ButtonModifier::from_string(args); } else if (name == "latency") { return LatencyModifier::from_string(args); } else if (name == "copy") { if (args.size() < 2) { raise_exception(std::runtime_error, "'copy' modifier requires at least two arguments"); } else { switch(get_event_type(args[0])) { case EV_REL: case EV_ABS: raise_exception(std::runtime_error, "not implemented"); break; case EV_KEY: return KeyCopyModifier::from_string(args); default: raise_exception(std::runtime_error, "'copy' modifier couldn't guess"); } } } else if (name == "key-copy") { return KeyCopyModifier::from_string(args); } else if (name == "log") { return LogModifier::from_string(value); } else if (name == "compat") { return new CompatModifier; } else { throw std::runtime_error("unknown modifier: " + name); } } throw std::runtime_error("unknown modifier: " + name); }