自学教程：C++ wi_retain函数代码示例

wr_window_t * wr_window_init_with_chat(wr_window_t *window, wr_chat_t *chat) {	window = wr_window_init(window);	window->type		= WR_WINDOW_TYPE_CHAT;	window->chat		= wi_retain(chat);		return window;}

wr_window_t * wr_window_init_with_user(wr_window_t *window, wr_user_t *user) {	window = wr_window_init(window);		window->type		= WR_WINDOW_TYPE_USER;	window->uid			= user->uid;	window->topic.topic	= wi_retain(user->nick);		return window;}

wt_server_t * wt_servers_server_with_key(wi_string_t *key) {	wt_server_t		*server;		wi_dictionary_rdlock(wt_servers);	server = wi_autorelease(wi_retain(wi_dictionary_data_for_key(wt_servers, key)));	wi_dictionary_unlock(wt_servers);		return server;}

wr_window_t * wr_window_init_with_user(wr_window_t *window, wr_user_t *user) {	window = wr_window_init(window);		window->type		= WR_WINDOW_TYPE_USER;	window->user		= wi_retain(user);	window->topic		= wr_topic_init_with_user(wr_topic_alloc(), user);		return window;}

void wr_transfers_set_download_path(wi_string_t *download_path) {	if(wi_is_equal(download_path, wr_download_path))		return;		wi_release(wr_download_path);	wr_download_path = wi_retain(download_path);		wr_printf_prefix(WI_STR("Using download path %@"), download_path);}

wi_regexp_t * wi_config_regexp_for_name(wi_config_t *config, wi_string_t *name) {	wi_regexp_t		*value;		wi_lock_lock(config->lock);	value = wi_autorelease(wi_retain(wi_dictionary_data_for_key(config->values, name)));	wi_lock_unlock(config->lock);		return value;}

wd_user_t * wd_users_user_with_uid(wd_uid_t uid) {	wd_user_t     *user;	wi_dictionary_rdlock(wd_users);	user = wi_autorelease(wi_retain(wi_dictionary_data_for_key(wd_users, wi_number_with_int32(uid))));	wi_dictionary_unlock(wd_users);		return user;}

wi_uinteger_t wi_config_port_for_name(wi_config_t *config, wi_string_t *name) {	wi_number_t		*value;		wi_lock_lock(config->lock);	value = wi_autorelease(wi_retain(wi_dictionary_data_for_key(config->values, name)));	wi_lock_unlock(config->lock);		return value ? wi_number_integer(value) : 0;}

static void wd_transfer_accept_thread(wi_runtime_instance_t *argument) {	wi_pool_t			*pool;	wi_socket_t			*socket = argument;	wi_array_t			*arguments;	wi_string_t			*ip, *string, *command;	wd_transfer_t		*transfer;		pool = wi_pool_init(wi_pool_alloc());		ip = wi_address_string(wi_socket_address(socket));		if(!wi_socket_accept_tls(socket, wd_transfer_socket_tls, 30.0)) {		wi_log_err(WI_STR("Could not accept a connection for %@: %m"), ip);				goto end;	}		if(!wi_socket_set_timeout(socket, 30.0))		wi_log_warn(WI_STR("Could not set timeout for %@: %m"), ip);		string = wi_socket_read_to_string(socket, 5.0, WI_STR(WD_MESSAGE_SEPARATOR_STR));		if(!string || wi_string_length(string) == 0) {		if(!string)			wi_log_warn(WI_STR("Could not read from %@: %m"), ip);				goto end;	}		wi_parse_wired_command(string, &command, &arguments);		if(wi_is_equal(command, WI_STR("TRANSFER")) && wi_array_count(arguments) >= 1) {		transfer = wd_transfers_transfer_with_hash(WI_ARRAY(arguments, 0));				if(!transfer)			goto end;				if(!wi_is_equal(ip, wd_user_ip(transfer->user)))			goto end;				wi_lock_lock(transfer->socket_lock);				if(!transfer->socket) {			transfer->socket = wi_retain(socket);			wi_lock_unlock(transfer->socket_lock);					wd_transfer_loop(transfer);		} else {			wi_lock_unlock(transfer->socket_lock);		}	}end:	wi_socket_close(socket);	wi_release(pool);}

static wi_timer_t * _wi_timer_first_timer(void) {	wi_timer_t		*timer;		wi_array_rdlock(_wi_timers);	timer = wi_autorelease(wi_retain(wi_array_first_data(_wi_timers)));	wi_array_unlock(_wi_timers);		return timer;}

wd_topic_t * wd_chat_topic(wd_chat_t *chat) {	wd_topic_t		*topic;		wi_recursive_lock_lock(chat->lock);	topic = wi_autorelease(wi_retain(chat->topic));	wi_recursive_lock_unlock(chat->lock);		return topic;}

void wr_windows_set_timestamp_format(wi_string_t *timestamp_format) {	if(wi_is_equal(timestamp_format, wr_timestamp_format))		return;		wi_release(wr_timestamp_format);	wr_timestamp_format = wi_retain(timestamp_format);	wr_printf_prefix(WI_STR("Using timestamp format %@"), wr_timestamp_format);}

wd_chat_t * wd_chats_chat_with_cid(wd_cid_t cid) {	wd_chat_t		*chat;		wi_dictionary_rdlock(wd_chats);	chat = wi_autorelease(wi_retain(wi_dictionary_data_for_key(wd_chats, wi_number_with_int32(cid))));	wi_dictionary_unlock(wd_chats);		return chat;}

wi_time_interval_t wi_config_time_interval_for_name(wi_config_t *config, wi_string_t *name) {	wi_number_t		*value;		wi_lock_lock(config->lock);	value = wi_autorelease(wi_retain(wi_dictionary_data_for_key(config->values, name)));	wi_lock_unlock(config->lock);		return value ? wi_number_double(value) : 0.0;}

void wi_mutable_url_set_host(wi_mutable_url_t *url, wi_string_t *host) {	WI_RUNTIME_ASSERT_MUTABLE(url);		wi_retain(host);	wi_release(url->host);		url->host = host;		_wi_url_regenerate_string(url);}

void wi_error_set_error_with_string(wi_error_domain_t domain, int code, wi_string_t *string) {	wi_error_t		*error;	error			= _wi_error_get_error();	error->domain	= domain;	error->code		= code;	wi_release(error->string);	error->string = wi_retain(string);}

void wi_mutable_url_set_password(wi_mutable_url_t *url, wi_string_t *password) {	WI_RUNTIME_ASSERT_MUTABLE(url);		wi_retain(password);	wi_release(url->password);		url->password = password;		_wi_url_regenerate_string(url);}

void wi_mutable_url_set_user(wi_mutable_url_t *url, wi_string_t *user) {	WI_RUNTIME_ASSERT_MUTABLE(url);		wi_retain(user);	wi_release(url->user);		url->user = user;		_wi_url_regenerate_string(url);}

wr_user_t * wr_user_init_with_message(wr_user_t *user, wi_p7_message_t *message) {	wi_p7_uint32_t		uid;	wi_p7_boolean_t		idle, admin;	wi_p7_enum_t		color;		wi_p7_message_get_uint32_for_name(message, &uid, WI_STR("wired.user.id"));	wi_p7_message_get_bool_for_name(message, &idle, WI_STR("wired.user.idle"));	wi_p7_message_get_bool_for_name(message, &admin, WI_STR("wired.user.admin"));	wi_p7_message_get_enum_for_name(message, &color, WI_STR("wired.account.color"));		user->nick		= wi_retain(wi_p7_message_string_for_name(message, WI_STR("wired.user.nick")));	user->status	= wi_retain(wi_p7_message_string_for_name(message, WI_STR("wired.user.status")));	user->uid		= uid;	user->idle		= idle;	user->admin		= admin;	user->color		= color;	return user;}

void wi_mutable_url_set_scheme(wi_mutable_url_t *url, wi_string_t *scheme) {	WI_RUNTIME_ASSERT_MUTABLE(url);		wi_retain(scheme);	wi_release(url->scheme);		url->scheme = scheme;		_wi_url_regenerate_string(url);}

void wi_error_set_openssl_ssl_error_with_result(void *ssl, int result) {	wi_error_t		*error;	int				code;		code = SSL_get_error(ssl, result);		if(code == SSL_ERROR_SYSCALL) {		if(ERR_peek_error() == 0) {			if(result == 0)				wi_error_set_libwired_error(WI_ERROR_SOCKET_EOF);			else				wi_error_set_errno(errno);		} else {			wi_error_set_openssl_error();		}	}	else if(code == SSL_ERROR_SSL) {		wi_error_set_openssl_error();	} else {		error = _wi_error_get_error();		error->domain = WI_ERROR_DOMAIN_OPENSSL_SSL;		error->code = code;		wi_release(error->string);		switch(error->code) {			case SSL_ERROR_NONE:				error->string = wi_retain(WI_STR("SSL: No error"));				break;			case SSL_ERROR_ZERO_RETURN:				error->string = wi_retain(WI_STR("SSL: Zero return"));				break;							case SSL_ERROR_WANT_READ:				error->string = wi_retain(WI_STR("SSL: Want read"));				break;							case SSL_ERROR_WANT_WRITE:				error->string = wi_retain(WI_STR("SSL: Want write"));				break;							case SSL_ERROR_WANT_CONNECT:				error->string = wi_retain(WI_STR("SSL: Want connect"));				break;							case SSL_ERROR_WANT_ACCEPT:				error->string = wi_retain(WI_STR("SSL: Want accept"));				break;							case SSL_ERROR_WANT_X509_LOOKUP:				error->string = wi_retain(WI_STR("SSL: Want X509 lookup"));				break;		}	}		ERR_clear_error();}

static void wd_transfer_create_timer(wd_transfer_t *transfer) {	transfer->timer = wi_timer_init_with_function(wi_timer_alloc(),												  wd_transfer_expire_timer,												  WD_TRANSFERS_WAITING_INTERVAL,												  false);	wi_timer_set_data(transfer->timer, transfer);	wi_timer_schedule(transfer->timer);		wi_retain(transfer);}

wi_boolean_t _wi_settings_set_path(wi_settings_t *settings, wi_uinteger_t index, wi_string_t *name, wi_string_t *value) {	wi_string_t		**string = (wi_string_t **) settings->spec[index].setting;		if(*string)		wi_release(*string);	*string = wi_retain(value);		return true;}

static wi_process_t * _wi_process_init_with_argv(wi_process_t *process, int argc, const char **argv) {	wi_array_t			*array;	wi_string_t			*string;	struct utsname		name;#ifdef HAVE_MACH_O_ARCH_H	const NXArchInfo	*arch_info;#endif		array = wi_array_init_with_argv(wi_array_alloc(), argc, argv);		string = wi_array_first_data(array);		if(string) {		process->path = wi_retain(string);		process->name = wi_retain(wi_string_last_path_component(process->path));	} else {		process->path = wi_retain(WI_STR("unknown"));		process->name = wi_retain(process->path);	}		if(wi_array_count(array) <= 1)		process->arguments = wi_array_init(wi_array_alloc());	else		process->arguments = wi_retain(wi_array_subarray_with_range(array, wi_make_range(1, wi_array_count(array) - 1)));		wi_release(array);		uname(&name);		process->os_name = wi_string_init_with_cstring(wi_string_alloc(), name.sysname);	process->os_release = wi_string_init_with_cstring(wi_string_alloc(), name.release);#ifdef HAVE_MACH_O_ARCH_H	arch_info = NXGetArchInfoFromCpuType(NXGetLocalArchInfo()->cputype, CPU_SUBTYPE_MULTIPLE);		process->arch = wi_string_init_with_cstring(wi_string_alloc(), arch_info->name);#else	process->arch = wi_string_init_with_cstring(wi_string_alloc(), name.machine);#endif	return process;}

void wr_client_init(void) {	wr_server_string_encoding = wi_string_encoding_init_with_charset(		wi_string_encoding_alloc(),		WI_STR("UTF-8"),		WI_STRING_ENCODING_IGNORE | WI_STRING_ENCODING_TRANSLITERATE);		wr_client_set_charset(WI_STR("UTF-8"));		wr_nick = wi_retain(wi_user_name());	wr_icon = wi_data_init_with_base64(wi_data_alloc(), wi_string_with_cstring(wr_default_icon));}

static wd_topic_t * wd_topic_init_with_string(wd_topic_t *topic, wi_string_t *string) {	wd_user_t	*user = wd_users_user_for_thread();		topic->topic	= wi_retain(string);	topic->date		= wi_date_init(wi_date_alloc());	topic->nick		= wi_copy(wd_user_nick(user));	topic->login	= wi_copy(wd_user_login(user));	topic->ip		= wi_copy(wd_user_ip(user));		return topic;}

wi_array_t * wi_array_init_with_string(wi_array_t *array, wi_string_t *string, wi_string_t *separator) {	if(wi_string_length(string) == 0) {		array = wi_array_init_with_data(array, WI_STR(""), (void *) NULL);	} else {		wi_release(array);				array = wi_retain(wi_string_components_separated_by_string(string, separator));	}		return array;}

static wd_user_t * wd_user_init_with_socket(wd_user_t *user, wi_socket_t *socket) {	wi_address_t	*address;	user->uid				= wd_user_next_uid();	user->socket			= wi_retain(socket);	user->state				= WD_USER_CONNECTED;	user->login_time		= wi_time_interval();	user->idle_time			= user->login_time;		address					= wi_socket_address(socket);	user->ip				= wi_retain(wi_address_string(address));	user->host				= wi_retain(wi_address_hostname(address));		user->user_lock			= wi_recursive_lock_init(wi_recursive_lock_alloc());	user->socket_lock		= wi_lock_init(wi_lock_alloc());		user->transfers_queue	= wi_array_init(wi_array_alloc());	return user;}

static void wr_msg_200(wi_array_t *arguments) {	wi_string_t		*password;	double			protocol;		protocol = wi_string_double(wr_protocol_version_string);		wr_server = wr_server_init(wr_server_alloc());	wr_server->version = wi_retain(WI_ARRAY(arguments, 0));	wr_server->protocol = wi_string_double(WI_ARRAY(arguments, 1));	wr_server->name = wi_retain(WI_ARRAY(arguments, 2));	wr_server->description = wi_retain(WI_ARRAY(arguments, 3));	wr_server->startdate = wi_date_init_with_rfc3339_string(wi_date_alloc(), WI_ARRAY(arguments, 4));	wr_server->files = wi_string_uint32(WI_ARRAY(arguments, 5));	wr_server->size = wi_string_uint64(WI_ARRAY(arguments, 6));	wr_draw_divider();		if(!wr_logged_in) {		if(wr_server->protocol > protocol) {			wr_wprintf_prefix(wr_console_window, WI_STR("Server protocol version %.1f may not be fully compatible with client protocol version %.1f"),				wr_server->protocol, protocol);		}		wr_send_command(WI_STR("CLIENT %#@"), wr_client_version_string);		wr_send_command(WI_STR("NICK %#@"), wr_nick);		wr_send_command(WI_STR("STATUS %#@"), wr_status);		wr_send_command(WI_STR("ICON %u%c%#@"), 0, WR_FIELD_SEPARATOR, wr_icon);		wr_send_command(WI_STR("USER %#@"), wr_login ? wr_login : WI_STR("guest"));				if(wr_password && wi_string_length(wr_password) > 0)			password = wi_string_sha1(wr_password);		else			password = NULL;		wr_send_command(WI_STR("PASS %#@"), password);				wr_send_command(WI_STR("WHO %u"), 1);		wr_logged_in = true;	}}

void wd_trackers_register(wi_boolean_t update) {	if(wi_array_count(wd_trackers) > 0) {		wi_release(wd_trackers_guest_account);				wd_trackers_guest_account = wi_retain(wd_accounts_read_user_and_group(WI_STR("guest")));				wi_log_info(WI_STR("Registering with trackers..."));		if(!wi_thread_create_thread(wd_trackers_register_thread, wi_number_with_bool(update)))			wi_log_err(WI_STR("Could not create a register thread: %m"));	}}