Merge pull request #813 from RealKC/utf8-apis

glib: Bind more `g_utf8` APIs

Author: sdroege

glib/Gir.toml

@@ -24,6 +24,7 @@ generate = [
     "GLib.LogWriterOutput",
     "GLib.MainContextFlags",
     "GLib.MarkupError",
+    "GLib.NormalizeMode",
     "GLib.OptionArg",
     "GLib.OptionFlags",
     "GLib.SeekType",

glib/src/auto/enums.rs

@@ -805,6 +805,66 @@ impl ErrorDomain for MarkupError {
     }
 }
 
+#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
+#[non_exhaustive]
+#[doc(alias = "GNormalizeMode")]
+pub enum NormalizeMode {
+    #[doc(alias = "G_NORMALIZE_DEFAULT")]
+    Default,
+    #[doc(alias = "G_NORMALIZE_DEFAULT_COMPOSE")]
+    DefaultCompose,
+    #[doc(alias = "G_NORMALIZE_ALL")]
+    All,
+    #[doc(alias = "G_NORMALIZE_ALL_COMPOSE")]
+    AllCompose,
+    #[doc(hidden)]
+    __Unknown(i32),
+}
+
+impl fmt::Display for NormalizeMode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "NormalizeMode::{}",
+            match *self {
+                Self::Default => "Default",
+                Self::DefaultCompose => "DefaultCompose",
+                Self::All => "All",
+                Self::AllCompose => "AllCompose",
+                _ => "Unknown",
+            }
+        )
+    }
+}
+
+#[doc(hidden)]
+impl IntoGlib for NormalizeMode {
+    type GlibType = ffi::GNormalizeMode;
+
+    fn into_glib(self) -> ffi::GNormalizeMode {
+        match self {
+            Self::Default => ffi::G_NORMALIZE_DEFAULT,
+            Self::DefaultCompose => ffi::G_NORMALIZE_DEFAULT_COMPOSE,
+            Self::All => ffi::G_NORMALIZE_ALL,
+            Self::AllCompose => ffi::G_NORMALIZE_ALL_COMPOSE,
+            Self::__Unknown(value) => value,
+        }
+    }
+}
+
+#[doc(hidden)]
+impl FromGlib<ffi::GNormalizeMode> for NormalizeMode {
+    unsafe fn from_glib(value: ffi::GNormalizeMode) -> Self {
+        match value {
+            ffi::G_NORMALIZE_DEFAULT => Self::Default,
+            ffi::G_NORMALIZE_DEFAULT_COMPOSE => Self::DefaultCompose,
+            ffi::G_NORMALIZE_ALL => Self::All,
+            ffi::G_NORMALIZE_ALL_COMPOSE => Self::AllCompose,
+            value => Self::__Unknown(value),
+        }
+    }
+}
+
 #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
 #[non_exhaustive]
 #[doc(alias = "GOptionArg")]

glib/src/auto/mod.rs

@@ -42,6 +42,7 @@ pub use self::enums::FileError;
 pub use self::enums::KeyFileError;
 pub use self::enums::LogWriterOutput;
 pub use self::enums::MarkupError;
+pub use self::enums::NormalizeMode;
 pub use self::enums::OptionArg;
 pub use self::enums::SeekType;
 pub use self::enums::TimeType;

glib/src/convert.rs

@@ -2,7 +2,7 @@
 
 use std::{io, os::raw::c_char, path::PathBuf, ptr};
 
-use crate::{translate::*, ConvertError, Error, GStr, GString, Slice};
+use crate::{translate::*, ConvertError, Error, GStr, GString, NormalizeMode, Slice};
 
 // rustdoc-stripper-ignore-next
 /// A wrapper for [`ConvertError`](crate::ConvertError) that can hold an offset into the input
@@ -318,6 +318,74 @@ pub fn locale_to_utf8(opsysstring: &[u8]) -> Result<(crate::GString, usize), Cvt
     }
 }
 
+#[doc(alias = "g_utf8_to_ucs4")]
+#[doc(alias = "g_utf8_to_ucs4_fast")]
+#[doc(alias = "utf8_to_ucs4")]
+pub fn utf8_to_utf32(str: impl AsRef<str>) -> Slice<char> {
+    unsafe {
+        let mut items_written = 0;
+
+        let str_as_utf32 = ffi::g_utf8_to_ucs4_fast(
+            str.as_ref().as_ptr().cast::<c_char>(),
+            str.as_ref().len() as _,
+            &mut items_written,
+        );
+
+        // NOTE: We assume that u32 and char have the same layout and trust that glib won't give us
+        //       invalid UTF-32 codepoints
+        Slice::from_glib_full_num(str_as_utf32.cast::<char>(), items_written as usize)
+    }
+}
+
+#[doc(alias = "g_ucs4_to_utf8")]
+#[doc(alias = "ucs4_to_utf8")]
+pub fn utf32_to_utf8(str: impl AsRef<[char]>) -> GString {
+    let mut items_read = 0;
+    let mut items_written = 0;
+    let mut error = ptr::null_mut();
+
+    unsafe {
+        let str_as_utf8 = ffi::g_ucs4_to_utf8(
+            str.as_ref().as_ptr().cast::<u32>(),
+            str.as_ref().len() as _,
+            &mut items_read,
+            &mut items_written,
+            &mut error,
+        );
+
+        assert!(
+            error.is_null(),
+            "Rust `char` should always be convertible to UTF-8"
+        );
+
+        GString::from_glib_full_num(str_as_utf8, items_written as usize)
+    }
+}
+
+#[doc(alias = "g_utf8_casefold")]
+#[doc(alias = "utf8_casefold")]
+pub fn casefold(str: impl AsRef<str>) -> GString {
+    unsafe {
+        let str = ffi::g_utf8_casefold(str.as_ref().as_ptr().cast(), str.as_ref().len() as isize);
+
+        from_glib_full(str)
+    }
+}
+
+#[doc(alias = "g_utf8_normalize")]
+#[doc(alias = "utf8_normalize")]
+pub fn normalize(str: impl AsRef<str>, mode: NormalizeMode) -> GString {
+    unsafe {
+        let str = ffi::g_utf8_normalize(
+            str.as_ref().as_ptr().cast(),
+            str.as_ref().len() as isize,
+            mode.into_glib(),
+        );
+
+        from_glib_full(str)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[test]
@@ -350,4 +418,15 @@ mod tests {
     fn filename_charsets() {
         let _ = super::filename_charsets();
     }
+
+    #[test]
+    fn utf8_and_utf32() {
+        let utf32 = ['A', 'b', '🤔'];
+        let utf8 = super::utf32_to_utf8(utf32);
+        assert_eq!(utf8, "Ab🤔");
+
+        let utf8 = "🤔 ț";
+        let utf32 = super::utf8_to_utf32(utf8);
+        assert_eq!(utf32.as_slice(), &['🤔', ' ', 'ț']);
+    }
 }

glib/src/gstring.rs

@@ -121,6 +121,12 @@ impl GStr {
     pub fn as_c_str(&self) -> &CStr {
         unsafe { CStr::from_bytes_with_nul_unchecked(self.to_bytes_with_nul()) }
     }
+
+    #[doc(alias = "g_utf8_collate")]
+    #[doc(alias = "utf8_collate")]
+    pub fn collate(&self, other: impl AsRef<GStr>) -> Ordering {
+        unsafe { ffi::g_utf8_collate(self.as_ptr(), other.as_ref().as_ptr()) }.cmp(&0)
+    }
 }
 
 // rustdoc-stripper-ignore-next