static void fill_vertex_normal(const char **tokens, t_vertex *vertx, int nt) { int i; t_lst *normals; t_vec3 *normal; normals = g_current_data->normals; i = token_to_int(tokens, 2); if (nt) i = token_to_int(tokens, 1); normal = lst_data_at(normals, i); if (normal) { vertx->normal.x = normal->x; vertx->normal.y = normal->y; vertx->normal.z = normal->z; } else if (i == DEFAULT_CODE || (i >= 0 && lst_get_size(normals) > (size_t)i)) { vertx->normal.x = FLT_MAX; vertx->normal.y = FLT_MAX; vertx->normal.z = FLT_MAX; } else parser_die("Invalid index for normal."); }
bool json_parse_sprinkler_configuration(const char* json_buffer, Sprinkler* sprinkler) { int current_token_index; TokenVector *tokens = token_vector_new(); jsmntok_t* current_token; size_t number_of_tokens; bool ret = true; // Parse json string if (!json_parse(json_buffer, tokens)) { add_to_log("json_parse_sprinkler_configuration: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } current_token = token_vector_get_pointer(tokens, 0); number_of_tokens = current_token->size; if (number_of_tokens <= 0 || current_token->type != JSMN_OBJECT) { add_to_log("json_parse_sprinkler_configuration: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } // iterate of all tokens, try to load configuration values current_token++; for ( current_token_index = 0; current_token_index < number_of_tokens ; ) { // Lets find out what to do with the key- if (TOKEN_STRING(json_buffer, *current_token, ID_TAG)) { // Id tag if (!token_to_int(json_buffer, (current_token+1), &sprinkler->id)) { ret = false; break; } } else if (TOKEN_STRING(json_buffer, *current_token, REFRESH_RATE_TAG)) { // Port index tag if (!token_to_uint(json_buffer, (current_token+1), &sprinkler->refresh_rate)) { ret = false; break; } } else if (TOKEN_STRING(json_buffer, *current_token, MAIN_VALF_DELAY_TAG)) { // Port index tag if (!token_to_int(json_buffer, (current_token+1), &sprinkler->main_valf_delay)) { ret = false; break; } } else if (TOKEN_STRING(json_buffer, *current_token, MAIN_VALF_TAG)) { // Port index tag if (!token_to_int(json_buffer, (current_token+1), &sprinkler->main_valf)) { ret = false; break; } } // else - ignore this key. current_token_index += 2; current_token += 2; } token_vector_destroy(tokens); return ret; }
bool parse_sprinkler_configuration(const char* json_buffer, Sprinkler& sprinkler) { int current_token_index; Vector<jsmntok_t> tokens; jsmntok_t* current_token; size_t number_of_tokens; Parser parser; bool ret = true; // Parse json string if (parser.Parse(json_buffer, tokens) != JSON::JSMN_SUCCESS) { Logger::AddLine("json_parse_sprinkler_nfiguration: Could not parse json.", Logger::ERROR); return false; } current_token = &tokens[0]; number_of_tokens = current_token->size; if (number_of_tokens <= 0 || current_token->type != JSMN_OBJECT) { Logger::AddLine("json_parse_sprinkler_configuration: Could not parse json.", Logger::ERROR); return false; } // iterate of all tokens, try to load configuration values current_token++; for ( current_token_index = 0; current_token_index < number_of_tokens ; ) { // Lets find out what to do with the key- if (TOKEN_STRING(json_buffer, *current_token, ID_TAG)) { // Id tag if (!token_to_int(json_buffer, (current_token+1), sprinkler.id)) { return false; } } else if (TOKEN_STRING(json_buffer, *current_token, REFRESH_RATE_TAG)) { // Port index tag if (!token_to_uint(json_buffer, (current_token+1), sprinkler.refresh_rate)) { return false; } } else if (TOKEN_STRING(json_buffer, *current_token, MAIN_VALF_DELAY_TAG)) { // Port index tag if (!token_to_int(json_buffer, (current_token+1), sprinkler.main_valf_delay)) { // return false; sprinkler.main_valf_delay = 0; } } else if (TOKEN_STRING(json_buffer, *current_token, MAIN_VALF_TAG)) { // Port index tag if (!token_to_int(json_buffer, (current_token+1), sprinkler.main_valf)) { // return false; sprinkler.main_valf = -1; } } // else - ignore this key. current_token_index += 2; current_token += 2; } return ret; }
static void fill_vertex_color(const char **tokens, t_vertex *vertex, int nt) { int i; t_lst *colors; t_vec2 *color; colors = g_current_data->uvs; i = DEFAULT_CODE; if (!nt) i = token_to_int(tokens, 1); color = lst_data_at(colors, i); if (color) { vertex->uv.x = color->x; vertex->uv.y = color->y; } else if (i == DEFAULT_CODE || (i >= 0 && lst_get_size(colors) > (size_t)i)) { vertex->uv.x = FLT_MAX; vertex->uv.y = FLT_MAX; } else parser_die("Invalid index for color."); }
static void fill_vertex_position(const char **tokens, t_vertex *vertex) { int index; t_lst *positions; t_vec3 *pos; index = token_to_int(tokens, 0); positions = g_current_data->positions; pos = lst_data_at(positions, index); if (pos) { vertex->position.x = pos->x; vertex->position.y = pos->y; vertex->position.z = pos->z; } else if (index >= 0 && lst_get_size(positions) > (size_t)index) { vertex->position.x = FLT_MAX; vertex->position.y = FLT_MAX; vertex->position.z = FLT_MAX; } else parser_die("Invalid index for a position."); }
bool parse_alarms_internal(Vector<jsmntok_t>& tokens_vector, const char* json_buffer, Vector<SensorPtr>& sensors) { int alarm_token_index, current_token_index, alarm_index; jsmntok_t* tokens = &tokens_vector[0]; if (sensors.empty()) return true; alarm_token_index = find_json_array_token(tokens_vector, json_buffer, ALARM_TAG); if (alarm_token_index < 0) { // No alarms, should not be a problem. return true; } if(tokens[alarm_token_index].type != JSMN_ARRAY) return false; // Build sensor hash table - port_index to sensor; unsigned int max_port_index = 0; const unsigned int number_of_sensors = sensors.size(); for (unsigned int sensor_index = 0 ; sensor_index < number_of_sensors ; sensor_index++) { SensorPtr sensor = sensors[sensor_index]; if (sensor->port_index < 0) return false; // invalid if (sensor->port_index > max_port_index) max_port_index = sensor->port_index; } SensorPtr* sensors_hash = new SensorPtr[max_port_index + 1]; for (unsigned int sensor_index = 0 ; sensor_index < number_of_sensors ; sensor_index++) { sensors_hash[sensors[sensor_index]->port_index] = sensors[sensor_index]; } // iterate of all tokens, try to build alarms for (current_token_index = alarm_token_index + 1, alarm_index = 0; alarm_index < tokens[alarm_token_index].size; alarm_index++ ) { int port_index = -1; double alarm_value = -9999; Alarm::AlarmType alarm_type = Alarm::INVALID; const size_t number_of_object_tokens = tokens[current_token_index].size; const size_t next_alarm_token_index = current_token_index + number_of_object_tokens; // We're expecting something like - {"port_index":1,"alarm_value":5.0,"condition_type":"greater_than"} if (tokens[current_token_index].type != JSMN_OBJECT || number_of_object_tokens < 6) { current_token_index = next_alarm_token_index; continue; // TODO - add logs } current_token_index++; // First token is the key, the second is the value while (current_token_index < next_alarm_token_index) { const unsigned int next_object_token_index = current_token_index + tokens[current_token_index].size + 1; if (tokens[current_token_index].type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token_index; continue; } if (tokens[current_token_index + 1].type != JSMN_PRIMITIVE && tokens[current_token_index + 1].type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token_index; continue; } if (TOKEN_STRING(json_buffer, tokens[current_token_index], ALARM_VALUE_TAG)) { // alarm value tag if (!token_to_double(json_buffer, &tokens[current_token_index + 1], alarm_value)) { current_token_index = next_alarm_token_index; break; } } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], PORT_INDEX_TAG)) { // Port index tag if (!token_to_int(json_buffer, &tokens[current_token_index + 1], port_index)) { current_token_index = next_alarm_token_index; break; } } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], CONDITION_TYPE_TAG)) { // Condition type tag if (!token_to_alarm_type(json_buffer, &tokens[current_token_index + 1], alarm_type)) { current_token_index = next_alarm_token_index; break; } } // else - ignore this key. current_token_index += 2; } if (port_index >= 0 && alarm_type != Alarm::INVALID && alarm_value != -9999 && port_index <= max_port_index) { // Add alarm AlarmPtr alarm(new Alarm(alarm_value, alarm_type)); SensorPtr s = sensors_hash[port_index]; if(s.get()!=NULL) s->alarms.Add(alarm); } } delete[](sensors_hash); return true; }
bool parse_sensors_internal(Vector<jsmntok_t>& tokens_vector, const char* json_buffer, Vector<SensorPtr>& sensors) { int sensors_array_token_index, current_token_index, sensor_index; jsmntok_t* tokens = &tokens_vector[0]; // Find sensors array token: sensors_array_token_index = find_json_array_token(tokens_vector, json_buffer, SENSORS_TAG); if (sensors_array_token_index < 0) { return false; } current_token_index = sensors_array_token_index + 1; // iterate of all tokens, try to build sensors for (sensor_index = 0 ; sensor_index < tokens[sensors_array_token_index].size; sensor_index++) { int id = -1, port_index = -1, value; double sensor_value = 0; SensorType mode = MOCK; const unsigned int next_sensor_token_index = current_token_index + tokens[current_token_index].size + 1; // We're expecting something like - {"id":4,"port_index":6, "type":"water_meter", "value":8.0} if (tokens[current_token_index].type != JSMN_OBJECT || tokens[current_token_index].size < 4) { current_token_index = next_sensor_token_index; continue; } current_token_index++; // First token is the key, the second is the value while (current_token_index < next_sensor_token_index) { const unsigned int next_object_token_index = current_token_index + tokens[current_token_index].size + 1; if (tokens[current_token_index].type != JSMN_STRING) { // Must be an error... current_token_index = next_object_token_index; continue; } if (tokens[current_token_index + 1].type == JSMN_STRING) { // probably type if (TOKEN_STRING(json_buffer, tokens[current_token_index], SENSOR_TYPE_TAG)) { if (TOKEN_STRING(json_buffer, tokens[current_token_index + 1], SENSOR_TYPE_WATER)) { mode = WATER_READER; } else if (TOKEN_STRING(json_buffer, tokens[current_token_index + 1], SENSOR_TYPE_BATTERY)) { mode = BATTERY; } // TODO - add other sensor types. // TODO - what to do in case of an error? - currently ignore. } // else - ignore this key. } else if (tokens[current_token_index + 1].type == JSMN_PRIMITIVE) { // Read the value if (TOKEN_STRING(json_buffer, tokens[current_token_index], VALUE_TAG)) { // Value tag if (!token_to_double(json_buffer, &tokens[current_token_index + 1], sensor_value)) { current_token_index = next_object_token_index; continue; } } if (!token_to_int(json_buffer, &tokens[current_token_index + 1], value)) { current_token_index = next_object_token_index; continue; } if (TOKEN_STRING(json_buffer, tokens[current_token_index], ID_TAG)) { // Id tag id = value; } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], PORT_INDEX_TAG)) { // Port index tag port_index = value; } // else - ignore this key. } current_token_index += 2; } if (id >= 0 && port_index >= 0) { // Add sensor SensorPtr sensor(SensorFactory::CreateSensor(mode, id, port_index, sensor_value)); sensors.Add(sensor); } } return true; }
bool parse_valves(const char* json_buffer, Vector<ValfPtr>& valves) { Vector<jsmntok_t> tokens; jsmntok_t* current_token; size_t number_of_tokens; int current_token_index; int valf_index; Parser parser; // Parse json string if (parser.Parse(json_buffer, tokens) != JSON::JSMN_SUCCESS) { Logger::AddLine("json_parse_valves: Could not parse json.", Logger::ERROR); return false; } // expected json : [{"id":4,"port_index":1},{"id":6,"port_index":2},{"id":5,"port_index":4}] current_token = &tokens[0]; number_of_tokens = current_token->size; if (number_of_tokens <= 0 || current_token->type != JSMN_ARRAY) { Logger::AddLine("json_parse_valves: Could not parse json.", Logger::ERROR); return false; } current_token++; current_token_index = 1; // iterate of all tokens, try to build valves for (valf_index = 0 ; valf_index < number_of_tokens; valf_index++) { const int next_valf_token_index = current_token_index+current_token->size; int port_index =-1, id=-1, value; if(current_token->type != JSMN_OBJECT ) { current_token += current_token->size + 1; continue; } current_token_index++; current_token++; while(current_token_index < next_valf_token_index) { const int next_object_token = current_token_index + current_token->size+1; if (current_token->type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token; current_token = &tokens[current_token_index]; continue; } if ((current_token+1)->type != JSMN_PRIMITIVE) {// Must be an error... current_token_index = next_object_token; current_token = &tokens[current_token_index]; continue; } // Read the value if (!token_to_int(json_buffer, current_token+1, value)) { current_token_index = next_object_token; current_token = &tokens[current_token_index]; continue; } if (TOKEN_STRING(json_buffer, *current_token, ID_TAG)) { // Id tag id = value; } else if (TOKEN_STRING(json_buffer, *current_token, PORT_INDEX_TAG)) { // Port index tag port_index = value; } // else - ignore this key. current_token_index += 2; current_token += 2; } if(id>=0 && port_index>=0) { // Create valf ValfPtr v(new Valf(id, port_index)); valves.Add(v); } } return true; }
bool json_parse_alarms_internal(TokenVector* tokens_vector, const char* json_buffer, ListElement* sensors) { int max_port_index = 0; int alarm_token_index, current_token_index, alarm_index; Sensor** sensors_hash; ListElement* root_sensors; int sensor_index; jsmntok_t* tokens = token_vector_get_pointer(tokens_vector, 0); if (list_empty(sensors)) return true; alarm_token_index = find_json_array_token(tokens_vector, json_buffer, ALARM_TAG); if (alarm_token_index < 0) { // No alarms, should not be a problem. return true; } if(tokens[alarm_token_index].type != JSMN_ARRAY) return false; // Build sensor hash table - port_index to sensor; for (root_sensors = sensors->next; root_sensors != NULL; root_sensors = root_sensors->next) { Sensor* sensor = (Sensor*)root_sensors->node; if (sensor->port_index < 0) return false; // invalid if (sensor->port_index > max_port_index) max_port_index = sensor->port_index; } sensors_hash = (Sensor**) calloc(sizeof (Sensor*), max_port_index + 1); for (sensor_index = 0; sensor_index <= max_port_index; sensor_index++) // Zero all pointers, could be memset. sensors_hash[sensor_index] = NULL; for (root_sensors = sensors->next; root_sensors != NULL; root_sensors = root_sensors->next) { Sensor* sensor = (Sensor*)root_sensors->node; sensors_hash[sensor->port_index] = sensor; } // iterate of all tokens, try to build alarms for (current_token_index = alarm_token_index + 1, alarm_index = 0; alarm_index < tokens[alarm_token_index].size; alarm_index++ ) { int port_index = -1; double alarm_value = -9999; enum AlarmType alarm_type = INVALID; const size_t number_of_object_tokens = tokens[current_token_index].size; const size_t next_alarm_token_index = current_token_index + number_of_object_tokens; // We're expecting something like - {"port_index":1,"alarm_value":5.0,"condition_type":"greater_than"} if (tokens[current_token_index].type != JSMN_OBJECT || number_of_object_tokens < 6) { current_token_index = next_alarm_token_index; continue; // TODO - add logs } current_token_index++; // First token is the key, the second is the value while (current_token_index < next_alarm_token_index) { const unsigned int next_object_token_index = current_token_index + tokens[current_token_index].size + 1; if (tokens[current_token_index].type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token_index; continue; } if (tokens[current_token_index + 1].type != JSMN_PRIMITIVE && tokens[current_token_index + 1].type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token_index; continue; } if (TOKEN_STRING(json_buffer, tokens[current_token_index], ALARM_VALUE_TAG)) { // alarm value tag if (!token_to_double(json_buffer, &tokens[current_token_index + 1], &alarm_value)) { current_token_index = next_alarm_token_index; break; } } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], PORT_INDEX_TAG)) { // Port index tag if (!token_to_int(json_buffer, &tokens[current_token_index + 1], &port_index)) { current_token_index = next_alarm_token_index; break; } } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], CONDITION_TYPE_TAG)) { // Condition type tag if (!token_to_alarm_type(json_buffer, &tokens[current_token_index + 1], &alarm_type)) { current_token_index = next_alarm_token_index; break; } } // else - ignore this key. current_token_index += 2; } if (port_index >= 0 && alarm_type != INVALID && alarm_value != -9999 && port_index <= max_port_index) { // Add alarm Alarm* alarm = alarm_create(alarm_value, alarm_type); Sensor* s = sensors_hash[port_index]; if(s!=NULL) list_add(s->alarms, (void*)alarm); else alarm_delete(alarm); } } free(sensors_hash); return true; }
bool json_parse_sensors_internal(TokenVector* tokens_vector, const char* json_buffer, ListElement* sensors) { int sensors_array_token_index, current_token_index, sensor_index; jsmntok_t* tokens = token_vector_get_pointer(tokens_vector, 0); // Find sensors array token: sensors_array_token_index = find_json_array_token(tokens_vector, json_buffer, SENSORS_TAG); if (sensors_array_token_index < 0) { return false; } current_token_index = sensors_array_token_index + 1; // iterate of all tokens, try to build sensors for (sensor_index = 0 ; sensor_index < tokens[sensors_array_token_index].size; sensor_index++) { int id = -1, port_index = -1, value; const unsigned int next_sensor_token_index = current_token_index + tokens[current_token_index].size + 1; // We're expecting something like - {"id":4,"port_index":6} if (tokens[current_token_index].type != JSMN_OBJECT || tokens[current_token_index].size < 4) { current_token_index = next_sensor_token_index; continue; } current_token_index++; // First token is the key, the second is the value while (current_token_index < next_sensor_token_index) { const unsigned int next_object_token_index = current_token_index + tokens[current_token_index].size + 1; if (tokens[current_token_index].type != JSMN_STRING) { // Must be an error... current_token_index = next_object_token_index; continue; } if (tokens[current_token_index + 1].type != JSMN_PRIMITIVE) { // Must be an error... current_token_index = next_object_token_index; continue; } // Read the value if (!token_to_int(json_buffer, &tokens[current_token_index + 1], &value)) { current_token_index = next_object_token_index; continue; } if (TOKEN_STRING(json_buffer, tokens[current_token_index], ID_TAG)) { // Id tag id = value; } else if (TOKEN_STRING(json_buffer, tokens[current_token_index], PORT_INDEX_TAG)) { // Port index tag port_index = value; } // else - ignore this key. current_token_index += 2; } if (id >= 0 && port_index >= 0) { // Add sensor Sensor* sensor = sensor_create(); sensor->id = id; sensor->port_index = port_index; list_add(sensors, sensor); } } return true; }
bool json_parse_irrigations(const char* json_buffer, ListElement* irrigations) { TokenVector *tokens = token_vector_new(); jsmntok_t* current_token; size_t number_of_tokens; int current_token_index; int irrigation_index; // Parse json string if (!json_parse(json_buffer, tokens)) { add_to_log("json_parse_irrigations: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } // expected json : [{"start_time":1350339360,"valf_id":4,"irrigation_mode":"time","amount":2}] current_token = token_vector_get_pointer(tokens, 0); number_of_tokens = current_token->size; if (number_of_tokens <= 0 || current_token->type != JSMN_ARRAY) { add_to_log("json_parse_irrigations: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } current_token++; current_token_index = 1; // iterate of all tokens, try to build valves for (irrigation_index = 0 ; irrigation_index < number_of_tokens; irrigation_index++) { const int next_irrigation_token_index = current_token_index+current_token->size; int number_of_processed_tokens = 0; time_t start_time=0; int valf_id=-1; enum IrrigationModes mode = TIME; size_t amount; if(current_token->type != JSMN_OBJECT ) { // Not an object, skip to the next token. current_token += current_token->size + 1; continue; } current_token_index++; current_token++; while(current_token_index < next_irrigation_token_index) { const int next_object_token = current_token_index + current_token->size+1; if (current_token->type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } if ((current_token+1)->type == JSMN_PRIMITIVE) { int value; // Read the value if (!token_to_int(json_buffer, current_token+1, &value)) { // Error current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } if (TOKEN_STRING(json_buffer, *current_token, START_TIME_TAG)) { start_time = value; number_of_processed_tokens++; } else if (TOKEN_STRING(json_buffer, *current_token, VALF_ID_TAG)) { valf_id = value; number_of_processed_tokens++; } else if (TOKEN_STRING(json_buffer, *current_token, AMOUNT_TAG)) { amount = value; number_of_processed_tokens++; } // else - ignore this key. } else if ((current_token+1)->type == JSMN_STRING) { if (TOKEN_STRING(json_buffer, *current_token, IRRIGATION_MODE_TAG)) { if (TOKEN_STRING(json_buffer, *(current_token+1), IRRIGATION_MODE_TIME)) { mode = TIME; number_of_processed_tokens++; } else if (TOKEN_STRING(json_buffer, *(current_token+1), IRRIGATION_MODE_VOLUME)) { mode = VOLUME; number_of_processed_tokens++; } // TODO - what to do in case of an error? - currently ignore. } // else - ignore this key. } else { // Error current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } current_token_index += 2; current_token += 2; } if(number_of_processed_tokens >= 4) { // Create valf Irrigation* i = irrigation_create(); i->amount = amount; i->mode = mode; i->start_time = start_time; i->valf_id = valf_id; list_add(irrigations, i); } } token_vector_destroy(tokens); return true; }
bool json_parse_valves(const char* json_buffer, ListElement* valves) { TokenVector *tokens = token_vector_new(); jsmntok_t* current_token; size_t number_of_tokens; int current_token_index; int valf_index; // Parse json string if (!json_parse(json_buffer, tokens)) { add_to_log("json_parse_valves: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } // expected json : [{"id":4,"port_index":1},{"id":6,"port_index":2},{"id":5,"port_index":4}] current_token = token_vector_get_pointer(tokens, 0); number_of_tokens = current_token->size; if (number_of_tokens <= 0 || current_token->type != JSMN_ARRAY) { add_to_log("json_parse_valves: Could not parse json.", ERROR); token_vector_destroy(tokens); return false; } current_token++; current_token_index = 1; // iterate of all tokens, try to build valves for (valf_index = 0 ; valf_index < number_of_tokens; valf_index++) { const int next_valf_token_index = current_token_index+current_token->size; int port_index =-1, id=-1, value; if(current_token->type != JSMN_OBJECT ) { current_token += current_token->size + 1; continue; } current_token_index++; current_token++; while(current_token_index < next_valf_token_index) { const int next_object_token = current_token_index + current_token->size+1; if (current_token->type != JSMN_STRING) {// Must be an error... current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } if ((current_token+1)->type != JSMN_PRIMITIVE) {// Must be an error... current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } // Read the value if (!token_to_int(json_buffer, current_token+1, &value)) { current_token_index = next_object_token; current_token = token_vector_get_pointer(tokens, current_token_index); continue; } if (TOKEN_STRING(json_buffer, *current_token, ID_TAG)) { // Id tag id = value; } else if (TOKEN_STRING(json_buffer, *current_token, PORT_INDEX_TAG)) { // Port index tag port_index = value; } // else - ignore this key. current_token_index += 2; current_token += 2; } if(id>=0 && port_index>=0) { // Create valf Valf* v = valf_create(id, port_index); list_add(valves, v); } } token_vector_destroy(tokens); return true; }