Add C-string version of the write_to

Author: berkus

vesper/src/write_to.rs

@@ -19,11 +19,19 @@ impl<'a> WriteTo<'a> {
         WriteTo { buffer, used: 0 }
     }
 
-    pub fn as_str(self) -> Option<&'a str> {
+    pub fn into_str(self) -> Option<&'a str> {
         if self.used <= self.buffer.len() {
             // only successful concats of str - must be a valid str.
-            use core::str::from_utf8_unchecked;
-            Some(unsafe { from_utf8_unchecked(&self.buffer[..self.used]) })
+            Some(unsafe { core::str::from_utf8_unchecked(&self.buffer[..self.used]) })
+        } else {
+            None
+        }
+    }
+
+    pub fn into_cstr(self) -> Option<&'a str> {
+        if self.used < self.buffer.len() {
+            self.buffer[self.used] = 0; // Terminate the string
+            Some(unsafe { core::str::from_utf8_unchecked(&self.buffer[..=self.used]) })
         } else {
             None
         }
@@ -48,24 +56,46 @@ impl<'a> fmt::Write for WriteTo<'a> {
     }
 }
 
+#[inline]
 pub fn show<'a>(buffer: &'a mut [u8], args: fmt::Arguments) -> Result<&'a str, fmt::Error> {
     let mut w = WriteTo::new(buffer);
     fmt::write(&mut w, args)?;
-    w.as_str().ok_or(fmt::Error)
+    w.into_str().ok_or(fmt::Error)
+}
+
+// Return a zero-terminated str
+#[inline] // Crazy bug - result of this call disappears if it's not inlined
+pub fn c_show<'a>(buffer: &'a mut [u8], args: fmt::Arguments) -> Result<&'a str, fmt::Error> {
+    let mut w = WriteTo::new(buffer);
+    fmt::write(&mut w, args)?;
+    w.into_cstr().ok_or(fmt::Error)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test_case]
-    pub fn write_to_functions() {
+    pub fn write_to_works() {
         let mut buf = [0u8; 64];
         let s: &str = show(
             &mut buf,
             format_args!("write some stuff {:?}: {}", "foo", 42),
         )
         .unwrap();
         assert_eq!(s, "write some stuff \"foo\": 42");
+        assert_eq!(s.as_ptr(), buf.as_ptr());
+    }
+
+    #[test_case]
+    pub fn zero_terminated_write_to_works() {
+        let mut buf = [0u8; 64];
+        let s: &str = c_show(
+            &mut buf,
+            format_args!("write some stuff {:?}: {}", "foo", 42),
+        )
+        .unwrap();
+        assert_eq!(s, "write some stuff \"foo\": 42\0");
+        assert_eq!(s.as_ptr(), buf.as_ptr());
     }
 }