Regarding Issue 380: Added writebuffer.pony in net package;

Updated test.pony in net for the same

CHANGELOG.md

@@ -49,6 +49,7 @@ All notable changes to the Pony compiler and standard library will be documented
 - Logger package
 - `ArrayValues.rewind()` method.
 - Nanos primitive in time package.
+- An initial implementation of WriteBuffer inside the net package
 
 ### Changed
 

packages/net/test.pony

@@ -6,8 +6,63 @@ actor Main is TestList
 
   fun tag tests(test: PonyTest) =>
     test(_TestBuffer)
+    test(_TestWriteBuffer)
     test(_TestBroadcast)
 
+class iso _TestWriteBuffer is UnitTest
+  """
+  Test adding to the WriteBuffer and reading from Buffer
+  """
+  fun name(): String => "net/WriteBuffer"
+
+  fun apply(h: TestHelper) ? =>
+    let bsize: USize = 1024
+    let test_val1: I64 = 0xEAD_BEEF_FEED_FACE
+    let test_val2: U64 = 0xDEADBEEFFEEDFACE
+    // Calling write_number with I64/U64 should test all cases(?!)
+    let x_be = recover val
+      let wb = WriteBuffer(bsize)
+      try
+        h.assert_eq[USize](wb.available(), bsize)
+        wb.write_number(test_val1)
+        // Using 8 here for the lack of a better way to get the size of an I64!
+        h.assert_eq[USize](wb.available(), bsize-8)
+        wb.write_number(test_val2)
+        h.assert_eq[USize](wb.available(), bsize-(8*2))
+      else
+        error
+      end
+
+      let data: Array[U8] iso = recover Array[U8].undefined(0) end
+      wb.get_data(consume data)
+    end
+
+    let x_le = recover val
+      let wb = WriteBuffer(bsize, true)
+      try
+        h.assert_eq[USize](wb.available(), bsize)
+        wb.write_number(test_val1)
+        h.assert_eq[USize](wb.available(), bsize-8)
+        wb.write_number(test_val2)
+        h.assert_eq[USize](wb.available(), bsize-(8*2))
+      else
+        error
+      end
+
+      let data: Array[U8] iso = recover Array[U8].undefined(0) end
+      wb.get_data(consume data)
+    end
+
+    let b = Buffer
+    b.append(x_be)
+    b.append(x_le)
+
+    h.assert_eq[I64](b.i64_be(), test_val1)
+    h.assert_eq[U64](b.u64_be(), test_val2)
+    b.skip(bsize-(8*2))
+    h.assert_eq[I64](b.i64_le(), test_val1)
+    h.assert_eq[U64](b.u64_le(), test_val2)
+
 class iso _TestBuffer is UnitTest
   """
   Test adding to and reading from a Buffer.

packages/net/writebuffer.pony

@@ -0,0 +1,69 @@
+use "collections"
+
+class WriteBuffer
+  """
+  A simple constant sized byte buffer to push Numbers into.
+  The data container is iso in order to keep it sendable(?)
+  Potential upgrades:
+  1. Have a list of data buffers of preset size
+  2. Arguably, seperate functions for _be and _le
+  3. A better way to get data out of the buffer, without passing a new array?
+  """
+  var data: Array[U8] iso
+  var _offset: USize
+  var _little_endian: Bool
+
+  new create(size: USize, little_endian: Bool = false) =>
+    """
+    Allocate the buffer
+    """
+    data = recover Array[U8].undefined(size) end
+    _offset = 0
+    _little_endian = little_endian
+
+  fun ref get_data(x: Array[U8] iso): Array[U8] iso^ =>
+    """
+    Destructive read inorder to get an iso reference to data
+    """
+    var x': Array[U8] iso = data = consume x
+    consume x'
+
+  fun ref available(): USize =>
+    """
+    Number of bytes currently available
+    """
+    data.size() - _offset
+
+  fun ref _byte(value: U8) : WriteBuffer^ ? =>
+    """
+    Write a single byte into the buffer if space available else error
+    Update _offset
+    """
+    if _offset < data.size() then
+      data(_offset) = value
+      _offset = _offset + 1
+    else error end
+    this
+
+  fun ref write_number(value: Number): WriteBuffer? =>
+    """
+    Write the number to buffer based on endianness
+    """
+    match (value, _little_endian)
+    | (let v: U8, _) => _byte(v)
+    | (let v: I8, _) => _byte(v.u8())
+    | (let v: U16, false) => _byte((v>>8).u8()); _byte(v.u8())
+    | (let v: I16, false) => _byte((v>>8).u8()); _byte(v.u8())
+    | (let v: U32, false) => write_number((v>>16).u16()); write_number(v.u16())
+    | (let v: I32, false) => write_number((v>>16).u16()); write_number(v.u16())
+    | (let v: U64, false) => write_number((v>>32).u32()); write_number(v.u32())
+    | (let v: I64, false) => write_number((v>>32).u32()); write_number(v.u32())
+    | (let v: U16, true) => _byte(v.u8()); _byte((v>>8).u8())
+    | (let v: I16, true) => _byte(v.u8()); _byte((v>>8).u8())
+    | (let v: U32, true) => write_number(v.u16()); write_number((v>>16).u16())
+    | (let v: I32, true) => write_number(v.u16()); write_number((v>>16).u16())
+    | (let v: U64, true) => write_number(v.u32()); write_number((v>>32).u32())
+    | (let v: I64, true) => write_number(v.u32()); write_number((v>>32).u32())
+    else
+      error
+    end