glib: stack allocate GStringBuilder

add some PartialEq and PartialOrd implementations for GStr too

Author: jf2048

glib/src/gstring_builder.rs

@@ -1,6 +1,7 @@
 // Take a look at the license at the top of the repository in the LICENSE file.
 
 use crate::translate::*;
+use crate::GStr;
 use std::cmp;
 use std::fmt;
 use std::hash;
@@ -15,11 +16,17 @@ wrapper! {
     /// A mutable text buffer that grows automatically.
     #[doc(alias = "GString")]
     #[must_use = "The builder must be built to be used"]
-    pub struct GStringBuilder(Boxed<ffi::GString>);
+    pub struct GStringBuilder(BoxedInline<ffi::GString>);
 
     match fn {
-        copy => |ptr| ffi::g_string_new((*ptr).str),
+        copy => |ptr| ffi::g_string_new_len((*ptr).str, (*ptr).len.try_into().unwrap()),
         free => |ptr| ffi::g_string_free(ptr, ffi::GTRUE),
+        init => |ptr| ptr::write(ptr, mem::zeroed()),
+        copy_into => |dest, src| {
+            ptr::write(dest, mem::zeroed());
+            ffi::g_string_append_len(dest, (*src).str, (*src).len.try_into().unwrap());
+        },
+        clear => |ptr| ffi::g_free((*ptr).str as *mut _),
         type_ => || ffi::g_gstring_get_type(),
     }
 }
@@ -80,7 +87,7 @@ impl GStringBuilder {
     }
 
     // rustdoc-stripper-ignore-next
-    /// Returns `&str` slice.
+    /// Returns <code>&[str]</code> slice.
     ///
     /// # Panics
     ///
@@ -98,28 +105,48 @@ impl GStringBuilder {
     }
 
     // rustdoc-stripper-ignore-next
-    /// Returns `&str` slice.
+    /// Returns <code>&[GStr]</code> slice.
     ///
     /// # Panics
     ///
     /// If the string builder contains invalid UTF-8 this function panics.
-    #[must_use = "String returned from the builder should probably be used"]
-    pub fn into_string(self) -> crate::GString {
+    pub fn as_gstr(&self) -> &GStr {
         unsafe {
-            let s = mem::ManuallyDrop::new(self);
-            from_glib_full(ffi::g_string_free(
-                mut_override(s.to_glib_none().0),
-                ffi::GFALSE,
-            ))
+            let ptr: *const u8 = self.inner.str as _;
+            let len: usize = self.inner.len;
+            if len == 0 {
+                return Default::default();
+            }
+            let slice = slice::from_raw_parts(ptr, len + 1);
+            GStr::from_utf8_with_nul_checked(slice).unwrap()
         }
     }
+
+    // rustdoc-stripper-ignore-next
+    /// FInalizes the builder, converting it to a [`GString`].
+    ///
+    /// # Panics
+    ///
+    /// If the string builder contains invalid UTF-8 this function panics.
+    #[must_use = "String returned from the builder should probably be used"]
+    pub fn into_string(self) -> crate::GString {
+        let s = mem::ManuallyDrop::new(self);
+        let len = s.len();
+        unsafe { FromGlibContainer::from_glib_full_num(s.inner.str, len) }
+    }
 }
 
 impl Default for GStringBuilder {
     // rustdoc-stripper-ignore-next
     /// Creates a new empty string.
     fn default() -> Self {
-        unsafe { from_glib_full(ffi::g_string_new(ptr::null())) }
+        Self {
+            inner: ffi::GString {
+                str: ptr::null_mut(),
+                len: 0,
+                allocated_len: 0,
+            },
+        }
     }
 }
 
@@ -153,6 +180,18 @@ impl PartialEq<GStringBuilder> for str {
     }
 }
 
+impl PartialEq<GStr> for GStringBuilder {
+    fn eq(&self, other: &GStr) -> bool {
+        self.as_gstr() == other
+    }
+}
+
+impl PartialEq<GStringBuilder> for GStr {
+    fn eq(&self, other: &GStringBuilder) -> bool {
+        self == other.as_gstr()
+    }
+}
+
 impl Eq for GStringBuilder {}
 
 impl cmp::PartialOrd for GStringBuilder {
@@ -173,6 +212,18 @@ impl cmp::PartialOrd<GStringBuilder> for str {
     }
 }
 
+impl cmp::PartialOrd<GStr> for GStringBuilder {
+    fn partial_cmp(&self, other: &GStr) -> Option<cmp::Ordering> {
+        Some(self.as_gstr().cmp(other))
+    }
+}
+
+impl cmp::PartialOrd<GStringBuilder> for GStr {
+    fn partial_cmp(&self, other: &GStringBuilder) -> Option<cmp::Ordering> {
+        Some(self.cmp(other.as_gstr()))
+    }
+}
+
 impl cmp::Ord for GStringBuilder {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         self.as_str().cmp(other.as_str())
@@ -200,6 +251,12 @@ impl AsRef<str> for GStringBuilder {
     }
 }
 
+impl AsRef<GStr> for GStringBuilder {
+    fn as_ref(&self) -> &GStr {
+        self.as_gstr()
+    }
+}
+
 impl ops::Deref for GStringBuilder {
     type Target = str;