glib/auto/functions.rs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT
#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
use crate::FileSetContentsFlags;
use crate::{
ffi, translate::*, Bytes, ChecksumType, Error, FileTest, FormatSizeFlags, Pid, Source,
SpawnFlags, UserDirectory,
};
use std::boxed::Box as Box_;
/// A wrapper for the POSIX access() function. This function is used to
/// test a pathname for one or several of read, write or execute
/// permissions, or just existence.
///
/// On Windows, the file protection mechanism is not at all POSIX-like,
/// and the underlying function in the C library only checks the
/// FAT-style READONLY attribute, and does not look at the ACL of a
/// file at all. This function is this in practise almost useless on
/// Windows. Software that needs to handle file permissions on Windows
/// more exactly should use the Win32 API.
///
/// See your C library manual for more details about access().
/// ## `filename`
/// a pathname in the GLib file name encoding
/// (UTF-8 on Windows)
/// ## `mode`
/// as in access()
///
/// # Returns
///
/// zero if the pathname refers to an existing file system
/// object that has all the tested permissions, or -1 otherwise
/// or on error.
#[doc(alias = "g_access")]
pub fn access(filename: impl AsRef<std::path::Path>, mode: i32) -> i32 {
unsafe { ffi::g_access(filename.as_ref().to_glib_none().0, mode) }
}
/// Decode a sequence of Base-64 encoded text into binary data. Note
/// that the returned binary data is not necessarily zero-terminated,
/// so it should not be used as a character string.
/// ## `text`
/// zero-terminated string with base64 text to decode
///
/// # Returns
///
///
/// newly allocated buffer containing the binary data
/// that @text represents. The returned buffer must
/// be freed with g_free().
#[doc(alias = "g_base64_decode")]
pub fn base64_decode(text: &str) -> Vec<u8> {
unsafe {
let mut out_len = std::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 _,
);
ret
}
}
//#[doc(alias = "g_base64_decode_inplace")]
//pub fn base64_decode_inplace(text: /*Unimplemented*/Vec<u8>) -> u8 {
// unsafe { TODO: call ffi:g_base64_decode_inplace() }
//}
//#[doc(alias = "g_base64_decode_step")]
//pub fn base64_decode_step(in_: &[u8], out: Vec<u8>, state: &mut i32, save: &mut u32) -> usize {
// unsafe { TODO: call ffi:g_base64_decode_step() }
//}
/// Encode a sequence of binary data into its Base-64 stringified
/// representation.
/// ## `data`
/// the binary data to encode
///
/// # Returns
///
/// a newly allocated, zero-terminated Base-64
/// encoded string representing @data. The returned string must
/// be freed with g_free().
#[doc(alias = "g_base64_encode")]
pub fn base64_encode(data: &[u8]) -> crate::GString {
let len = data.len() as _;
unsafe { from_glib_full(ffi::g_base64_encode(data.to_glib_none().0, len)) }
}
//#[doc(alias = "g_base64_encode_close")]
//pub fn base64_encode_close(break_lines: bool, out: Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
// unsafe { TODO: call ffi:g_base64_encode_close() }
//}
//#[doc(alias = "g_base64_encode_step")]
//pub fn base64_encode_step(in_: &[u8], break_lines: bool, out: Vec<u8>, state: &mut i32, save: &mut i32) -> usize {
// unsafe { TODO: call ffi:g_base64_encode_step() }
//}
/// Checks that the GLib library in use is compatible with the
/// given version.
///
/// Generally you would pass in the constants `GLIB_MAJOR_VERSION`,
/// `GLIB_MINOR_VERSION`, `GLIB_MICRO_VERSION` as the three arguments
/// to this function; that produces a check that the library in use
/// is compatible with the version of GLib the application or module
/// was compiled against.
///
/// Compatibility is defined by two things: first the version
/// of the running library is newer than the version
/// `@required_major.required_minor.@required_micro`. Second
/// the running library must be binary compatible with the
/// version `@required_major.@required_minor.@required_micro`
/// (same major version.)
/// ## `required_major`
/// the required major version
/// ## `required_minor`
/// the required minor version
/// ## `required_micro`
/// the required micro version
///
/// # Returns
///
/// [`None`] if the GLib library is
/// compatible with the given version, or a string describing the
/// version mismatch. The returned string is owned by GLib and must
/// not be modified or freed.
#[doc(alias = "glib_check_version")]
pub fn check_version(
required_major: u32,
required_minor: u32,
required_micro: u32,
) -> Option<crate::GString> {
unsafe {
from_glib_none(ffi::glib_check_version(
required_major,
required_minor,
required_micro,
))
}
}
/// Computes the checksum for a binary @data. This is a
/// convenience wrapper for g_checksum_new(), g_checksum_get_string()
/// and g_checksum_free().
///
/// The hexadecimal string returned will be in lower case.
/// ## `checksum_type`
/// a #GChecksumType
/// ## `data`
/// binary blob to compute the digest of
///
/// # Returns
///
/// the digest of the binary data as a
/// string in hexadecimal, or [`None`] if g_checksum_new() fails for
/// @checksum_type. The returned string should be freed with g_free() when
/// done using it.
#[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,
))
}
}
/// Computes the checksum for a binary @data of @length. This is a
/// convenience wrapper for g_checksum_new(), g_checksum_get_string()
/// and g_checksum_free().
///
/// The hexadecimal string returned will be in lower case.
/// ## `checksum_type`
/// a #GChecksumType
/// ## `data`
/// binary blob to compute the digest of
///
/// # Returns
///
/// the digest of the binary data as a
/// string in hexadecimal, or [`None`] if g_checksum_new() fails for
/// @checksum_type. The returned string should be freed with g_free() when
/// done using it.
#[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 _;
unsafe {
from_glib_full(ffi::g_compute_checksum_for_data(
checksum_type.into_glib(),
data.to_glib_none().0,
length,
))
}
}
/// Computes the HMAC for a binary @data. This is a
/// convenience wrapper for g_hmac_new(), g_hmac_get_string()
/// and g_hmac_unref().
///
/// The hexadecimal string returned will be in lower case.
/// ## `digest_type`
/// a #GChecksumType to use for the HMAC
/// ## `key`
/// the key to use in the HMAC
/// ## `data`
/// binary blob to compute the HMAC of
///
/// # Returns
///
/// the HMAC of the binary data as a string in hexadecimal.
/// The returned string should be freed with g_free() when done using it.
#[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,
))
}
}
/// Computes the HMAC for a binary @data of @length. This is a
/// convenience wrapper for g_hmac_new(), g_hmac_get_string()
/// and g_hmac_unref().
///
/// The hexadecimal string returned will be in lower case.
/// ## `digest_type`
/// a #GChecksumType to use for the HMAC
/// ## `key`
/// the key to use in the HMAC
/// ## `data`
/// binary blob to compute the HMAC of
///
/// # Returns
///
/// the HMAC of the binary data as a string in hexadecimal.
/// The returned string should be freed with g_free() when done using it.
#[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 _;
let length = data.len() as _;
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,
))
}
}
/// This is a variant of g_dgettext() that allows specifying a locale
/// category instead of always using `LC_MESSAGES`. See g_dgettext() for
/// more information about how this functions differs from calling
/// dcgettext() directly.
/// ## `domain`
/// the translation domain to use, or [`None`] to use
/// the domain set with textdomain()
/// ## `msgid`
/// message to translate
/// ## `category`
/// a locale category
///
/// # Returns
///
/// the translated string for the given locale category
#[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,
))
}
}
/// This function is a wrapper of dgettext() which does not translate
/// the message if the default domain as set with textdomain() has no
/// translations for the current locale.
///
/// The advantage of using this function over dgettext() proper is that
/// libraries using this function (like GTK) will not use translations
/// if the application using the library does not have translations for
/// the current locale. This results in a consistent English-only
/// interface instead of one having partial translations. For this
/// feature to work, the call to textdomain() and setlocale() should
/// precede any g_dgettext() invocations. For GTK, it means calling
/// textdomain() before gtk_init or its variants.
///
/// This function disables translations if and only if upon its first
/// call all the following conditions hold:
///
/// - @domain is not [`None`]
///
/// - textdomain() has been called to set a default text domain
///
/// - there is no translations available for the default text domain
/// and the current locale
///
/// - current locale is not "C" or any English locales (those
/// starting with "en_")
///
/// Note that this behavior may not be desired for example if an application
/// has its untranslated messages in a language other than English. In those
/// cases the application should call textdomain() after initializing GTK.
///
/// Applications should normally not use this function directly,
/// but use the _() macro for translations.
/// ## `domain`
/// the translation domain to use, or [`None`] to use
/// the domain set with textdomain()
/// ## `msgid`
/// message to translate
///
/// # Returns
///
/// The translated string
#[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,
))
}
}
/// This function is a wrapper of dngettext() which does not translate
/// the message if the default domain as set with textdomain() has no
/// translations for the current locale.
///
/// See g_dgettext() for details of how this differs from dngettext()
/// proper.
/// ## `domain`
/// the translation domain to use, or [`None`] to use
/// the domain set with textdomain()
/// ## `msgid`
/// message to translate
/// ## `msgid_plural`
/// plural form of the message
/// ## `n`
/// the quantity for which translation is needed
///
/// # Returns
///
/// The translated string
#[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,
))
}
}
/// This function is a variant of g_dgettext() which supports
/// a disambiguating message context. GNU gettext uses the
/// '\004' character to separate the message context and
/// message id in @msgctxtid.
/// If 0 is passed as @msgidoffset, this function will fall back to
/// trying to use the deprecated convention of using "|" as a separation
/// character.
///
/// This uses g_dgettext() internally. See that functions for differences
/// with dgettext() proper.
///
/// Applications should normally not use this function directly,
/// but use the C_() macro for translations with context.
/// ## `domain`
/// the translation domain to use, or [`None`] to use
/// the domain set with textdomain()
/// ## `msgctxtid`
/// a combined message context and message id, separated
/// by a \004 character
/// ## `msgidoffset`
/// the offset of the message id in @msgctxid
///
/// # Returns
///
/// The translated string
#[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,
))
}
}
/// This function is a variant of g_dgettext() which supports
/// a disambiguating message context. GNU gettext uses the
/// '\004' character to separate the message context and
/// message id in @msgctxtid.
///
/// This uses g_dgettext() internally. See that functions for differences
/// with dgettext() proper.
///
/// This function differs from C_() in that it is not a macro and
/// thus you may use non-string-literals as context and msgid arguments.
/// ## `domain`
/// the translation domain to use, or [`None`] to use
/// the domain set with textdomain()
/// ## `context`
/// the message context
/// ## `msgid`
/// the message
///
/// # Returns
///
/// The translated string
#[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,
))
}
}
/// Writes all of @contents to a file named @filename. This is a convenience
/// wrapper around calling g_file_set_contents_full() with `flags` set to
/// `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and
/// `mode` set to `0666`.
/// ## `filename`
/// name of a file to write @contents to, in the GLib file name
/// encoding
/// ## `contents`
/// string to write to the file
///
/// # Returns
///
/// [`true`] on success, [`false`] if an error occurred
#[doc(alias = "g_file_set_contents")]
pub fn file_set_contents(
filename: impl AsRef<std::path::Path>,
contents: &[u8],
) -> Result<(), crate::Error> {
let length = contents.len() as _;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_file_set_contents(
filename.as_ref().to_glib_none().0,
contents.to_glib_none().0,
length,
&mut error,
);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Writes all of @contents to a file named @filename, with good error checking.
/// If a file called @filename already exists it will be overwritten.
///
/// @flags control the properties of the write operation: whether it’s atomic,
/// and what the tradeoff is between returning quickly or being resilient to
/// system crashes.
///
/// As this function performs file I/O, it is recommended to not call it anywhere
/// where blocking would cause problems, such as in the main loop of a graphical
/// application. In particular, if @flags has any value other than
/// [`FileSetContentsFlags::NONE`][crate::FileSetContentsFlags::NONE] then this function may call `fsync()`.
///
/// If [`FileSetContentsFlags::CONSISTENT`][crate::FileSetContentsFlags::CONSISTENT] is set in @flags, the operation is atomic
/// in the sense that it is first written to a temporary file which is then
/// renamed to the final name.
///
/// Notes:
///
/// - On UNIX, if @filename already exists hard links to @filename will break.
/// Also since the file is recreated, existing permissions, access control
/// lists, metadata etc. may be lost. If @filename is a symbolic link,
/// the link itself will be replaced, not the linked file.
///
/// - On UNIX, if @filename already exists and is non-empty, and if the system
/// supports it (via a journalling filesystem or equivalent), and if
/// [`FileSetContentsFlags::CONSISTENT`][crate::FileSetContentsFlags::CONSISTENT] is set in @flags, the `fsync()` call (or
/// equivalent) will be used to ensure atomic replacement: @filename
/// will contain either its old contents or @contents, even in the face of
/// system power loss, the disk being unsafely removed, etc.
///
/// - On UNIX, if @filename does not already exist or is empty, there is a
/// possibility that system power loss etc. after calling this function will
/// leave @filename empty or full of NUL bytes, depending on the underlying
/// filesystem, unless [`FileSetContentsFlags::DURABLE`][crate::FileSetContentsFlags::DURABLE] and
/// [`FileSetContentsFlags::CONSISTENT`][crate::FileSetContentsFlags::CONSISTENT] are set in @flags.
///
/// - On Windows renaming a file will not remove an existing file with the
/// new name, so on Windows there is a race condition between the existing
/// file being removed and the temporary file being renamed.
///
/// - On Windows there is no way to remove a file that is open to some
/// process, or mapped into memory. Thus, this function will fail if
/// @filename already exists and is open.
///
/// If the call was successful, it returns [`true`]. If the call was not successful,
/// it returns [`false`] and sets @error. The error domain is `G_FILE_ERROR`.
/// Possible error codes are those in the #GFileError enumeration.
///
/// Note that the name for the temporary file is constructed by appending up
/// to 7 characters to @filename.
///
/// If the file didn’t exist before and is created, it will be given the
/// permissions from @mode. Otherwise, the permissions of the existing file may
/// be changed to @mode depending on @flags, or they may remain unchanged.
/// ## `filename`
/// name of a file to write @contents to, in the GLib file name
/// encoding
/// ## `contents`
/// string to write to the file
/// ## `flags`
/// flags controlling the safety vs speed of the operation
/// ## `mode`
/// file mode, as passed to `open()`; typically this will be `0666`
///
/// # Returns
///
/// [`true`] on success, [`false`] if an error occurred
#[cfg(feature = "v2_66")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
#[doc(alias = "g_file_set_contents_full")]
pub fn file_set_contents_full(
filename: impl AsRef<std::path::Path>,
contents: &[u8],
flags: FileSetContentsFlags,
mode: i32,
) -> Result<(), crate::Error> {
let length = contents.len() as _;
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = 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,
);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// Returns [`true`] if any of the tests in the bitfield @test are
/// [`true`]. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)`
/// will return [`true`] if the file exists; the check whether it's a
/// directory doesn't matter since the existence test is [`true`]. With
/// the current set of available tests, there's no point passing in
/// more than one test at a time.
///
/// Apart from [`FileTest::IS_SYMLINK`][crate::FileTest::IS_SYMLINK] all tests follow symbolic links,
/// so for a symbolic link to a regular file g_file_test() will return
/// [`true`] for both [`FileTest::IS_SYMLINK`][crate::FileTest::IS_SYMLINK] and [`FileTest::IS_REGULAR`][crate::FileTest::IS_REGULAR].
///
/// Note, that for a dangling symbolic link g_file_test() will return
/// [`true`] for [`FileTest::IS_SYMLINK`][crate::FileTest::IS_SYMLINK] and [`false`] for all other flags.
///
/// You should never use g_file_test() to test whether it is safe
/// to perform an operation, because there is always the possibility
/// of the condition changing before you actually perform the operation,
/// see [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use).
///
/// For example, you might think you could use [`FileTest::IS_SYMLINK`][crate::FileTest::IS_SYMLINK]
/// to know whether it is safe to write to a file without being
/// tricked into writing into a different location. It doesn't work!
///
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
/// // DON'T DO THIS
/// if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
/// {
/// fd = g_open (filename, O_WRONLY);
/// // write to fd
/// }
///
/// // DO THIS INSTEAD
/// fd = g_open (filename, O_WRONLY | O_NOFOLLOW | O_CLOEXEC);
/// if (fd == -1)
/// {
/// // check error
/// if (errno == ELOOP)
/// // file is a symlink and can be ignored
/// else
/// // handle errors as before
/// }
/// else
/// {
/// // write to fd
/// }
/// ```
///
/// Another thing to note is that [`FileTest::EXISTS`][crate::FileTest::EXISTS] and
/// [`FileTest::IS_EXECUTABLE`][crate::FileTest::IS_EXECUTABLE] are implemented using the access()
/// system call. This usually doesn't matter, but if your program
/// is setuid or setgid it means that these tests will give you
/// the answer for the real user ID and group ID, rather than the
/// effective user ID and group ID.
///
/// On Windows, there are no symlinks, so testing for
/// [`FileTest::IS_SYMLINK`][crate::FileTest::IS_SYMLINK] will always return [`false`]. Testing for
/// [`FileTest::IS_EXECUTABLE`][crate::FileTest::IS_EXECUTABLE] will just check that the file exists and
/// its name indicates that it is executable, checking for well-known
/// extensions and those listed in the `PATHEXT` environment variable.
/// ## `filename`
/// a filename to test in the
/// GLib file name encoding
/// ## `test`
/// bitfield of #GFileTest flags
///
/// # Returns
///
/// whether a test was [`true`]
#[doc(alias = "g_file_test")]
#[allow(dead_code)]
pub(crate) fn file_test(filename: impl AsRef<std::path::Path>, test: FileTest) -> bool {
unsafe {
from_glib(ffi::g_file_test(
filename.as_ref().to_glib_none().0,
test.into_glib(),
))
}
}
/// Returns the display basename for the particular filename, guaranteed
/// to be valid UTF-8. The display name might not be identical to the filename,
/// for instance there might be problems converting it to UTF-8, and some files
/// can be translated in the display.
///
/// If GLib cannot make sense of the encoding of @filename, as a last resort it
/// replaces unknown characters with U+FFFD, the Unicode replacement character.
/// You can search the result for the UTF-8 encoding of this character (which is
/// "\357\277\275" in octal notation) to find out if @filename was in an invalid
/// encoding.
///
/// You must pass the whole absolute pathname to this functions so that
/// translation of well known locations can be done.
///
/// This function is preferred over g_filename_display_name() if you know the
/// whole path, as it allows translation.
/// ## `filename`
/// an absolute pathname in the
/// GLib file name encoding
///
/// # Returns
///
/// a newly allocated string containing
/// a rendition of the basename of the filename in valid UTF-8
#[doc(alias = "g_filename_display_basename")]
pub fn filename_display_basename(filename: impl AsRef<std::path::Path>) -> crate::GString {
unsafe {
from_glib_full(ffi::g_filename_display_basename(
filename.as_ref().to_glib_none().0,
))
}
}
/// Converts a filename into a valid UTF-8 string. The conversion is
/// not necessarily reversible, so you should keep the original around
/// and use the return value of this function only for display purposes.
/// Unlike g_filename_to_utf8(), the result is guaranteed to be non-[`None`]
/// even if the filename actually isn't in the GLib file name encoding.
///
/// If GLib cannot make sense of the encoding of @filename, as a last resort it
/// replaces unknown characters with U+FFFD, the Unicode replacement character.
/// You can search the result for the UTF-8 encoding of this character (which is
/// "\357\277\275" in octal notation) to find out if @filename was in an invalid
/// encoding.
///
/// If you know the whole pathname of the file you should use
/// g_filename_display_basename(), since that allows location-based
/// translation of filenames.
/// ## `filename`
/// a pathname hopefully in the
/// GLib file name encoding
///
/// # Returns
///
/// a newly allocated string containing
/// a rendition of the filename in valid UTF-8
#[doc(alias = "g_filename_display_name")]
pub fn filename_display_name(filename: impl AsRef<std::path::Path>) -> crate::GString {
unsafe {
from_glib_full(ffi::g_filename_display_name(
filename.as_ref().to_glib_none().0,
))
}
}
/// Converts an escaped ASCII-encoded URI to a local filename in the
/// encoding used for filenames.
///
/// Since GLib 2.78, the query string and fragment can be present in the URI,
/// but are not part of the resulting filename.
/// We take inspiration from https://url.spec.whatwg.org/#file-state,
/// but we don't support the entire standard.
/// ## `uri`
/// a uri describing a filename (escaped, encoded in ASCII).
///
/// # Returns
///
/// a newly-allocated string holding
/// the resulting filename, or [`None`] on an error.
///
/// ## `hostname`
/// Location to store hostname for the URI.
/// If there is no hostname in the URI, [`None`] will be
/// stored in this location.
#[doc(alias = "g_filename_from_uri")]
pub fn filename_from_uri(
uri: &str,
) -> Result<(std::path::PathBuf, Option<crate::GString>), crate::Error> {
unsafe {
let mut hostname = std::ptr::null_mut();
let mut error = std::ptr::null_mut();
let ret = ffi::g_filename_from_uri(uri.to_glib_none().0, &mut hostname, &mut error);
if error.is_null() {
Ok((from_glib_full(ret), from_glib_full(hostname)))
} else {
Err(from_glib_full(error))
}
}
}
/// Converts an absolute filename to an escaped ASCII-encoded URI, with the path
/// component following Section 3.3. of RFC 2396.
/// ## `filename`
/// an absolute filename specified in the GLib file
/// name encoding, which is the on-disk file name bytes on Unix, and UTF-8
/// on Windows
/// ## `hostname`
/// A UTF-8 encoded hostname, or [`None`] for none.
///
/// # Returns
///
/// a newly-allocated string holding the resulting
/// URI, or [`None`] on an error.
#[doc(alias = "g_filename_to_uri")]
pub fn filename_to_uri(
filename: impl AsRef<std::path::Path>,
hostname: Option<&str>,
) -> Result<crate::GString, crate::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let ret = ffi::g_filename_to_uri(
filename.as_ref().to_glib_none().0,
hostname.to_glib_none().0,
&mut error,
);
if error.is_null() {
Ok(from_glib_full(ret))
} else {
Err(from_glib_full(error))
}
}
}
/// Locates the first executable named @program in the user's path, in the
/// same way that execvp() would locate it. Returns an allocated string
/// with the absolute path name, or [`None`] if the program is not found in
/// the path. If @program is already an absolute path, returns a copy of
/// @program if @program exists and is executable, and [`None`] otherwise.
///
/// On Windows, if @program does not have a file type suffix, tries
/// with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
/// the `PATHEXT` environment variable.
///
/// On Windows, it looks for the file in the same way as CreateProcess()
/// would. This means first in the directory where the executing
/// program was loaded from, then in the current directory, then in the
/// Windows 32-bit system directory, then in the Windows directory, and
/// finally in the directories in the `PATH` environment variable. If
/// the program is found, the return value contains the full name
/// including the type suffix.
/// ## `program`
/// a program name in the GLib file name encoding
///
/// # Returns
///
/// a newly-allocated
/// string with the absolute path, or [`None`]
#[doc(alias = "g_find_program_in_path")]
pub fn find_program_in_path(program: impl AsRef<std::path::Path>) -> Option<std::path::PathBuf> {
unsafe {
from_glib_full(ffi::g_find_program_in_path(
program.as_ref().to_glib_none().0,
))
}
}
/// Formats a size (for example the size of a file) into a human readable
/// string. Sizes are rounded to the nearest size prefix (kB, MB, GB)
/// and are displayed rounded to the nearest tenth. E.g. the file size
/// 3292528 bytes will be converted into the string "3.2 MB". The returned string
/// is UTF-8, and may use a non-breaking space to separate the number and units,
/// to ensure they aren’t separated when line wrapped.
///
/// The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
///
/// This string should be freed with g_free() when not needed any longer.
///
/// See g_format_size_full() for more options about how the size might be
/// formatted.
/// ## `size`
/// a size in bytes
///
/// # Returns
///
/// a newly-allocated formatted string containing
/// a human readable file size
#[doc(alias = "g_format_size")]
pub fn format_size(size: u64) -> crate::GString {
unsafe { from_glib_full(ffi::g_format_size(size)) }
}
/// Formats a size.
///
/// This function is similar to g_format_size() but allows for flags
/// that modify the output. See #GFormatSizeFlags.
/// ## `size`
/// a size in bytes
/// ## `flags`
/// #GFormatSizeFlags to modify the output
///
/// # Returns
///
/// a newly-allocated formatted string
/// containing a human readable file 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())) }
}
/// Gets a human-readable name for the application, as set by
/// g_set_application_name(). This name should be localized if
/// possible, and is intended for display to the user. Contrast with
/// g_get_prgname(), which gets a non-localized name. If
/// g_set_application_name() has not been called, returns the result of
/// g_get_prgname() (which may be [`None`] if g_set_prgname() has also not
/// been called).
///
/// # Returns
///
/// human-readable application
/// name. May return [`None`]
#[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()) }
}
/// Gets the character set for the current locale.
///
/// # Returns
///
/// a newly allocated string containing the name
/// of the character set. This string must be freed with g_free().
#[doc(alias = "g_get_codeset")]
#[doc(alias = "get_codeset")]
pub fn codeset() -> crate::GString {
unsafe { from_glib_full(ffi::g_get_codeset()) }
}
/// Obtains the character set used by the console attached to the process,
/// which is suitable for printing output to the terminal.
///
/// Usually this matches the result returned by g_get_charset(), but in
/// environments where the locale's character set does not match the encoding
/// of the console this function tries to guess a more suitable value instead.
///
/// On Windows the character set returned by this function is the
/// output code page used by the console associated with the calling process.
/// If the codepage can't be determined (for example because there is no
/// console attached) UTF-8 is assumed.
///
/// The return value is [`true`] if the locale's encoding is UTF-8, in that
/// case you can perhaps avoid calling g_convert().
///
/// The string returned in @charset is not allocated, and should not be
/// freed.
///
/// # Returns
///
/// [`true`] if the returned charset is UTF-8
///
/// ## `charset`
/// return location for character set
/// name, or [`None`].
#[cfg(feature = "v2_62")]
#[cfg_attr(docsrs, 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 = std::ptr::null();
let ret = from_glib(ffi::g_get_console_charset(&mut charset));
if ret {
Some(from_glib_none(charset))
} else {
None
}
}
}
/// Gets the current directory.
///
/// The returned string should be freed when no longer needed.
/// The encoding of the returned string is system defined.
/// On Windows, it is always UTF-8.
///
/// Since GLib 2.40, this function will return the value of the "PWD"
/// environment variable if it is set and it happens to be the same as
/// the current directory. This can make a difference in the case that
/// the current directory is the target of a symbolic link.
///
/// # Returns
///
/// the current directory
#[doc(alias = "g_get_current_dir")]
#[doc(alias = "get_current_dir")]
pub fn current_dir() -> std::path::PathBuf {
unsafe { from_glib_full(ffi::g_get_current_dir()) }
}
/// Gets the list of environment variables for the current process.
///
/// The list is [`None`] terminated and each item in the list is of the
/// form 'NAME=VALUE'.
///
/// This is equivalent to direct access to the 'environ' global variable,
/// except portable.
///
/// The return value is freshly allocated and it should be freed with
/// g_strfreev() when it is no longer needed.
///
/// # Returns
///
///
/// the list of environment variables
#[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()) }
}
/// Gets the current user's home directory.
///
/// As with most UNIX tools, this function will return the value of the
/// `HOME` environment variable if it is set to an existing absolute path
/// name, falling back to the `passwd` file in the case that it is unset.
///
/// If the path given in `HOME` is non-absolute, does not exist, or is
/// not a directory, the result is undefineReleases all references to other objects. This can be used to break
/// reference cycles.
///
/// This function should only be called from object system implementations.
#[doc(alias = "g_get_home_dir")]
#[doc(alias = "get_home_dir")]
pub fn home_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_home_dir()) }
}
#[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(feature = "v2_58")]
#[cfg_attr(docsrs, 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(feature = "v2_64")]
#[cfg_attr(docsrs, 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_name")]
#[doc(alias = "get_real_name")]
pub fn real_name() -> std::ffi::OsString {
unsafe { from_glib_none(ffi::g_get_real_name()) }
}
#[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_tmp_dir")]
#[doc(alias = "get_tmp_dir")]
pub fn tmp_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_tmp_dir()) }
}
#[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_name")]
#[doc(alias = "get_user_name")]
pub fn user_name() -> std::ffi::OsString {
unsafe { from_glib_none(ffi::g_get_user_name()) }
}
#[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) -> Option<std::path::PathBuf> {
unsafe { from_glib_none(ffi::g_get_user_special_dir(directory.into_glib())) }
}
#[cfg(feature = "v2_72")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
#[doc(alias = "g_get_user_state_dir")]
#[doc(alias = "get_user_state_dir")]
pub fn user_state_dir() -> std::path::PathBuf {
unsafe { from_glib_none(ffi::g_get_user_state_dir()) }
}
#[doc(alias = "g_getenv")]
pub fn getenv(variable: impl AsRef<std::ffi::OsStr>) -> Option<std::ffi::OsString> {
unsafe { from_glib_none(ffi::g_getenv(variable.as_ref().to_glib_none().0)) }
}
#[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 _;
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(pathname: impl AsRef<std::path::Path>, mode: i32) -> i32 {
unsafe { ffi::g_mkdir_with_parents(pathname.as_ref().to_glib_none().0, 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")]
#[allow(dead_code)]
pub(crate) fn path_get_basename(file_name: impl AsRef<std::path::Path>) -> 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")]
#[allow(dead_code)]
pub(crate) fn path_get_dirname(file_name: impl AsRef<std::path::Path>) -> std::path::PathBuf {
unsafe { from_glib_full(ffi::g_path_get_dirname(file_name.as_ref().to_glib_none().0)) }
}
//#[doc(alias = "g_poll")]
//pub fn poll(fds: /*Ignored*/&mut PollFD, nfds: u32, timeout: i32) -> i32 {
// unsafe { TODO: call ffi:g_poll() }
//}
#[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_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_setenv")]
pub fn setenv(
variable: impl AsRef<std::ffi::OsStr>,
value: impl AsRef<std::ffi::OsStr>,
overwrite: bool,
) -> Result<(), crate::error::BoolError> {
unsafe {
crate::result_from_gboolean!(
ffi::g_setenv(
variable.as_ref().to_glib_none().0,
value.as_ref().to_glib_none().0,
overwrite.into_glib()
),
"Failed to set environment variable"
)
}
}
#[doc(alias = "g_shell_parse_argv")]
pub fn shell_parse_argv(
command_line: impl AsRef<std::ffi::OsStr>,
) -> Result<Vec<std::ffi::OsString>, crate::Error> {
unsafe {
let mut argcp = std::mem::MaybeUninit::uninit();
let mut argvp = std::ptr::null_mut();
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_shell_parse_argv(
command_line.as_ref().to_glib_none().0,
argcp.as_mut_ptr(),
&mut argvp,
&mut error,
);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(FromGlibContainer::from_glib_full_num(
argvp,
argcp.assume_init() as _,
))
} else {
Err(from_glib_full(error))
}
}
}
#[doc(alias = "g_shell_quote")]
pub fn shell_quote(unquoted_string: impl AsRef<std::ffi::OsStr>) -> 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(
quoted_string: impl AsRef<std::ffi::OsStr>,
) -> Result<std::ffi::OsString, crate::Error> {
unsafe {
let mut error = std::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_sort_array")]
//pub fn sort_array(array: /*Unimplemented*/&[&Basic: Pointer], element_size: usize, compare_func: /*Unimplemented*/FnMut(/*Unimplemented*/Option<Basic: Pointer>, /*Unimplemented*/Option<Basic: Pointer>) -> i32, user_data: /*Unimplemented*/Option<Basic: Pointer>) {
// unsafe { TODO: call ffi:g_sort_array() }
//}
#[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(
working_directory: Option<impl AsRef<std::path::Path>>,
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(data: ffi::gpointer) {
let callback = Box_::from_raw(data as *mut Option<Box_<dyn FnOnce() + 'static>>);
let callback = (*callback).expect("cannot get closure...");
callback()
}
let child_setup = if child_setup_data.is_some() {
Some(child_setup_func as _)
} else {
None
};
let super_callback0: Box_<Option<Box_<dyn FnOnce() + 'static>>> = child_setup_data;
unsafe {
let mut child_pid = std::mem::MaybeUninit::uninit();
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_spawn_async(
working_directory
.as_ref()
.map(|p| p.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,
);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(from_glib(child_pid.assume_init()))
} else {
Err(from_glib_full(error))
}
}
}
//#[cfg(feature = "v2_68")]
//#[cfg_attr(docsrs, doc(cfg(feature = "v2_68")))]
//#[doc(alias = "g_spawn_async_with_pipes_and_fds")]
//pub fn spawn_async_with_pipes_and_fds(working_directory: Option<impl AsRef<std::path::Path>>, argv: &[&std::path::Path], envp: &[&std::path::Path], flags: SpawnFlags, child_setup: Option<Box_<dyn FnOnce() + 'static>>, stdin_fd: i32, stdout_fd: i32, stderr_fd: i32, source_fds: &[i32], target_fds: &[i32], n_fds: usize) -> Result<(Pid, i32, i32, i32), crate::Error> {
// unsafe { TODO: call ffi:g_spawn_async_with_pipes_and_fds() }
//}
#[cfg_attr(feature = "v2_70", deprecated = "Since 2.70")]
#[allow(deprecated)]
#[doc(alias = "g_spawn_check_exit_status")]
pub fn spawn_check_exit_status(wait_status: i32) -> Result<(), crate::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_spawn_check_exit_status(wait_status, &mut error);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
#[doc(alias = "g_spawn_check_wait_status")]
pub fn spawn_check_wait_status(wait_status: i32) -> Result<(), crate::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok = ffi::g_spawn_check_wait_status(wait_status, &mut error);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
/// A simple version of g_spawn_async() that parses a command line with
/// g_shell_parse_argv() and passes it to g_spawn_async().
///
/// Runs a command line in the background. Unlike g_spawn_async(), the
/// [`SpawnFlags::SEARCH_PATH`][crate::SpawnFlags::SEARCH_PATH] flag is enabled, other flags are not. Note
/// that [`SpawnFlags::SEARCH_PATH`][crate::SpawnFlags::SEARCH_PATH] can have security implications, so
/// consider using g_spawn_async() directly if appropriate. Possible
/// errors are those from g_shell_parse_argv() and g_spawn_async().
///
/// The same concerns on Windows apply as for g_spawn_command_line_sync().
/// ## `command_line`
/// a command line
///
/// # Returns
///
/// [`true`] on success, [`false`] if error is set
#[cfg(unix)]
#[cfg_attr(docsrs, doc(cfg(unix)))]
#[doc(alias = "g_spawn_command_line_async")]
pub fn spawn_command_line_async(
command_line: impl AsRef<std::ffi::OsStr>,
) -> Result<(), crate::Error> {
unsafe {
let mut error = std::ptr::null_mut();
let is_ok =
ffi::g_spawn_command_line_async(command_line.as_ref().to_glib_none().0, &mut error);
debug_assert_eq!(is_ok == crate::ffi::GFALSE, !error.is_null());
if error.is_null() {
Ok(())
} else {
Err(from_glib_full(error))
}
}
}
//#[doc(alias = "g_spawn_command_line_sync")]
//pub fn spawn_command_line_sync(command_line: impl AsRef<std::path::Path>, standard_output: Vec<u8>, standard_error: Vec<u8>) -> Result<i32, crate::Error> {
// unsafe { TODO: call ffi:g_spawn_command_line_sync() }
//}
//#[doc(alias = "g_spawn_sync")]
//pub fn spawn_sync(working_directory: Option<impl AsRef<std::path::Path>>, argv: &[&std::path::Path], envp: &[&std::path::Path], flags: SpawnFlags, child_setup: Option<&mut dyn (FnMut())>, standard_output: Vec<u8>, standard_error: Vec<u8>) -> Result<i32, crate::Error> {
// unsafe { TODO: call ffi:g_spawn_sync() }
//}
//#[doc(alias = "g_stat")]
//pub fn stat(filename: impl AsRef<std::path::Path>, buf: /*Ignored*/&mut StatBuf) -> i32 {
// unsafe { TODO: call ffi:g_stat() }
//}
//#[cfg(unix)]
//#[cfg_attr(docsrs, doc(cfg(unix)))]
//#[cfg(feature = "v2_64")]
//#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
//#[doc(alias = "g_unix_get_passwd_entry")]
//pub fn unix_get_passwd_entry(user_name: &str) -> Result</*Unimplemented*/Option<Basic: Pointer>, crate::Error> {
// unsafe { TODO: call ffi:g_unix_get_passwd_entry() }
//}
/// A wrapper for the POSIX unlink() function. The unlink() function
/// deletes a name from the filesystem. If this was the last link to the
/// file and no processes have it opened, the diskspace occupied by the
/// file is freed.
///
/// See your C library manual for more details about unlink(). Note
/// that on Windows, it is in general not possible to delete files that
/// are open to some process, or mapped into memory.
/// ## `filename`
/// a pathname in the GLib file name encoding
/// (UTF-8 on Windows)
///
/// # Returns
///
/// 0 if the name was successfully deleted, -1 if an error
/// occurred
#[doc(alias = "g_unlink")]
pub fn unlink(filename: impl AsRef<std::path::Path>) -> i32 {
unsafe { ffi::g_unlink(filename.as_ref().to_glib_none().0) }
}
/// Removes an environment variable from the environment.
///
/// Note that on some systems, when variables are overwritten, the
/// memory used for the previous variables and its value isn't reclaimed.
///
/// You should be mindful of the fact that environment variable handling
/// in UNIX is not thread-safe, and your program may crash if one thread
/// calls g_unsetenv() while another thread is calling getenv(). (And note
/// that many functions, such as gettext(), call getenv() internally.) This
/// function is only safe to use at the very start of your program, before
/// creating any other threads (or creating objects that create worker
/// threads of their own).
///
/// If you need to set up the environment for a child process, you can
/// use g_get_environ() to get an environment array, modify that with
/// g_environ_setenv() and g_environ_unsetenv(), and then pass that
/// array directly to execvpe(), g_spawn_async(), or the like.
/// ## `variable`
/// the environment variable to remove, must
/// not contain '='
#[doc(alias = "g_unsetenv")]
pub fn unsetenv(variable: impl AsRef<std::ffi::OsStr>) {
unsafe {
ffi::g_unsetenv(variable.as_ref().to_glib_none().0);
}
}
/// Pauses the current thread for the given number of microseconds.
///
/// There are 1 million microseconds per second (represented by the
/// `G_USEC_PER_SEC` macro). g_usleep() may have limited precision,
/// depending on hardware and operating system; don't rely on the exact
/// length of the sleep.
/// ## `microseconds`
/// number of microseconds to pause
#[doc(alias = "g_usleep")]
pub fn usleep(microseconds: libc::c_ulong) {
unsafe {
ffi::g_usleep(microseconds);
}
}
/// Parses the string @str and verify if it is a UUID.
///
/// The function accepts the following syntax:
///
/// - simple forms (e.g. `f81d4fae-7dec-11d0-a765-00a0c91e6bf6`)
///
/// Note that hyphens are required within the UUID string itself,
/// as per the aforementioned RFC.
/// ## `str`
/// a string representing a UUID
///
/// # Returns
///
/// [`true`] if @str is a valid UUID, [`false`] otherwise.
#[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)) }
}
/// Generates a random UUID (RFC 4122 version 4) as a string. It has the same
/// randomness guarantees as #GRand, so must not be used for cryptographic
/// purposes such as key generation, nonces, salts or one-time pads.
///
/// # Returns
///
/// A string that should be freed with g_free().
#[doc(alias = "g_uuid_string_random")]
pub fn uuid_string_random() -> crate::GString {
unsafe { from_glib_full(ffi::g_uuid_string_random()) }
}