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