Merge pull request #857 from sdroege/gstringbuilder-improvements

glib: Minor `GStringBuilder` improvements

Author: sdroege

glib/src/gstring.rs

@@ -440,6 +440,21 @@ impl GString {
     pub unsafe fn from_ptr_lossy<'a>(ptr: *const c_char) -> Cow<'a, GStr> {
         GStr::from_ptr_lossy(ptr)
     }
+
+    // rustdoc-stripper-ignore-next
+    /// Wraps a raw C string with a safe GLib string wrapper. The provided C string **must** be
+    /// nul-terminated. All constraints from [`std::ffi::CStr::from_ptr`] also apply here.
+    ///
+    /// `len` is the length without the nul-terminator, i.e. if `len == 0` is passed then `*ptr`
+    /// must be the nul-terminator.
+    pub unsafe fn from_ptr_and_len_unchecked(ptr: *const c_char, len: usize) -> Self {
+        assert!(!ptr.is_null());
+
+        GString(Inner::Foreign {
+            ptr: ptr::NonNull::new_unchecked(ptr as *mut _),
+            len,
+        })
+    }
 }
 
 impl IntoGlibPtr<*mut c_char> for GString {

glib/src/gstring_builder.rs

@@ -21,20 +21,25 @@ wrapper! {
         copy => |ptr| ffi::g_string_new((*ptr).str),
         free => |ptr| ffi::g_string_free(ptr, ffi::GTRUE),
         init => |ptr| unsafe {
-            *ptr = ffi::GString {
-                str: ffi::g_malloc0(64) as *mut _,
+            let inner = ffi::GString {
+                str: ffi::g_malloc(64) as *mut _,
                 len: 0,
                 allocated_len: 64,
             };
+            ptr::write(inner.str, 0);
+
+            *ptr = inner;
         },
         copy_into => |dest, src| {
+            assert!((*src).allocated_len > (*src).len);
             let allocated_len = (*src).allocated_len;
-            let mut inner = ffi::GString {
-                str: ffi::g_malloc0(allocated_len) as *mut _,
+            let inner = ffi::GString {
+                str: ffi::g_malloc(allocated_len) as *mut _,
                 len: 0,
                 allocated_len,
             };
-            ffi::g_string_append_len(&mut inner, (*src).str, (*src).len as isize);
+            // +1 to also copy the NUL-terminator
+            ptr::copy_nonoverlapping((*src).str, inner.str, (*src).len + 1);
             *dest = inner;
         },
         clear => |ptr| {
@@ -56,19 +61,16 @@ impl GStringBuilder {
             let allocated_len = usize::next_power_of_two(std::cmp::max(data.len(), 64) + 1);
             assert_ne!(allocated_len, 0);
 
-            let mut inner = ffi::GString {
+            let inner = ffi::GString {
                 str: ffi::g_malloc(allocated_len) as *mut _,
-                len: 0,
+                len: data.len(),
                 allocated_len,
             };
             if data.is_empty() {
                 ptr::write(inner.str, 0);
             } else {
-                ffi::g_string_append_len(
-                    &mut inner,
-                    data.as_ptr() as *const _,
-                    data.len() as isize,
-                );
+                ptr::copy_nonoverlapping(data.as_ptr() as *const _, inner.str, data.len());
+                ptr::write(inner.str.add(data.len()), 0);
             }
             Self { inner }
         }
@@ -116,10 +118,6 @@ impl GStringBuilder {
 
     // rustdoc-stripper-ignore-next
     /// Returns `&str` slice.
-    ///
-    /// # Panics
-    ///
-    /// If the string builder contains invalid UTF-8 this function panics.
     pub fn as_str(&self) -> &str {
         unsafe {
             let ptr: *const u8 = self.inner.str as _;
@@ -128,21 +126,17 @@ impl GStringBuilder {
                 return "";
             }
             let slice = slice::from_raw_parts(ptr, len);
-            std::str::from_utf8(slice).unwrap()
+            std::str::from_utf8_unchecked(slice)
         }
     }
 
     // rustdoc-stripper-ignore-next
     /// Returns `&str` 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 {
         unsafe {
             let s = mem::ManuallyDrop::new(self);
-            crate::GString::from_glib_full_num(s.inner.str, s.inner.len)
+            crate::GString::from_ptr_and_len_unchecked(s.inner.str, s.inner.len)
         }
     }
 }
@@ -257,6 +251,7 @@ mod tests {
     #[test]
     fn append() {
         let mut s = crate::GStringBuilder::new("");
+        assert_eq!(&*s, "");
         s.append("Hello");
         s.append(" ");
         s.append("there!");
@@ -267,6 +262,7 @@ mod tests {
     #[test]
     fn prepend() {
         let mut s = crate::GStringBuilder::new("456");
+        assert_eq!(&*s, "456");
         s.prepend("123");
         assert_eq!(&*s, "123456");
     }