use crate::translate::*;
use crate::Bytes;
use crate::ChecksumType;
use crate::Error;
#[cfg(any(feature = "v2_66", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_66")))]
use crate::FileSetContentsFlags;
use crate::FileTest;
use crate::FormatSizeFlags;
use crate::Pid;
use crate::Source;
use crate::SpawnFlags;
use crate::UserDirectory;
use std::boxed::Box as Box_;
use std::mem;
use std::ptr;
#[doc(alias = "g_access")]
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) }
}
#[doc(alias = "g_assert_warning")]
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,
);
}
}
#[doc(alias = "g_assertion_message")]
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,
);
}
}
#[doc(alias = "g_assertion_message_cmpstr")]
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,
);
}
}
#[doc(alias = "g_base64_decode")]
pub fn base64_decode(text: &str) -> Vec<u8> {
unsafe {
let mut out_len = mem::MaybeUninit::uninit();
let ret = FromGlibContainer::from_glib_full_num(
ffi::g_base64_decode(text.to_glib_none().0, out_len.as_mut_ptr()),
out_len.assume_init() as usize,
);
ret
}
}
#[doc(alias = "g_base64_encode")]
pub fn base64_encode(data: &[u8]) -> crate::GString {
let len = data.len() as usize;
unsafe { from_glib_full(ffi::g_base64_encode(data.to_glib_none().0, len)) }
}
#[doc(alias = "g_bit_nth_lsf")]
pub fn bit_nth_lsf(mask: libc::c_ulong, nth_bit: i32) -> i32 {
unsafe { ffi::g_bit_nth_lsf(mask, nth_bit) }
}
#[doc(alias = "g_bit_nth_msf")]
pub fn bit_nth_msf(mask: libc::c_ulong, nth_bit: i32) -> i32 {
unsafe { ffi::g_bit_nth_msf(mask, nth_bit) }
}
#[doc(alias = "g_bit_storage")]
pub fn bit_storage(number: libc::c_ulong) -> u32 {
unsafe { ffi::g_bit_storage(number) }
}
#[doc(alias = "g_build_filenamev")]
pub fn build_filenamev(args: &[&std::path::Path]) -> std::path::PathBuf {
unsafe { from_glib_full(ffi::g_build_filenamev(args.to_glib_none().0)) }
}
#[doc(alias = "g_build_pathv")]
pub fn build_pathv(separator: &str, args: &[&std::path::Path]) -> std::path::PathBuf {
unsafe {
from_glib_full(ffi::g_build_pathv(
separator.to_glib_none().0,
args.to_glib_none().0,
))
}
}
#[cfg(any(feature = "v2_58", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_58")))]
#[doc(alias = "g_canonicalize_filename")]
pub fn canonicalize_filename<P: AsRef<std::path::Path>, Q: AsRef<std::path::Path>>(
filename: P,
relative_to: Q,
) -> std::path::PathBuf {
unsafe {
from_glib_full(ffi::g_canonicalize_filename(
filename.as_ref().to_glib_none().0,
relative_to.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "g_chdir")]
pub fn chdir<P: AsRef<std::path::Path>>(path: P) -> i32 {
unsafe { ffi::g_chdir(path.as_ref().to_glib_none().0) }
}
#[doc(alias = "glib_check_version")]
pub fn check_version(
required_major: u32,
required_minor: u32,
required_micro: u32,
) -> crate::GString {
unsafe {
from_glib_none(ffi::glib_check_version(
required_major,
required_minor,
required_micro,
))
}
}
#[doc(alias = "g_clear_error")]
pub fn clear_error() -> Result<(), crate::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))
}
}
}
#[doc(alias = "g_compute_checksum_for_bytes")]
pub fn compute_checksum_for_bytes(
checksum_type: ChecksumType,
data: &Bytes,
) -> Option<crate::GString> {
unsafe {
from_glib_full(ffi::g_compute_checksum_for_bytes(
checksum_type.into_glib(),
data.to_glib_none().0,
))
}
}
#[doc(alias = "g_compute_checksum_for_data")]
pub fn compute_checksum_for_data(
checksum_type: ChecksumType,
data: &[u8],
) -> Option<crate::GString> {
let length = data.len() as usize;
unsafe {
from_glib_full(ffi::g_compute_checksum_for_data(
checksum_type.into_glib(),
data.to_glib_none().0,
length,
))
}
}
#[doc(alias = "g_compute_checksum_for_string")]
pub fn compute_checksum_for_string(
checksum_type: ChecksumType,
str: &str,
) -> Option<crate::GString> {
let length = str.len() as isize;
unsafe {
from_glib_full(ffi::g_compute_checksum_for_string(
checksum_type.into_glib(),
str.to_glib_none().0,
length,
))
}
}
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
#[doc(alias = "g_compute_hmac_for_bytes")]
pub fn compute_hmac_for_bytes(
digest_type: ChecksumType,
key: &Bytes,
data: &Bytes,
) -> crate::GString {
unsafe {
from_glib_full(ffi::g_compute_hmac_for_bytes(
digest_type.into_glib(),
key.to_glib_none().0,
data.to_glib_none().0,
))
}
}
#[doc(alias = "g_compute_hmac_for_data")]
pub fn compute_hmac_for_data(digest_type: ChecksumType, key: &[u8], data: &[u8]) -> crate::GString {
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.into_glib(),
key.to_glib_none().0,
key_len,
data.to_glib_none().0,
length,
))
}
}
#[doc(alias = "g_compute_hmac_for_string")]
pub fn compute_hmac_for_string(digest_type: ChecksumType, key: &[u8], str: &str) -> crate::GString {
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.into_glib(),
key.to_glib_none().0,
key_len,
str.to_glib_none().0,
length,
))
}
}
#[doc(alias = "g_dcgettext")]
pub fn dcgettext(domain: Option<&str>, msgid: &str, category: i32) -> crate::GString {
unsafe {
from_glib_none(ffi::g_dcgettext(
domain.to_glib_none().0,
msgid.to_glib_none().0,
category,
))
}
}
#[doc(alias = "g_dgettext")]
pub fn dgettext(domain: Option<&str>, msgid: &str) -> crate::GString {
unsafe {
from_glib_none(ffi::g_dgettext(
domain.to_glib_none().0,
msgid.to_glib_none().0,
))
}
}
#[doc(alias = "g_dngettext")]
pub fn dngettext(
domain: Option<&str>,
msgid: &str,
msgid_plural: &str,
n: libc::c_ulong,
) -> crate::GString {
unsafe {
from_glib_none(ffi::g_dngettext(
domain.to_glib_none().0,
msgid.to_glib_none().0,
msgid_plural.to_glib_none().0,
n,
))
}
}
#[doc(alias = "g_dpgettext")]
pub fn dpgettext(domain: Option<&str>, msgctxtid: &str, msgidoffset: usize) -> crate::GString {
unsafe {
from_glib_none(ffi::g_dpgettext(
domain.to_glib_none().0,
msgctxtid.to_glib_none().0,
msgidoffset,
))
}
}
#[doc(alias = "g_dpgettext2")]
pub fn dpgettext2(domain: Option<&str>, context: &str, msgid: &str) -> crate::GString {
unsafe {
from_glib_none(ffi::g_dpgettext2(
domain.to_glib_none().0,
context.to_glib_none().0,
msgid.to_glib_none().0,
))
}
}
#[doc(alias = "g_file_get_contents")]
pub fn file_get_contents<P: AsRef<std::path::Path>>(filename: P) -> Result<Vec<u8>, crate::Error> {
unsafe {
let mut contents = ptr::null_mut();
let mut length = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let _ = ffi::g_file_get_contents(
filename.as_ref().to_glib_none().0,
&mut contents,
length.as_mut_ptr(),
&mut error,
);
if error.is_null() {
Ok(FromGlibContainer::from_glib_full_num(
contents,
length.assume_init() as usize,
))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_file_open_tmp")]
pub fn file_open_tmp<P: AsRef<std::path::Path>>(
tmpl: P,
) -> Result<(i32, std::path::PathBuf), crate::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))
}
}
}
#[doc(alias = "g_file_read_link")]
pub fn file_read_link<P: AsRef<std::path::Path>>(
filename: P,
) -> Result<std::path::PathBuf, crate::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))
}
}
}
#[doc(alias = "g_file_set_contents")]
pub fn file_set_contents<P: AsRef<std::path::Path>>(
filename: P,
contents: &[u8],
) -> Result<(), crate::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))
}
}
}
#[cfg(any(feature = "v2_66", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_66")))]
#[doc(alias = "g_file_set_contents_full")]
pub fn file_set_contents_full<P: AsRef<std::path::Path>>(
filename: P,
contents: &[u8],
flags: FileSetContentsFlags,
mode: i32,
) -> Result<(), crate::Error> {
let length = contents.len() as isize;
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_file_set_contents_full(
filename.as_ref().to_glib_none().0,
contents.to_glib_none().0,
length,
flags.into_glib(),
mode,
&mut error,
);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_file_test")]
pub fn file_test<P: AsRef<std::path::Path>>(filename: P, test: FileTest) -> bool {
unsafe {
from_glib(ffi::g_file_test(
filename.as_ref().to_glib_none().0,
test.into_glib(),
))
}
}
#[doc(alias = "g_filename_display_basename")]
pub fn filename_display_basename<P: AsRef<std::path::Path>>(filename: P) -> crate::GString {
unsafe {
from_glib_full(ffi::g_filename_display_basename(
filename.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "g_filename_display_name")]
pub fn filename_display_name<P: AsRef<std::path::Path>>(filename: P) -> crate::GString {
unsafe {
from_glib_full(ffi::g_filename_display_name(
filename.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "g_format_size")]
pub fn format_size(size: u64) -> crate::GString {
unsafe { from_glib_full(ffi::g_format_size(size)) }
}
#[doc(alias = "g_format_size_full")]
pub fn format_size_full(size: u64, flags: FormatSizeFlags) -> crate::GString {
unsafe { from_glib_full(ffi::g_format_size_full(size, flags.into_glib())) }
}
#[doc(alias = "g_get_application_name")]
#[doc(alias = "get_application_name")]
pub fn application_name() -> Option<crate::GString> {
unsafe { from_glib_none(ffi::g_get_application_name()) }
}
#[doc(alias = "g_get_codeset")]
#[doc(alias = "get_codeset")]
pub fn codeset() -> crate::GString {
unsafe { from_glib_full(ffi::g_get_codeset()) }
}
#[cfg(any(feature = "v2_62", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_62")))]
#[doc(alias = "g_get_console_charset")]
#[doc(alias = "get_console_charset")]
pub fn console_charset() -> Option<crate::GString> {
unsafe {
let mut charset = ptr::null();
let ret = from_glib(ffi::g_get_console_charset(&mut charset));
if ret {
Some(from_glib_none(charset))
} else {
None
}
}
}
#[doc(alias = "g_get_environ")]
#[doc(alias = "get_environ")]
pub fn environ() -> Vec<std::ffi::OsString> {
unsafe { FromGlibPtrContainer::from_glib_full(ffi::g_get_environ()) }
}
#[doc(alias = "g_get_host_name")]
#[doc(alias = "get_host_name")]
pub fn host_name() -> crate::GString {
unsafe { from_glib_none(ffi::g_get_host_name()) }
}
#[doc(alias = "g_get_language_names")]
#[doc(alias = "get_language_names")]
pub fn language_names() -> Vec<crate::GString> {
unsafe { FromGlibPtrContainer::from_glib_none(ffi::g_get_language_names()) }
}
#[cfg(any(feature = "v2_58", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_58")))]
#[doc(alias = "g_get_language_names_with_category")]
#[doc(alias = "get_language_names_with_category")]
pub fn language_names_with_category(category_name: &str) -> Vec<crate::GString> {
unsafe {
FromGlibPtrContainer::from_glib_none(ffi::g_get_language_names_with_category(
category_name.to_glib_none().0,
))
}
}
#[doc(alias = "g_get_locale_variants")]
#[doc(alias = "get_locale_variants")]
pub fn locale_variants(locale: &str) -> Vec<crate::GString> {
unsafe {
FromGlibPtrContainer::from_glib_full(ffi::g_get_locale_variants(locale.to_glib_none().0))
}
}
#[doc(alias = "g_get_monotonic_time")]
#[doc(alias = "get_monotonic_time")]
pub fn monotonic_time() -> i64 {
unsafe { ffi::g_get_monotonic_time() }
}
#[doc(alias = "g_get_num_processors")]
#[doc(alias = "get_num_processors")]
pub fn num_processors() -> u32 {
unsafe { ffi::g_get_num_processors() }
}
#[cfg(any(feature = "v2_64", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_64")))]
#[doc(alias = "g_get_os_info")]
#[doc(alias = "get_os_info")]
pub fn os_info(key_name: &str) -> Option<crate::GString> {
unsafe { from_glib_full(ffi::g_get_os_info(key_name.to_glib_none().0)) }
}
#[doc(alias = "g_get_real_time")]
#[doc(alias = "get_real_time")]
pub fn real_time() -> i64 {
unsafe { ffi::g_get_real_time() }
}
#[doc(alias = "g_get_system_config_dirs")]
#[doc(alias = "get_system_config_dirs")]
pub fn system_config_dirs() -> Vec<std::path::PathBuf> {
unsafe { FromGlibPtrContainer::from_glib_none(ffi::g_get_system_config_dirs()) }
}
#[doc(alias = "g_get_system_data_dirs")]
#[doc(alias = "get_system_data_dirs")]
pub fn system_data_dirs() -> Vec<std::path::PathBuf> {
unsafe { FromGlibPtrContainer::from_glib_none(ffi::g_get_system_data_dirs()) }
}
#[doc(alias = "g_get_user_cache_dir")]
#[doc(alias = "get_user_cache_dir")]
pub fn user_cache_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_cache_dir()) }
}
#[doc(alias = "g_get_user_config_dir")]
#[doc(alias = "get_user_config_dir")]
pub fn user_config_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_config_dir()) }
}
#[doc(alias = "g_get_user_data_dir")]
#[doc(alias = "get_user_data_dir")]
pub fn user_data_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_data_dir()) }
}
#[doc(alias = "g_get_user_runtime_dir")]
#[doc(alias = "get_user_runtime_dir")]
pub fn user_runtime_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_runtime_dir()) }
}
#[doc(alias = "g_get_user_special_dir")]
#[doc(alias = "get_user_special_dir")]
pub fn user_special_dir(directory: UserDirectory) -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_special_dir(directory.into_glib())) }
}
#[doc(alias = "g_hostname_is_ascii_encoded")]
pub fn hostname_is_ascii_encoded(hostname: &str) -> bool {
unsafe { from_glib(ffi::g_hostname_is_ascii_encoded(hostname.to_glib_none().0)) }
}
#[doc(alias = "g_hostname_is_ip_address")]
pub fn hostname_is_ip_address(hostname: &str) -> bool {
unsafe { from_glib(ffi::g_hostname_is_ip_address(hostname.to_glib_none().0)) }
}
#[doc(alias = "g_hostname_is_non_ascii")]
pub fn hostname_is_non_ascii(hostname: &str) -> bool {
unsafe { from_glib(ffi::g_hostname_is_non_ascii(hostname.to_glib_none().0)) }
}
#[doc(alias = "g_hostname_to_ascii")]
pub fn hostname_to_ascii(hostname: &str) -> Option<crate::GString> {
unsafe { from_glib_full(ffi::g_hostname_to_ascii(hostname.to_glib_none().0)) }
}
#[doc(alias = "g_hostname_to_unicode")]
pub fn hostname_to_unicode(hostname: &str) -> Option<crate::GString> {
unsafe { from_glib_full(ffi::g_hostname_to_unicode(hostname.to_glib_none().0)) }
}
#[doc(alias = "g_listenv")]
pub fn listenv() -> Vec<std::ffi::OsString> {
unsafe { FromGlibPtrContainer::from_glib_full(ffi::g_listenv()) }
}
#[doc(alias = "g_main_current_source")]
pub fn main_current_source() -> Option<Source> {
unsafe { from_glib_none(ffi::g_main_current_source()) }
}
#[doc(alias = "g_main_depth")]
pub fn main_depth() -> i32 {
unsafe { ffi::g_main_depth() }
}
#[doc(alias = "g_markup_escape_text")]
pub fn markup_escape_text(text: &str) -> crate::GString {
let length = text.len() as isize;
unsafe { from_glib_full(ffi::g_markup_escape_text(text.to_glib_none().0, length)) }
}
#[doc(alias = "g_mkdir_with_parents")]
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) }
}
#[doc(alias = "g_mkdtemp")]
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)) }
}
#[doc(alias = "g_mkdtemp_full")]
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)) }
}
#[doc(alias = "g_mkstemp_full")]
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) }
}
#[doc(alias = "g_on_error_query")]
pub fn on_error_query(prg_name: &str) {
unsafe {
ffi::g_on_error_query(prg_name.to_glib_none().0);
}
}
#[doc(alias = "g_on_error_stack_trace")]
pub fn on_error_stack_trace(prg_name: &str) {
unsafe {
ffi::g_on_error_stack_trace(prg_name.to_glib_none().0);
}
}
#[doc(alias = "g_path_get_basename")]
pub fn path_get_basename<P: AsRef<std::path::Path>>(file_name: P) -> std::path::PathBuf {
unsafe {
from_glib_full(ffi::g_path_get_basename(
file_name.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "g_path_get_dirname")]
pub fn path_get_dirname<P: AsRef<std::path::Path>>(file_name: P) -> std::path::PathBuf {
unsafe { from_glib_full(ffi::g_path_get_dirname(file_name.as_ref().to_glib_none().0)) }
}
#[doc(alias = "g_path_is_absolute")]
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)) }
}
#[doc(alias = "g_path_skip_root")]
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)) }
}
#[doc(alias = "g_pattern_match_simple")]
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,
))
}
}
#[doc(alias = "g_random_double")]
pub fn random_double() -> f64 {
unsafe { ffi::g_random_double() }
}
#[doc(alias = "g_random_double_range")]
pub fn random_double_range(begin: f64, end: f64) -> f64 {
unsafe { ffi::g_random_double_range(begin, end) }
}
#[doc(alias = "g_random_int")]
pub fn random_int() -> u32 {
unsafe { ffi::g_random_int() }
}
#[doc(alias = "g_random_int_range")]
pub fn random_int_range(begin: i32, end: i32) -> i32 {
unsafe { ffi::g_random_int_range(begin, end) }
}
#[doc(alias = "g_random_set_seed")]
pub fn random_set_seed(seed: u32) {
unsafe {
ffi::g_random_set_seed(seed);
}
}
#[doc(alias = "g_reload_user_special_dirs_cache")]
pub fn reload_user_special_dirs_cache() {
unsafe {
ffi::g_reload_user_special_dirs_cache();
}
}
#[doc(alias = "g_return_if_fail_warning")]
pub fn return_if_fail_warning(
log_domain: Option<&str>,
pretty_function: &str,
expression: Option<&str>,
) {
unsafe {
ffi::g_return_if_fail_warning(
log_domain.to_glib_none().0,
pretty_function.to_glib_none().0,
expression.to_glib_none().0,
);
}
}
#[doc(alias = "g_rmdir")]
pub fn rmdir<P: AsRef<std::path::Path>>(filename: P) -> i32 {
unsafe { ffi::g_rmdir(filename.as_ref().to_glib_none().0) }
}
#[doc(alias = "g_set_application_name")]
pub fn set_application_name(application_name: &str) {
unsafe {
ffi::g_set_application_name(application_name.to_glib_none().0);
}
}
#[doc(alias = "g_shell_parse_argv")]
pub fn shell_parse_argv<P: AsRef<std::ffi::OsStr>>(
command_line: P,
) -> Result<Vec<std::ffi::OsString>, crate::Error> {
unsafe {
let mut argcp = mem::MaybeUninit::uninit();
let mut argvp = ptr::null_mut();
let mut error = ptr::null_mut();
let _ = ffi::g_shell_parse_argv(
command_line.as_ref().to_glib_none().0,
argcp.as_mut_ptr(),
&mut argvp,
&mut error,
);
if error.is_null() {
Ok(FromGlibContainer::from_glib_full_num(
argvp,
argcp.assume_init() as usize,
))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_shell_quote")]
pub fn shell_quote<P: AsRef<std::ffi::OsStr>>(unquoted_string: P) -> std::ffi::OsString {
unsafe {
from_glib_full(ffi::g_shell_quote(
unquoted_string.as_ref().to_glib_none().0,
))
}
}
#[doc(alias = "g_shell_unquote")]
pub fn shell_unquote<P: AsRef<std::ffi::OsStr>>(
quoted_string: P,
) -> Result<std::ffi::OsString, crate::Error> {
unsafe {
let mut error = ptr::null_mut();
let ret = ffi::g_shell_unquote(quoted_string.as_ref().to_glib_none().0, &mut error);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_spaced_primes_closest")]
pub fn spaced_primes_closest(num: u32) -> u32 {
unsafe { ffi::g_spaced_primes_closest(num) }
}
#[doc(alias = "g_spawn_async")]
pub fn spawn_async<P: AsRef<std::path::Path>>(
working_directory: P,
argv: &[&std::path::Path],
envp: &[&std::path::Path],
flags: SpawnFlags,
child_setup: Option<Box_<dyn FnOnce() + 'static>>,
) -> Result<Pid, crate::Error> {
let child_setup_data: Box_<Option<Box_<dyn FnOnce() + 'static>>> = Box_::new(child_setup);
unsafe extern "C" fn child_setup_func<P: AsRef<std::path::Path>>(user_data: ffi::gpointer) {
let callback: Box_<Option<Box_<dyn FnOnce() + 'static>>> =
Box_::from_raw(user_data as *mut _);
let callback = (*callback).expect("cannot get closure...");
callback()
}
let child_setup = if child_setup_data.is_some() {
Some(child_setup_func::<P> as _)
} else {
None
};
let super_callback0: Box_<Option<Box_<dyn FnOnce() + 'static>>> = child_setup_data;
unsafe {
let mut child_pid = mem::MaybeUninit::uninit();
let mut error = ptr::null_mut();
let _ = ffi::g_spawn_async(
working_directory.as_ref().to_glib_none().0,
argv.to_glib_none().0,
envp.to_glib_none().0,
flags.into_glib(),
child_setup,
Box_::into_raw(super_callback0) as *mut _,
child_pid.as_mut_ptr(),
&mut error,
);
let child_pid = from_glib(child_pid.assume_init());
if error.is_null() {
Ok(child_pid)
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_spawn_check_exit_status")]
pub fn spawn_check_exit_status(exit_status: i32) -> Result<(), crate::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(any(unix, feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(unix)))]
#[doc(alias = "g_spawn_command_line_async")]
pub fn spawn_command_line_async<P: AsRef<std::ffi::OsStr>>(
command_line: P,
) -> Result<(), crate::Error> {
unsafe {
let mut error = ptr::null_mut();
let _ = ffi::g_spawn_command_line_async(command_line.as_ref().to_glib_none().0, &mut error);
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_stpcpy")]
pub fn stpcpy(dest: &str, src: &str) -> crate::GString {
unsafe { from_glib_full(ffi::g_stpcpy(dest.to_glib_none().0, src.to_glib_none().0)) }
}
#[doc(alias = "g_unlink")]
pub fn unlink<P: AsRef<std::path::Path>>(filename: P) -> i32 {
unsafe { ffi::g_unlink(filename.as_ref().to_glib_none().0) }
}
#[doc(alias = "g_usleep")]
pub fn usleep(microseconds: libc::c_ulong) {
unsafe {
ffi::g_usleep(microseconds);
}
}
#[cfg(any(feature = "v2_52", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_52")))]
#[doc(alias = "g_uuid_string_is_valid")]
pub fn uuid_string_is_valid(str: &str) -> bool {
unsafe { from_glib(ffi::g_uuid_string_is_valid(str.to_glib_none().0)) }
}
#[cfg(any(feature = "v2_52", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_52")))]
#[doc(alias = "g_uuid_string_random")]
pub fn uuid_string_random() -> crate::GString {
unsafe { from_glib_full(ffi::g_uuid_string_random()) }
}
#[doc(alias = "g_warn_message")]
pub fn warn_message(
domain: Option<&str>,
file: &str,
line: i32,
func: &str,
warnexpr: Option<&str>,
) {
unsafe {
ffi::g_warn_message(
domain.to_glib_none().0,
file.to_glib_none().0,
line,
func.to_glib_none().0,
warnexpr.to_glib_none().0,
);
}
}