#[cfg(feature = "v2_34")]
use Bytes;
use ChecksumType;
use Error;
use FormatSizeFlags;
use Source;
use UserDirectory;
use ffi;
use libc;
use std;
use std::mem;
use std::ptr;
use translate::*;
use types;
pub fn access<P: AsRef<std::path::Path>>(filename: P, mode: i32) -> i32 {
unsafe {
ffi::g_access(filename.as_ref().to_glib_none().0, mode)
}
}
pub fn assert_warning(log_domain: &str, file: &str, line: i32, pretty_function: &str, expression: &str) {
unsafe {
ffi::g_assert_warning(log_domain.to_glib_none().0, file.to_glib_none().0, line, pretty_function.to_glib_none().0, expression.to_glib_none().0);
}
}
pub fn assertion_message(domain: &str, file: &str, line: i32, func: &str, message: &str) {
unsafe {
ffi::g_assertion_message(domain.to_glib_none().0, file.to_glib_none().0, line, func.to_glib_none().0, message.to_glib_none().0);
}
}
pub fn assertion_message_cmpstr(domain: &str, file: &str, line: i32, func: &str, expr: &str, arg1: &str, cmp: &str, arg2: &str) {
unsafe {
ffi::g_assertion_message_cmpstr(domain.to_glib_none().0, file.to_glib_none().0, line, func.to_glib_none().0, expr.to_glib_none().0, arg1.to_glib_none().0, cmp.to_glib_none().0, arg2.to_glib_none().0);
}
}
pub fn assertion_message_expr<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(domain: P, file: &str, line: i32, func: &str, expr: Q) {
let domain = domain.into();
let domain = domain.to_glib_none();
let expr = expr.into();
let expr = expr.to_glib_none();
unsafe {
ffi::g_assertion_message_expr(domain.0, file.to_glib_none().0, line, func.to_glib_none().0, expr.0);
}
}
pub fn base64_decode(text: &str) -> Vec<u8> {
unsafe {
let mut out_len = mem::uninitialized();
let ret = FromGlibContainer::from_glib_full_num(ffi::g_base64_decode(text.to_glib_none().0, &mut out_len), out_len as usize);
ret
}
}
pub fn base64_encode(data: &[u8]) -> Option<String> {
let len = data.len() as usize;
unsafe {
from_glib_full(ffi::g_base64_encode(data.to_glib_none().0, len))
}
}
pub fn basename<P: AsRef<std::path::Path>>(file_name: P) -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_basename(file_name.as_ref().to_glib_none().0))
}
}
pub fn bit_nth_lsf(mask: libc::c_ulong, nth_bit: i32) -> i32 {
unsafe {
ffi::g_bit_nth_lsf(mask, nth_bit)
}
}
pub fn bit_nth_msf(mask: libc::c_ulong, nth_bit: i32) -> i32 {
unsafe {
ffi::g_bit_nth_msf(mask, nth_bit)
}
}
pub fn bit_storage(number: libc::c_ulong) -> u32 {
unsafe {
ffi::g_bit_storage(number)
}
}
pub fn build_filenamev(args: &[&std::path::Path]) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_build_filenamev(args.to_glib_none().0))
}
}
pub fn build_pathv(separator: &str, args: &[&std::path::Path]) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_build_pathv(separator.to_glib_none().0, args.to_glib_none().0))
}
}
pub fn chdir<P: AsRef<std::path::Path>>(path: P) -> i32 {
unsafe {
ffi::g_chdir(path.as_ref().to_glib_none().0)
}
}
pub fn check_version(required_major: u32, required_minor: u32, required_micro: u32) -> Option<String> {
unsafe {
from_glib_none(ffi::glib_check_version(required_major, required_minor, required_micro))
}
}
pub fn clear_error() -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_clear_error(&mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(feature = "v2_36")]
pub fn close(fd: i32) -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_close(fd, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(feature = "v2_34")]
pub fn compute_checksum_for_bytes(checksum_type: ChecksumType, data: &Bytes) -> Option<String> {
unsafe {
from_glib_full(ffi::g_compute_checksum_for_bytes(checksum_type.to_glib(), data.to_glib_none().0))
}
}
pub fn compute_checksum_for_data(checksum_type: ChecksumType, data: &[u8]) -> Option<String> {
let length = data.len() as usize;
unsafe {
from_glib_full(ffi::g_compute_checksum_for_data(checksum_type.to_glib(), data.to_glib_none().0, length))
}
}
pub fn compute_checksum_for_string(checksum_type: ChecksumType, str: &str) -> Option<String> {
let length = str.len() as isize;
unsafe {
from_glib_full(ffi::g_compute_checksum_for_string(checksum_type.to_glib(), str.to_glib_none().0, length))
}
}
#[cfg(feature = "v2_50")]
pub fn compute_hmac_for_bytes(digest_type: ChecksumType, key: &Bytes, data: &Bytes) -> Option<String> {
unsafe {
from_glib_full(ffi::g_compute_hmac_for_bytes(digest_type.to_glib(), key.to_glib_none().0, data.to_glib_none().0))
}
}
pub fn compute_hmac_for_data(digest_type: ChecksumType, key: &[u8], data: &[u8]) -> Option<String> {
let key_len = key.len() as usize;
let length = data.len() as usize;
unsafe {
from_glib_full(ffi::g_compute_hmac_for_data(digest_type.to_glib(), key.to_glib_none().0, key_len, data.to_glib_none().0, length))
}
}
pub fn compute_hmac_for_string(digest_type: ChecksumType, key: &[u8], str: &str) -> Option<String> {
let key_len = key.len() as usize;
let length = str.len() as isize;
unsafe {
from_glib_full(ffi::g_compute_hmac_for_string(digest_type.to_glib(), key.to_glib_none().0, key_len, str.to_glib_none().0, length))
}
}
pub fn dcgettext<'a, P: Into<Option<&'a str>>>(domain: P, msgid: &str, category: i32) -> Option<String> {
let domain = domain.into();
let domain = domain.to_glib_none();
unsafe {
from_glib_none(ffi::g_dcgettext(domain.0, msgid.to_glib_none().0, category))
}
}
pub fn dgettext<'a, P: Into<Option<&'a str>>>(domain: P, msgid: &str) -> Option<String> {
let domain = domain.into();
let domain = domain.to_glib_none();
unsafe {
from_glib_none(ffi::g_dgettext(domain.0, msgid.to_glib_none().0))
}
}
pub fn dngettext<'a, P: Into<Option<&'a str>>>(domain: P, msgid: &str, msgid_plural: &str, n: libc::c_ulong) -> Option<String> {
let domain = domain.into();
let domain = domain.to_glib_none();
unsafe {
from_glib_none(ffi::g_dngettext(domain.0, msgid.to_glib_none().0, msgid_plural.to_glib_none().0, n))
}
}
pub fn dpgettext<'a, P: Into<Option<&'a str>>>(domain: P, msgctxtid: &str, msgidoffset: usize) -> Option<String> {
let domain = domain.into();
let domain = domain.to_glib_none();
unsafe {
from_glib_none(ffi::g_dpgettext(domain.0, msgctxtid.to_glib_none().0, msgidoffset))
}
}
pub fn dpgettext2<'a, P: Into<Option<&'a str>>>(domain: P, context: &str, msgid: &str) -> Option<String> {
let domain = domain.into();
let domain = domain.to_glib_none();
unsafe {
from_glib_none(ffi::g_dpgettext2(domain.0, context.to_glib_none().0, msgid.to_glib_none().0))
}
}
pub fn environ_getenv(envp: &[&str], variable: &str) -> Option<String> {
unsafe {
from_glib_none(ffi::g_environ_getenv(envp.to_glib_none().0, variable.to_glib_none().0))
}
}
pub fn environ_setenv(envp: &[&str], variable: &str, value: &str, overwrite: bool) -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_environ_setenv(envp.to_glib_full(), variable.to_glib_none().0, value.to_glib_none().0, overwrite.to_glib()))
}
}
pub fn environ_unsetenv(envp: &[&str], variable: &str) -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_environ_unsetenv(envp.to_glib_full(), variable.to_glib_none().0))
}
}
pub fn file_get_contents<P: AsRef<std::path::Path>>(filename: P) -> Result<Vec<u8>, Error> {
unsafe {
let mut contents = ptr::null_mut();
let mut length = mem::uninitialized();
let mut error = ptr::null_mut();
let _ = ffi::g_file_get_contents(filename.as_ref().to_glib_none().0, &mut contents, &mut length, &mut error);
if error.is_null() { Ok(FromGlibContainer::from_glib_full_num(contents, length as usize)) } else { Err(from_glib_full(error)) }
}
}
pub fn file_open_tmp<P: AsRef<std::path::Path>>(tmpl: P) -> Result<(i32, std::path::PathBuf), Error> {
unsafe {
let mut name_used = ptr::null_mut();
let mut error = ptr::null_mut();
let ret = ffi::g_file_open_tmp(tmpl.as_ref().to_glib_none().0, &mut name_used, &mut error);
if error.is_null() { Ok((ret, from_glib_full(name_used))) } else { Err(from_glib_full(error)) }
}
}
pub fn file_read_link<P: AsRef<std::path::Path>>(filename: P) -> Result<std::path::PathBuf, Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_file_read_link(filename.as_ref().to_glib_none().0, &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
pub fn file_set_contents<P: AsRef<std::path::Path>>(filename: P, contents: &[u8]) -> Result<(), Error> {
let length = contents.len() as isize;
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_file_set_contents(filename.as_ref().to_glib_none().0, contents.to_glib_none().0, length, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn filename_display_basename<P: AsRef<std::path::Path>>(filename: P) -> Option<String> {
unsafe {
from_glib_full(ffi::g_filename_display_basename(filename.as_ref().to_glib_none().0))
}
}
pub fn filename_display_name<P: AsRef<std::path::Path>>(filename: P) -> Option<String> {
unsafe {
from_glib_full(ffi::g_filename_display_name(filename.as_ref().to_glib_none().0))
}
}
pub fn format_size(size: u64) -> Option<String> {
unsafe {
from_glib_full(ffi::g_format_size(size))
}
}
pub fn format_size_for_display(size: i64) -> Option<String> {
unsafe {
from_glib_full(ffi::g_format_size_for_display(size))
}
}
pub fn format_size_full(size: u64, flags: FormatSizeFlags) -> Option<String> {
unsafe {
from_glib_full(ffi::g_format_size_full(size, flags.to_glib()))
}
}
pub fn get_application_name() -> Option<String> {
unsafe {
from_glib_none(ffi::g_get_application_name())
}
}
pub fn get_charset() -> Option<String> {
unsafe {
let mut charset = ptr::null();
let ret = from_glib(ffi::g_get_charset(&mut charset));
if ret { Some(from_glib_none(charset)) } else { None }
}
}
pub fn get_codeset() -> Option<String> {
unsafe {
from_glib_full(ffi::g_get_codeset())
}
}
pub fn get_environ() -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_get_environ())
}
}
pub fn get_host_name() -> Option<String> {
unsafe {
from_glib_none(ffi::g_get_host_name())
}
}
pub fn get_language_names() -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::g_get_language_names())
}
}
pub fn get_locale_variants(locale: &str) -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_get_locale_variants(locale.to_glib_none().0))
}
}
pub fn get_monotonic_time() -> i64 {
unsafe {
ffi::g_get_monotonic_time()
}
}
#[cfg(feature = "v2_36")]
pub fn get_num_processors() -> u32 {
unsafe {
ffi::g_get_num_processors()
}
}
pub fn get_real_time() -> i64 {
unsafe {
ffi::g_get_real_time()
}
}
pub fn get_system_config_dirs() -> Vec<std::path::PathBuf> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::g_get_system_config_dirs())
}
}
pub fn get_system_data_dirs() -> Vec<std::path::PathBuf> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::g_get_system_data_dirs())
}
}
pub fn get_user_cache_dir() -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_get_user_cache_dir())
}
}
pub fn get_user_config_dir() -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_get_user_config_dir())
}
}
pub fn get_user_data_dir() -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_get_user_data_dir())
}
}
pub fn get_user_runtime_dir() -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_get_user_runtime_dir())
}
}
pub fn get_user_special_dir(directory: UserDirectory) -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_get_user_special_dir(directory.to_glib()))
}
}
pub fn hostname_is_ascii_encoded(hostname: &str) -> bool {
unsafe {
from_glib(ffi::g_hostname_is_ascii_encoded(hostname.to_glib_none().0))
}
}
pub fn hostname_is_ip_address(hostname: &str) -> bool {
unsafe {
from_glib(ffi::g_hostname_is_ip_address(hostname.to_glib_none().0))
}
}
pub fn hostname_is_non_ascii(hostname: &str) -> bool {
unsafe {
from_glib(ffi::g_hostname_is_non_ascii(hostname.to_glib_none().0))
}
}
pub fn hostname_to_ascii(hostname: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_hostname_to_ascii(hostname.to_glib_none().0))
}
}
pub fn hostname_to_unicode(hostname: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_hostname_to_unicode(hostname.to_glib_none().0))
}
}
pub fn intern_static_string<'a, P: Into<Option<&'a str>>>(string: P) -> Option<String> {
let string = string.into();
let string = string.to_glib_none();
unsafe {
from_glib_none(ffi::g_intern_static_string(string.0))
}
}
pub fn intern_string<'a, P: Into<Option<&'a str>>>(string: P) -> Option<String> {
let string = string.into();
let string = string.to_glib_none();
unsafe {
from_glib_none(ffi::g_intern_string(string.0))
}
}
pub fn listenv() -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_listenv())
}
}
pub fn log_remove_handler(log_domain: &str, handler_id: u32) {
unsafe {
ffi::g_log_remove_handler(log_domain.to_glib_none().0, handler_id);
}
}
#[cfg(feature = "v2_50")]
pub fn log_writer_is_journald(output_fd: i32) -> bool {
unsafe {
from_glib(ffi::g_log_writer_is_journald(output_fd))
}
}
#[cfg(feature = "v2_50")]
pub fn log_writer_supports_color(output_fd: i32) -> bool {
unsafe {
from_glib(ffi::g_log_writer_supports_color(output_fd))
}
}
pub fn main_current_source() -> Option<Source> {
unsafe {
from_glib_none(ffi::g_main_current_source())
}
}
pub fn main_depth() -> i32 {
unsafe {
ffi::g_main_depth()
}
}
pub fn mem_is_system_malloc() -> bool {
unsafe {
from_glib(ffi::g_mem_is_system_malloc())
}
}
pub fn mem_profile() {
unsafe {
ffi::g_mem_profile();
}
}
pub fn mkdir_with_parents<P: AsRef<std::path::Path>>(pathname: P, mode: i32) -> i32 {
unsafe {
ffi::g_mkdir_with_parents(pathname.as_ref().to_glib_none().0, mode)
}
}
pub fn mkdtemp<P: AsRef<std::path::Path>>(tmpl: P) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_mkdtemp(tmpl.as_ref().to_glib_none().0))
}
}
pub fn mkdtemp_full<P: AsRef<std::path::Path>>(tmpl: P, mode: i32) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_mkdtemp_full(tmpl.as_ref().to_glib_none().0, mode))
}
}
pub fn mkstemp_full<P: AsRef<std::path::Path>>(tmpl: P, flags: i32, mode: i32) -> i32 {
unsafe {
ffi::g_mkstemp_full(tmpl.as_ref().to_glib_none().0, flags, mode)
}
}
pub fn on_error_query(prg_name: &str) {
unsafe {
ffi::g_on_error_query(prg_name.to_glib_none().0);
}
}
pub fn on_error_stack_trace(prg_name: &str) {
unsafe {
ffi::g_on_error_stack_trace(prg_name.to_glib_none().0);
}
}
pub fn path_get_basename<P: AsRef<std::path::Path>>(file_name: P) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_path_get_basename(file_name.as_ref().to_glib_none().0))
}
}
pub fn path_get_dirname<P: AsRef<std::path::Path>>(file_name: P) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_path_get_dirname(file_name.as_ref().to_glib_none().0))
}
}
pub fn path_is_absolute<P: AsRef<std::path::Path>>(file_name: P) -> bool {
unsafe {
from_glib(ffi::g_path_is_absolute(file_name.as_ref().to_glib_none().0))
}
}
pub fn path_skip_root<P: AsRef<std::path::Path>>(file_name: P) -> Option<std::path::PathBuf> {
unsafe {
from_glib_none(ffi::g_path_skip_root(file_name.as_ref().to_glib_none().0))
}
}
pub fn pattern_match_simple(pattern: &str, string: &str) -> bool {
unsafe {
from_glib(ffi::g_pattern_match_simple(pattern.to_glib_none().0, string.to_glib_none().0))
}
}
pub fn random_double() -> f64 {
unsafe {
ffi::g_random_double()
}
}
pub fn random_double_range(begin: f64, end: f64) -> f64 {
unsafe {
ffi::g_random_double_range(begin, end)
}
}
pub fn random_int() -> u32 {
unsafe {
ffi::g_random_int()
}
}
pub fn random_int_range(begin: i32, end: i32) -> i32 {
unsafe {
ffi::g_random_int_range(begin, end)
}
}
pub fn random_set_seed(seed: u32) {
unsafe {
ffi::g_random_set_seed(seed);
}
}
pub fn reload_user_special_dirs_cache() {
unsafe {
ffi::g_reload_user_special_dirs_cache();
}
}
pub fn return_if_fail_warning<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(log_domain: P, pretty_function: &str, expression: Q) {
let log_domain = log_domain.into();
let log_domain = log_domain.to_glib_none();
let expression = expression.into();
let expression = expression.to_glib_none();
unsafe {
ffi::g_return_if_fail_warning(log_domain.0, pretty_function.to_glib_none().0, expression.0);
}
}
pub fn rmdir<P: AsRef<std::path::Path>>(filename: P) -> i32 {
unsafe {
ffi::g_rmdir(filename.as_ref().to_glib_none().0)
}
}
pub fn set_application_name(application_name: &str) {
unsafe {
ffi::g_set_application_name(application_name.to_glib_none().0);
}
}
pub fn shell_parse_argv(command_line: &str) -> Result<Vec<String>, Error> {
unsafe {
let mut argcp = mem::uninitialized();
let mut argvp = ptr::null_mut();
let mut error = ptr::null_mut();
let _ = ffi::g_shell_parse_argv(command_line.to_glib_none().0, &mut argcp, &mut argvp, &mut error);
if error.is_null() { Ok(FromGlibContainer::from_glib_full_num(argvp, argcp as usize)) } else { Err(from_glib_full(error)) }
}
}
pub fn shell_quote(unquoted_string: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_shell_quote(unquoted_string.to_glib_none().0))
}
}
pub fn shell_unquote(quoted_string: &str) -> Result<String, Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_shell_unquote(quoted_string.to_glib_none().0, &mut error);
if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
}
}
pub fn spaced_primes_closest(num: u32) -> u32 {
unsafe {
ffi::g_spaced_primes_closest(num)
}
}
#[cfg(feature = "v2_34")]
pub fn spawn_check_exit_status(exit_status: i32) -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_spawn_check_exit_status(exit_status, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
#[cfg(unix)]
pub fn spawn_command_line_async(command_line: &str) -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_spawn_command_line_async(command_line.to_glib_none().0, &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn stpcpy(dest: &str, src: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_stpcpy(dest.to_glib_none().0, src.to_glib_none().0))
}
}
pub fn test_assert_expected_messages_internal(domain: &str, file: &str, line: i32, func: &str) {
unsafe {
ffi::g_test_assert_expected_messages_internal(domain.to_glib_none().0, file.to_glib_none().0, line, func.to_glib_none().0);
}
}
pub fn test_bug(bug_uri_snippet: &str) {
unsafe {
ffi::g_test_bug(bug_uri_snippet.to_glib_none().0);
}
}
pub fn test_bug_base(uri_pattern: &str) {
unsafe {
ffi::g_test_bug_base(uri_pattern.to_glib_none().0);
}
}
pub fn test_fail() {
unsafe {
ffi::g_test_fail();
}
}
#[cfg(feature = "v2_38")]
pub fn test_failed() -> bool {
unsafe {
from_glib(ffi::g_test_failed())
}
}
#[cfg(feature = "v2_38")]
pub fn test_incomplete<'a, P: Into<Option<&'a str>>>(msg: P) {
let msg = msg.into();
let msg = msg.to_glib_none();
unsafe {
ffi::g_test_incomplete(msg.0);
}
}
pub fn test_rand_double() -> f64 {
unsafe {
ffi::g_test_rand_double()
}
}
pub fn test_rand_double_range(range_start: f64, range_end: f64) -> f64 {
unsafe {
ffi::g_test_rand_double_range(range_start, range_end)
}
}
pub fn test_rand_int() -> i32 {
unsafe {
ffi::g_test_rand_int()
}
}
pub fn test_rand_int_range(begin: i32, end: i32) -> i32 {
unsafe {
ffi::g_test_rand_int_range(begin, end)
}
}
pub fn test_run() -> i32 {
unsafe {
ffi::g_test_run()
}
}
#[cfg(feature = "v2_38")]
pub fn test_set_nonfatal_assertions() {
unsafe {
ffi::g_test_set_nonfatal_assertions();
}
}
#[cfg(feature = "v2_38")]
pub fn test_skip<'a, P: Into<Option<&'a str>>>(msg: P) {
let msg = msg.into();
let msg = msg.to_glib_none();
unsafe {
ffi::g_test_skip(msg.0);
}
}
#[cfg(feature = "v2_38")]
pub fn test_subprocess() -> bool {
unsafe {
from_glib(ffi::g_test_subprocess())
}
}
pub fn test_timer_elapsed() -> f64 {
unsafe {
ffi::g_test_timer_elapsed()
}
}
pub fn test_timer_last() -> f64 {
unsafe {
ffi::g_test_timer_last()
}
}
pub fn test_timer_start() {
unsafe {
ffi::g_test_timer_start();
}
}
pub fn test_trap_assertions(domain: &str, file: &str, line: i32, func: &str, assertion_flags: u64, pattern: &str) {
unsafe {
ffi::g_test_trap_assertions(domain.to_glib_none().0, file.to_glib_none().0, line, func.to_glib_none().0, assertion_flags, pattern.to_glib_none().0);
}
}
pub fn test_trap_has_passed() -> bool {
unsafe {
from_glib(ffi::g_test_trap_has_passed())
}
}
pub fn test_trap_reached_timeout() -> bool {
unsafe {
from_glib(ffi::g_test_trap_reached_timeout())
}
}
#[cfg(unix)]
pub fn unix_set_fd_nonblocking(fd: i32, nonblock: bool) -> Result<(), Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_unix_set_fd_nonblocking(fd, nonblock.to_glib(), &mut error);
if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }
}
}
pub fn unlink<P: AsRef<std::path::Path>>(filename: P) -> i32 {
unsafe {
ffi::g_unlink(filename.as_ref().to_glib_none().0)
}
}
pub fn uri_escape_string<'a, P: Into<Option<&'a str>>>(unescaped: &str, reserved_chars_allowed: P, allow_utf8: bool) -> Option<String> {
let reserved_chars_allowed = reserved_chars_allowed.into();
let reserved_chars_allowed = reserved_chars_allowed.to_glib_none();
unsafe {
from_glib_full(ffi::g_uri_escape_string(unescaped.to_glib_none().0, reserved_chars_allowed.0, allow_utf8.to_glib()))
}
}
pub fn uri_list_extract_uris(uri_list: &str) -> Vec<String> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_uri_list_extract_uris(uri_list.to_glib_none().0))
}
}
pub fn uri_parse_scheme(uri: &str) -> Option<String> {
unsafe {
from_glib_full(ffi::g_uri_parse_scheme(uri.to_glib_none().0))
}
}
pub fn uri_unescape_segment<'a, 'b, 'c, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>, R: Into<Option<&'c str>>>(escaped_string: P, escaped_string_end: Q, illegal_characters: R) -> Option<String> {
let escaped_string = escaped_string.into();
let escaped_string = escaped_string.to_glib_none();
let escaped_string_end = escaped_string_end.into();
let escaped_string_end = escaped_string_end.to_glib_none();
let illegal_characters = illegal_characters.into();
let illegal_characters = illegal_characters.to_glib_none();
unsafe {
from_glib_full(ffi::g_uri_unescape_segment(escaped_string.0, escaped_string_end.0, illegal_characters.0))
}
}
pub fn uri_unescape_string<'a, P: Into<Option<&'a str>>>(escaped_string: &str, illegal_characters: P) -> Option<String> {
let illegal_characters = illegal_characters.into();
let illegal_characters = illegal_characters.to_glib_none();
unsafe {
from_glib_full(ffi::g_uri_unescape_string(escaped_string.to_glib_none().0, illegal_characters.0))
}
}
pub fn usleep(microseconds: libc::c_ulong) {
unsafe {
ffi::g_usleep(microseconds);
}
}
pub fn variant_get_gtype() -> types::Type {
unsafe {
from_glib(ffi::g_variant_get_gtype())
}
}
pub fn warn_message<'a, 'b, P: Into<Option<&'a str>>, Q: Into<Option<&'b str>>>(domain: P, file: &str, line: i32, func: &str, warnexpr: Q) {
let domain = domain.into();
let domain = domain.to_glib_none();
let warnexpr = warnexpr.into();
let warnexpr = warnexpr.to_glib_none();
unsafe {
ffi::g_warn_message(domain.0, file.to_glib_none().0, line, func.to_glib_none().0, warnexpr.0);
}
}