int sky_importer_process_event(sky_importer *importer, bstring source,
jsmntok_t *tokens, uint32_t *index)
{
int rc;
check(importer != NULL, "Importer required");
check(source != NULL, "Source required");
check(tokens != NULL, "Tokens required");
check(index != NULL, "Token index required");
jsmntok_t *event_token = &tokens[*index];
(*index)++;
// Open table if it hasn't been already.
if(!importer->table->opened) {
check(sky_table_open(importer->table) == 0, "Unable to open table");
}
// Create the event object.
sky_event *event = sky_event_create(0, 0, 0); check_mem(event);
// Process over child tokens.
int32_t i;
for(i=0; i<(event_token->size/2); i++) {
jsmntok_t *token = &tokens[*index];
(*index)++;
if(sky_importer_tokstr_equal(source, token, "timestamp")) {
bstring timestamp = sky_importer_token_parse_bstring(source, &tokens[(*index)++]);
rc = sky_timestamp_parse(timestamp, &event->timestamp);
check(rc == 0, "Unable to parse timestamp");
bdestroy(timestamp);
}
else if(sky_importer_tokstr_equal(source, token, "objectId")) {
event->object_id = (sky_object_id_t)sky_importer_token_parse_int(source, &tokens[(*index)++]);
}
else if(sky_importer_tokstr_equal(source, token, "action")) {
sky_action *action = NULL;
bstring action_name = sky_importer_token_parse_bstring(source, &tokens[(*index)++]);
rc = sky_action_file_find_action_by_name(importer->table->action_file, action_name, &action);
check(rc == 0, "Unable to find action: %s", bdata(action_name));
event->action_id = action->id;
}
else if(sky_importer_tokstr_equal(source, token, "data")) {
rc = sky_importer_process_event_data(importer, event, source, tokens, index);
check(rc == 0, "Unable to import event data");
}
else {
sentinel("Invalid token at char %d", tokens[*index].start);
}
}
// Add event.
rc = sky_table_add_event(importer->table, event);
check(rc == 0, "Unable to add event");
return 0;
error:
return -1;
}
int sky_importer_process_property(sky_importer *importer, bstring source,
jsmntok_t *tokens, uint32_t *index)
{
int rc;
assert(importer != NULL);
assert(source != NULL);
assert(tokens != NULL);
assert(index != NULL);
jsmntok_t *property_token = &tokens[*index];
(*index)++;
// Create the property object.
sky_property *property = sky_property_create(); check_mem(property);
// Process over child tokens.
int32_t i;
for(i=0; i<(property_token->size/2); i++) {
jsmntok_t *token = &tokens[*index];
(*index)++;
if(sky_importer_tokstr_equal(source, token, "type")) {
bstring type = sky_importer_token_parse_bstring(source, &tokens[*index]);
property->type = biseqcstr(type, "action") == 1 ? SKY_PROPERTY_TYPE_ACTION : SKY_PROPERTY_TYPE_OBJECT;
bdestroy(type);
}
else if(sky_importer_tokstr_equal(source, token, "dataType")) {
bstring data_type_str = sky_importer_token_parse_bstring(source, &tokens[*index]);
property->data_type = sky_data_type_to_enum(data_type_str);
bdestroy(data_type_str);
}
else if(sky_importer_tokstr_equal(source, token, "name")) {
property->name = sky_importer_token_parse_bstring(source, &tokens[*index]);
}
else {
sentinel("Invalid token at char %d", tokens[*index].start);
}
(*index)++;
}
// Add property.
if(!importer->table->opened) {
check(sky_table_open(importer->table) == 0, "Unable to open table");
}
rc = sky_property_file_add_property(importer->table->property_file, property);
check(rc == 0, "Unable to add property: %s", bdata(property->name));
return 0;
error:
return -1;
}
int sky_importer_process_action(sky_importer *importer, bstring source,
jsmntok_t *tokens, uint32_t *index)
{
int rc;
assert(importer != NULL);
assert(source != NULL);
assert(tokens != NULL);
assert(index != NULL);
jsmntok_t *action_token = &tokens[*index];
(*index)++;
// Create the action object.
sky_action *action = sky_action_create(); check_mem(action);
// Process over child tokens.
int32_t i;
for(i=0; i<(action_token->size/2); i++) {
jsmntok_t *token = &tokens[*index];
(*index)++;
if(sky_importer_tokstr_equal(source, token, "name")) {
action->name = sky_importer_token_parse_bstring(source, &tokens[*index]);
}
else {
sentinel("Invalid token at char %d", tokens[*index].start);
}
(*index)++;
}
// Add action.
if(!importer->table->opened) {
check(sky_table_open(importer->table) == 0, "Unable to open table");
}
rc = sky_action_file_add_action(importer->table->action_file, action);
check(rc == 0, "Unable to add action: %s", bdata(action->name));
return 0;
error:
return -1;
}
int sky_importer_process_event_data(sky_importer *importer, sky_event *event,
bstring source, jsmntok_t *tokens, uint32_t *index)
{
int rc;
bstring property_name = NULL;
assert(importer != NULL);
assert(source != NULL);
assert(tokens != NULL);
assert(index != NULL);
jsmntok_t *data_token = &tokens[*index];
(*index)++;
// Process over child tokens.
int32_t i;
for(i=0; i<(data_token->size/2); i++) {
sky_event_data *event_data = NULL;
jsmntok_t *key_token = &tokens[*index];
(*index)++;
jsmntok_t *value_token = &tokens[*index];
(*index)++;
// Retrieve property name.
sky_property *property = NULL;
property_name = sky_importer_token_parse_bstring(source, key_token);
rc = sky_property_file_find_by_name(importer->table->property_file, property_name, &property);
check(rc == 0 && property != NULL, "Unable to find property: %s", bdata(property_name));
bdestroy(property_name);
property_name = NULL;
// Reallocate event data array.
event->data_count++;
event->data = realloc(event->data, sizeof(*event->data) * event->data_count);
check_mem(event->data);
// Parse string.
char ch = bdata(source)[value_token->start];
bstring value = sky_importer_token_parse_bstring(source, value_token);
if(value_token->type == JSMN_STRING) {
event_data = sky_event_data_create_string(property->id, value); check_mem(event_data);
}
// Parse primitives.
else if(value_token->type == JSMN_PRIMITIVE) {
// True
if(ch == 't') {
event_data = sky_event_data_create_boolean(property->id, true); check_mem(event_data);
}
// False
else if(ch == 'f') {
event_data = sky_event_data_create_boolean(property->id, false); check_mem(event_data);
}
// Numbers (or null, which evaluates to Int 0).
else {
if(property->data_type == SKY_DATA_TYPE_DOUBLE) {
event_data = sky_event_data_create_double(property->id, atof(bdata(value))); check_mem(event_data);
}
else {
event_data = sky_event_data_create_int(property->id, atoll(bdata(value))); check_mem(event_data);
}
}
}
bdestroy(value);
// Make sure data was generated.
check(event_data != NULL, "Event data could not be parsed for: %s", bdata(property->name));
event->data[event->data_count-1] = event_data;
}
return 0;
error:
bdestroy(property_name);
return -1;
}
