writer::num

Author: ijl

src/serialize/writer/formatter.rs

@@ -1,7 +1,11 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright ijl (2022-2025)
+// Copyright ijl (2022-2026)
 // This is an adaptation of `src/value/ser.rs` from serde-json.
 
+use super::{
+    write_float32, write_float64, write_integer_i32, write_integer_i64, write_integer_u32,
+    write_integer_u64,
+};
 use crate::serialize::writer::WriteExt;
 use std::io;
 
@@ -43,8 +47,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = itoap::write_to_ptr(writer.as_mut_buffer_ptr(), value);
-            writer.advance_mut(len);
+            write_integer_i32(writer, value);
         }
         Ok(())
     }
@@ -56,8 +59,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = itoap::write_to_ptr(writer.as_mut_buffer_ptr(), value);
-            writer.advance_mut(len);
+            write_integer_i64(writer, value);
         }
         Ok(())
     }
@@ -69,8 +71,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = itoap::write_to_ptr(writer.as_mut_buffer_ptr(), value);
-            writer.advance_mut(len);
+            write_integer_u32(writer, value);
         }
         Ok(())
     }
@@ -82,8 +83,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = itoap::write_to_ptr(writer.as_mut_buffer_ptr(), value);
-            writer.advance_mut(len);
+            write_integer_u64(writer, value);
         }
         Ok(())
     }
@@ -95,8 +95,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = ryu::raw::format32(value, writer.as_mut_buffer_ptr());
-            writer.advance_mut(len);
+            write_float32(writer, value);
         }
         Ok(())
     }
@@ -108,8 +107,7 @@ pub(crate) trait Formatter {
     {
         unsafe {
             reserve_minimum!(writer);
-            let len = ryu::raw::format64(value, writer.as_mut_buffer_ptr());
-            writer.advance_mut(len);
+            write_float64(writer, value);
         }
         Ok(())
     }

src/serialize/writer/mod.rs

@@ -1,10 +1,15 @@
 // SPDX-License-Identifier: MPL-2.0
-// Copyright ijl (2024-2025)
+// Copyright ijl (2024-2026)
 
 mod byteswriter;
 mod formatter;
 mod json;
+mod num;
 mod str;
 
 pub(crate) use byteswriter::{BytesWriter, WriteExt};
 pub(crate) use json::{set_str_formatter_fn, to_writer, to_writer_pretty};
+pub(crate) use num::{
+    write_float32, write_float64, write_integer_i32, write_integer_i64, write_integer_u32,
+    write_integer_u64,
+};

src/serialize/writer/num.rs

@@ -0,0 +1,83 @@
+// SPDX-License-Identifier: MPL-2.0
+// Copyright ijl (2026)
+
+use crate::serialize::writer::WriteExt;
+use bytes::BufMut;
+
+#[inline]
+pub(crate) fn write_integer_u32<B>(buf: &mut B, val: u32)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    write_integer(buf, val)
+}
+
+#[inline]
+pub(crate) fn write_integer_i32<B>(buf: &mut B, val: i32)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    write_integer(buf, val)
+}
+
+#[inline]
+pub(crate) fn write_integer_u64<B>(buf: &mut B, val: u64)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    write_integer(buf, val)
+}
+
+#[inline]
+pub(crate) fn write_integer_i64<B>(buf: &mut B, val: i64)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    write_integer(buf, val)
+}
+
+#[inline]
+fn write_integer<B, V: itoap::Integer>(buf: &mut B, val: V)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    unsafe {
+        debug_assert!(buf.remaining_mut() >= 20);
+        let len = itoap::write_to_ptr(buf.as_mut_buffer_ptr(), val);
+        buf.advance_mut(len);
+    }
+}
+
+#[inline]
+pub(crate) fn write_float32<B>(buf: &mut B, val: f32)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    if val.is_infinite() || val.is_nan() {
+        cold_path!();
+        buf.put_slice(b"null");
+    } else {
+        unsafe {
+            debug_assert!(buf.remaining_mut() >= 40);
+            let len = ryu::raw::format32(val, buf.as_mut_buffer_ptr());
+            buf.advance_mut(len);
+        }
+    }
+}
+
+#[inline]
+pub(crate) fn write_float64<B>(buf: &mut B, val: f64)
+where
+    B: ?Sized + WriteExt + BufMut,
+{
+    if val.is_infinite() || val.is_nan() {
+        cold_path!();
+        buf.put_slice(b"null");
+    } else {
+        unsafe {
+            debug_assert!(buf.remaining_mut() >= 40);
+            let len = ryu::raw::format64(val, buf.as_mut_buffer_ptr());
+            buf.advance_mut(len);
+        }
+    }
+}