add @buffer.write_bytesview and FixedArray::blit_from_bytesview API

buffer/buffer.mbt

@@ -558,6 +558,36 @@ pub fn write_bytes(self : T, value : Bytes) -> Unit {
   self.len += val_len
 }
 
+///|
+/// Writes a sequence of bytes from a BytesView into the buffer.
+///
+/// Parameters:
+///
+/// * `buffer` : The buffer to write to.
+/// * `value` : The BytesView containing the bytes to write.
+///
+/// Example:
+///
+/// ```moonbit
+/// test "write_bytesview" {
+///   let buf = @buffer.new()
+///   let view = b"Test"[1:3]
+///   buf.write_bytesview(view)
+///   inspect!(
+///     buf.contents(),
+///     content=
+///       #|b"\x65\x73"
+///     ,
+///   )
+/// }
+/// ```
+pub fn write_bytesview(self : T, value : BytesView) -> Unit {
+  let val_len = value.length()
+  self.grow_if_necessary(self.len + val_len)
+  self.data.blit_from_bytesview(self.len, value)
+  self.len += val_len
+}
+
 ///|
 /// Writes a portion of a string into the buffer in UTF-16LE encoding.
 ///

buffer/buffer.mbti

@@ -16,6 +16,7 @@ impl T {
   to_unchecked_string(Self) -> String //deprecated
   write_byte(Self, Byte) -> Unit
   write_bytes(Self, Bytes) -> Unit
+  write_bytesview(Self, BytesView) -> Unit
   write_char(Self, Char) -> Unit
   write_double_be(Self, Double) -> Unit
   write_double_le(Self, Double) -> Unit

buffer/buffer_test.mbt

@@ -310,3 +310,14 @@ test "write_iter" {
     ,
   )
 }
+
+test "write_bytesview" {
+  let buf = @buffer.new(size_hint=4)
+  buf.write_bytesview(b"Test"[1:3])
+  inspect!(
+    buf.contents(),
+    content=
+      #|b"\x65\x73"
+    ,
+  )
+}

builtin/builtin.mbti

@@ -694,6 +694,7 @@ impl Result {
 
 impl FixedArray {
   blit_from_bytes(Self[Byte], Int, Bytes, Int, Int) -> Unit
+  blit_from_bytesview(Self[Byte], Int, BytesView) -> Unit
   blit_from_string(Self[Byte], Int, String, Int, Int) -> Unit
   blit_to[A](Self[A], Self[A], len~ : Int, src_offset~ : Int = .., dst_offset~ : Int = ..) -> Unit
   compare[T : Compare](Self[T], Self[T]) -> Int

builtin/bytes.mbt

@@ -221,6 +221,39 @@ pub fn FixedArray::blit_from_bytes(
   }
 }
 
+///|
+/// Copy bytes from a BytesView into a fixed array of bytes.
+///
+/// Parameters:
+///
+/// * `self` : The destination fixed array of bytes.
+/// * `bytes_offset` : The starting position in the destination array where bytes will be copied.
+/// * `src` : The source BytesView to copy from.
+///
+/// Throws a panic if:
+/// * `bytes_offset` is negative
+/// * The destination array is too small to hold all bytes from the source BytesView
+///
+/// Example:
+///
+/// ```moonbit
+///  let arr = FixedArray::make(4, b'\x00')
+///  let view = b"\x01\x02\x03"[1:]
+///  arr.blit_from_bytesview(1, view)
+///  inspect!(arr, content="[b'\\x00', b'\\x02', b'\\x03', b'\\x00']")
+/// ```
+pub fn FixedArray::blit_from_bytesview(
+  self : FixedArray[Byte],
+  bytes_offset : Int,
+  src : BytesView
+) -> Unit {
+  let src_len = src.length()
+  guard bytes_offset >= 0 && bytes_offset + src_len - 1 < self.length()
+  for i = 0, j = bytes_offset; i < src_len; i = i + 1, j = j + 1 {
+    self[j] = src[i]
+  }
+}
+
 ///|
 /// Creates a new byte sequence by copying all bytes from the input sequence.
 ///

bytes/bytes_test.mbt

@@ -147,3 +147,22 @@ test "Bytes::from_iter with multiple elements" {
   let bytes = Bytes::from_iter(iter)
   inspect!(bytes, content="b\"\\x61\\x62\\x63\"")
 }
+
+test "Fixed::blit_from_bytesview" {
+  let arr = FixedArray::make(4, b'\x00')
+  let view = b"\x01\x02\x03"[1:]
+  arr.blit_from_bytesview(1, view)
+  inspect!(arr, content="[b'\\x00', b'\\x02', b'\\x03', b'\\x00']")
+}
+
+test "panic Fixed::blit_from_bytesview 1" {
+  let arr = FixedArray::make(2, b'\x00')
+  let view = b"\x01\x02\x03"[1:]
+  ignore(arr.blit_from_bytesview(1, view))
+}
+
+test "panic Fixed::blit_from_bytesview 2" {
+  let arr = FixedArray::make(2, b'\x00')
+  let view = b"\x01\x02\x03"[1:]
+  ignore(arr.blit_from_bytesview(-1, view))
+}