void wi_test_set_runtime_functions(void) { wi_set_t *set1; wi_mutable_set_t *set2; set1 = wi_set_with_data(WI_STR("foo"), WI_STR("bar"), NULL); set2 = wi_autorelease(wi_mutable_copy(set1)); WI_TEST_ASSERT_EQUAL_INSTANCES(set1, set2, ""); WI_TEST_ASSERT_EQUALS(wi_hash(set1), wi_hash(set2), ""); WI_TEST_ASSERT_EQUALS(wi_runtime_id(set1), wi_set_runtime_id(), ""); WI_TEST_ASSERT_EQUALS(wi_runtime_id(set2), wi_set_runtime_id(), ""); WI_TEST_ASSERT_TRUE(wi_runtime_options(set1) & WI_RUNTIME_OPTION_IMMUTABLE, ""); WI_TEST_ASSERT_TRUE(wi_runtime_options(set2) & WI_RUNTIME_OPTION_MUTABLE, ""); wi_mutable_set_remove_data(set2, WI_STR("bar")); wi_mutable_set_add_data(set2, WI_STR("baz")); WI_TEST_ASSERT_NOT_EQUAL_INSTANCES(set1, set2, ""); wi_mutable_set_remove_data(set2, WI_STR("baz")); WI_TEST_ASSERT_NOT_EQUAL_INSTANCES(set1, set2, ""); set2 = wi_autorelease(wi_set_init_with_capacity_and_callbacks(wi_mutable_set_alloc(), 0, false, wi_set_null_callbacks)); wi_mutable_set_add_data(set2, (void *) 1); wi_mutable_set_add_data(set2, (void *) 2); WI_TEST_ASSERT_NOT_EQUALS(wi_string_index_of_string(wi_description(set1), WI_STR("foo"), 0), WI_NOT_FOUND, ""); WI_TEST_ASSERT_NOT_EQUALS(wi_string_index_of_string(wi_description(set2), WI_STR("0x1"), 0), WI_NOT_FOUND, ""); }
void wi_test_set_enumeration(void) { wi_mutable_set_t *set; wi_enumerator_t *enumerator; wi_number_t *number; wi_uinteger_t i; set = wi_mutable_set(); for(i = 1; i <= 1000; i++) wi_mutable_set_add_data(set, WI_INT32(i)); enumerator = wi_set_data_enumerator(set); i = 0; while((number = wi_enumerator_next_data(enumerator))) { WI_TEST_ASSERT_TRUE(wi_number_int32(number) >= 1, ""); WI_TEST_ASSERT_TRUE(wi_number_int32(number) <= 1000, ""); i++; } WI_TEST_ASSERT_EQUALS(i, 1000, ""); for(i = 1; i <= 1000; i++) wi_mutable_set_remove_data(set, WI_INT32(i)); }
static void _wi_test_filesystem_events_callback(wi_filesystem_events_t *filesystem_events, wi_string_t *path) { wi_condition_lock_lock(_wi_test_filesystem_events_lock); wi_mutable_set_add_data(_wi_test_filesystem_events_paths, path); wi_condition_lock_unlock_with_condition(_wi_test_filesystem_events_lock, 1); wi_filesystem_events_remove_path(filesystem_events, path); }
void wi_test_set_scalars(void) { wi_mutable_set_t *set; wi_array_t *array; set = wi_set_init_with_capacity_and_callbacks(wi_mutable_set_alloc(), 0, false, wi_set_null_callbacks); wi_mutable_set_add_data(set, "foo"); wi_mutable_set_add_data(set, "bar"); WI_TEST_ASSERT_NOT_NULL(set, ""); WI_TEST_ASSERT_EQUALS(wi_set_count(set), 2U, ""); WI_TEST_ASSERT_TRUE(wi_set_contains_data(set, "foo"), ""); WI_TEST_ASSERT_TRUE(wi_set_contains_data(set, "bar"), ""); array = wi_set_all_data(set); WI_TEST_ASSERT_EQUALS(wi_array_count(array), 2U, ""); WI_TEST_ASSERT_TRUE(wi_array_contains_data(array, "foo"), ""); WI_TEST_ASSERT_TRUE(wi_array_contains_data(array, "bar"), ""); }
void wi_test_set_mutation(void) { wi_mutable_set_t *set1, *set2; set1 = wi_set_init_with_capacity_and_callbacks(wi_mutable_set_alloc(), 0, true, wi_set_null_callbacks); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 0U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("foo")), 0U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("bar")), 0U, ""); wi_mutable_set_add_data(set1, WI_STR("foo")); wi_mutable_set_add_data(set1, WI_STR("bar")); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 2U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("foo")), 1U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("bar")), 1U, ""); wi_mutable_set_add_data(set1, WI_STR("foo")); wi_mutable_set_add_data(set1, WI_STR("bar")); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 2U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("foo")), 2U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("bar")), 2U, ""); wi_mutable_set_remove_data(set1, WI_STR("foo")); wi_mutable_set_remove_data(set1, WI_STR("bar")); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 2U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("foo")), 1U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("bar")), 1U, ""); wi_mutable_set_remove_data(set1, WI_STR("foo")); wi_mutable_set_remove_data(set1, WI_STR("bar")); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 0U, ""); wi_mutable_set_add_data(set1, WI_STR("foo")); wi_mutable_set_add_data(set1, WI_STR("bar")); set2 = wi_mutable_copy(set1); wi_mutable_set_add_data(set2, WI_STR("baz")); wi_mutable_set_set_set(set1, set2); WI_TEST_ASSERT_EQUAL_INSTANCES(set1, set2, ""); wi_mutable_set_remove_all_data(set1); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 0U, ""); wi_mutable_set_add_data_from_array(set1, wi_array_with_data(WI_STR("foo"), WI_STR("bar"), NULL)); WI_TEST_ASSERT_EQUALS(wi_set_count(set1), 2U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("foo")), 1U, ""); WI_TEST_ASSERT_EQUALS(wi_set_count_for_data(set1, WI_STR("bar")), 1U, ""); }
void wd_user_subscribe_path(wd_user_t *user, wi_string_t *path, wi_string_t *realpath) { wi_string_t *metapath; wi_recursive_lock_lock(user->user_lock); wi_mutable_set_add_data(user->subscribed_paths, realpath); if(wd_files_fsevents) wi_fsevents_add_path(wd_files_fsevents, realpath); metapath = wi_string_by_appending_path_component(realpath, WI_STR(WD_FILES_META_PATH)); wi_mutable_set_add_data(user->subscribed_paths, metapath); if(wd_files_fsevents) wi_fsevents_add_path(wd_files_fsevents, metapath); wi_mutable_dictionary_set_data_for_key(user->subscribed_virtualpaths, path, realpath); wi_recursive_lock_unlock(user->user_lock); }
void wi_config_set_instance_for_name(wi_config_t *config, wi_runtime_instance_t *instance, wi_string_t *name) { wi_runtime_instance_t *copy; wi_lock_lock(config->lock); if(!wi_is_equal(instance, wi_dictionary_data_for_key(config->values, name))) wi_mutable_set_add_data(config->changes, name); copy = wi_copy(instance); wi_mutable_dictionary_set_data_for_key(config->values, copy, name); wi_release(copy); wi_lock_unlock(config->lock); }
static void wd_transfers_update_queue(void) { wi_mutable_set_t *users; wi_mutable_array_t *sorted_users, *transfers_queue, *failed_transfers; wd_transfer_t *transfer; wd_user_t *user; wi_uinteger_t position; wi_uinteger_t i, count; wi_uinteger_t total_downloads, total_uploads, user_downloads, user_uploads, active_downloads, active_uploads; wi_boolean_t queue; wi_array_rdlock(wd_transfers); total_downloads = wd_settings.totaldownloads; user_downloads = wd_settings.clientdownloads; total_uploads = wd_settings.totaluploads; user_uploads = wd_settings.clientuploads; active_downloads = 0; active_uploads = 0; failed_transfers = wi_array_init(wi_mutable_array_alloc()); users = wi_set_init(wi_mutable_set_alloc()); count = wi_array_count(wd_transfers); for(i = 0; i < count; i++) { transfer = WI_ARRAY(wd_transfers, i); if(wd_transfer_state(transfer) == WD_TRANSFER_QUEUED) { wi_mutable_array_add_data(wd_user_transfers_queue(transfer->user), transfer); wi_mutable_set_add_data(users, transfer->user); } wd_user_clear_downloads(transfer->user); wd_user_clear_uploads(transfer->user); } for(i = 0; i < count; i++) { transfer = WI_ARRAY(wd_transfers, i); if(wd_transfer_state(transfer) == WD_TRANSFER_RUNNING) { if(transfer->type == WD_TRANSFER_DOWNLOAD) { active_downloads++; wd_user_increase_downloads(transfer->user); } else { active_uploads++; wd_user_increase_uploads(transfer->user); } } } count = wi_set_count(users); if(count > 0) { sorted_users = wi_autorelease(wi_mutable_copy(wi_set_all_data(users))); wi_mutable_array_sort(sorted_users, wd_transfers_compare_user); position = 1; while(count > 0) { for(i = 0; i < count; i++) { user = WI_ARRAY(sorted_users, i); transfers_queue = wd_user_transfers_queue(user); transfer = WI_ARRAY(transfers_queue, 0); if(transfer->type == WD_TRANSFER_DOWNLOAD) { queue = ((total_downloads > 0 && active_downloads >= total_downloads) || (user_downloads > 0 && wd_user_downloads(transfer->user) >= user_downloads)); } else { queue = ((total_uploads > 0 && active_uploads >= total_uploads) || (user_uploads > 0 && wd_user_uploads(transfer->user) >= user_uploads)); } if(queue) { if(transfer->queue != position) { transfer->queue = position; wd_user_lock_socket(transfer->user); wd_sreply(wd_user_socket(transfer->user), 401, WI_STR("%#@%c%u"), transfer->path, WD_FIELD_SEPARATOR, transfer->queue); wd_user_unlock_socket(transfer->user); } position++; } else { transfer->queue = 0; transfer->waiting_time = wi_time_interval(); wd_transfer_set_state(transfer, WD_TRANSFER_WAITING); if(wd_transfer_open(transfer)) { wd_transfer_create_timer(transfer); wd_user_lock_socket(transfer->user); wd_sreply(wd_user_socket(transfer->user), 400, WI_STR("%#@%c%llu%c%#@"), transfer->path, WD_FIELD_SEPARATOR, transfer->offset, WD_FIELD_SEPARATOR, transfer->hash); wd_user_unlock_socket(transfer->user); } else { wd_user_lock_socket(transfer->user); wd_sreply(wd_user_socket(transfer->user), 500, WI_STR("Command Failed")); wd_user_unlock_socket(transfer->user); wi_mutable_array_add_data(failed_transfers, transfer); } } wi_mutable_array_remove_data_at_index(transfers_queue, 0); if(wi_array_count(transfers_queue) == 0) { wi_mutable_array_remove_data_at_index(sorted_users, i); i--; count--; } } } } wi_mutable_array_remove_data_in_array(wd_transfers, failed_transfers); wi_array_unlock(wd_transfers); wi_release(users); wi_release(failed_transfers); }
void wi_config_note_change(wi_config_t *config, wi_string_t *name) { wi_mutable_set_add_data(config->changes, name); }
wi_boolean_t wi_config_read_file(wi_config_t *config) { wi_enumerator_t *enumerator; wi_runtime_instance_t *instance; wi_file_t *file; wi_mutable_array_t *array; wi_mutable_dictionary_t *previous_values; wi_string_t *string, *name, *value; wi_config_type_t type; file = wi_file_for_reading(config->path); if(!file) { wi_log_err(WI_STR("Could not open %@: %m"), config->path); return false; } wi_log_info(WI_STR("Reading %@"), config->path); config->line = 0; wi_lock_lock(config->lock); previous_values = config->values; config->values = wi_dictionary_init(wi_mutable_dictionary_alloc()); if(config->defaults) { enumerator = wi_dictionary_key_enumerator(config->defaults); while((name = wi_enumerator_next_data(enumerator))) { // instance = wi_mutable_copy(wi_dictionary_data_for_key(config->defaults, name)); instance = wi_dictionary_data_for_key(config->defaults, name); if(wi_runtime_id(instance) == wi_array_runtime_id()) instance = wi_autorelease(wi_mutable_copy(instance)); wi_mutable_dictionary_set_data_for_key(config->values, instance, name); // wi_release(instance); } } while((string = wi_file_read_line(file))) { config->line++; if(wi_string_length(string) > 0 && !wi_string_has_prefix(string, WI_STR("#"))) { if(_wi_config_parse_string(config, string, &name, &value)) { instance = _wi_config_instance_for_setting(config, name, value, &type); if(instance) { wi_log_debug(WI_STR(" %@ = %@"), name, value); if(type == WI_CONFIG_STRINGLIST) { array = wi_dictionary_data_for_key(config->values, name); if(!array) { array = wi_mutable_array(); wi_mutable_dictionary_set_data_for_key(config->values, array, name); } wi_mutable_array_add_data(array, instance); } else { wi_mutable_dictionary_set_data_for_key(config->values, instance, name); } } else { _wi_config_log_error(config, name); } } else { wi_error_set_libwired_error(WI_ERROR_SETTINGS_SYNTAXERROR); _wi_config_log_error(config, string); } } } enumerator = wi_dictionary_key_enumerator(config->values); while((name = wi_enumerator_next_data(enumerator))) { instance = wi_dictionary_data_for_key(config->values, name); if(!previous_values || !wi_is_equal(instance, wi_dictionary_data_for_key(previous_values, name))) wi_mutable_set_add_data(config->changes, name); } wi_release(previous_values); wi_lock_unlock(config->lock); return true; }