wip refactoring structs to use span for read trait. Scanner still needs some work

Author: thatstoasty

CHANGELOG.md

@@ -1,12 +1,23 @@
-
 # Change Log
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased] - yyyy-mm-dd
 
+## [0.0.2] - 2024-06-19
+
+### Added
+
+- UDP support in `net` package.
+- `examples` package with `tcp` and `udp` examples using `Socket` and their respective `dial` and `listen` functions.
+
+### Removed
+
+- `Listener`, `Dialer`, and `Conn` interfaces have been removed until Trait support improves. For now, call `listen_tcp/listen_udp` and `dial_tcp/dial_udp` functions directly.
+
 ## [0.0.1] - 2024-06-16
 
 ### Changed

examples/udp/listener_server.mojo

@@ -2,7 +2,7 @@ from gojo.net import UDPAddr, get_ip_address, listen_udp, HostPort
 import gojo.io
 
 
-fn udp_listener() raises:
+fn main() raises:
     var listener = listen_udp("udp", UDPAddr("127.0.0.1", 12000))
 
     while True:
@@ -21,7 +21,3 @@ fn udp_listener() raises:
         var bytes_sent: Int
         bytes_sent, err = listener.write_to(message.as_bytes(), UDPAddr(remote.host, remote.port))
         print("Message sent:", message)
-
-
-fn main() raises:
-    udp_listener()

examples/udp/socket_server.mojo

@@ -3,7 +3,7 @@ from gojo.syscall import SocketType
 import gojo.io
 
 
-fn udp_server() raises:
+fn main() raises:
     var socket = Socket(socket_type=SocketType.SOCK_DGRAM)
     alias host = "127.0.0.1"
     alias port = 12000
@@ -26,7 +26,3 @@ fn udp_server() raises:
         var bytes_sent: Int
         bytes_sent, err = socket.send_to(message.as_bytes(), remote.host, remote.port)
         print("Message sent:", message)
-
-
-fn main() raises:
-    udp_server()

gojo/bufio/bufio.mojo

@@ -108,11 +108,8 @@ struct Reader[R: io.Reader](Sized, io.Reader, io.ByteReader, io.ByteScanner):
         if self.read_pos > 0:
             var data_to_slide = self.as_bytes_slice()[self.read_pos : self.write_pos]
             # TODO: Temp copying of elements until I figure out a better pattern or slice refs are added
-            for i in range(len(self.buf)):
-                if i > len(self.buf):
-                    self.buf[i] = data_to_slide[i]
-                else:
-                    self.buf.append(data_to_slide[i])
+            for i in range(len(data_to_slide)):
+                self.buf[i] = data_to_slide[i]
 
             # self.buf.reserve(current_capacity)
             self.write_pos -= self.read_pos
@@ -126,20 +123,22 @@ struct Reader[R: io.Reader](Sized, io.Reader, io.ByteReader, io.ByteScanner):
         # Read new data: try a limited number of times.
         var i: Int = MAX_CONSECUTIVE_EMPTY_READS
         while i > 0:
-            # TODO: Using temp until slicing can return a Reference
-            var temp = List[UInt8](capacity=io.BUFFER_SIZE)
+            # TODO: Using temp until slicing can return a Reference, does reading directly into a Span of self.buf work?
+            # Maybe we need to read into the end of the buffer.
+            var span = self.as_bytes_slice()
             var bytes_read: Int
             var err: Error
-            bytes_read, err = self.reader.read(temp)
+            bytes_read, err = self.reader.read(span)
+            print("bytes read, bufio reader", bytes_read)
             if bytes_read < 0:
                 panic(ERR_NEGATIVE_READ)
 
-            # TODO: Temp copying of elements until I figure out a better pattern or slice refs are added
-            for i in range(len(temp)):
-                if i + self.write_pos > len(temp):
-                    self.buf[i + self.write_pos] = temp[i]
-                else:
-                    self.buf.append(temp[i])
+            # # TODO: Temp copying of elements until I figure out a better pattern or slice refs are added
+            # for i in range(len(temp)):
+            #     if i + self.write_pos > len(temp):
+            #         self.buf[i + self.write_pos] = temp[i]
+            #     else:
+            #         self.buf.append(temp[i])
             self.write_pos += bytes_read
 
             if err:
@@ -230,44 +229,47 @@ struct Reader[R: io.Reader](Sized, io.Reader, io.ByteReader, io.ByteScanner):
             if remain == 0:
                 return number_of_bytes, Error()
 
-    fn read(inout self, inout dest: List[UInt8]) -> (Int, Error):
+    fn read(inout self, inout dest: Span[UInt8, True]) -> (Int, Error):
         """Reads data into dest.
         It returns the number of bytes read into dest.
         The bytes are taken from at most one Read on the underlying [Reader],
         hence n may be less than len(src).
         To read exactly len(src) bytes, use io.ReadFull(b, src).
         If the underlying [Reader] can return a non-zero count with io.EOF,
         then this Read method can do so as well; see the [io.Reader] docs."""
-        var space_available = dest.capacity - len(dest)
-        if space_available == 0:
-            if self.buffered() > 0:
-                return 0, Error()
-            return 0, self.read_error()
+        # TODO: How do we check the capacity of a Span? Or UnsafePointer?
+        # var space_available = dest.capacity - len(dest)
+        # if space_available == 0:
+        #     if self.buffered() > 0:
+        #         return 0, Error()
+        #     return 0, self.read_error()
 
         var bytes_read: Int = 0
         if self.read_pos == self.write_pos:
-            if space_available >= len(self.buf):
-                # Large read, empty buffer.
-                # Read directly into dest to avoid copy.
-                var bytes_read: Int
-                var err: Error
-                bytes_read, err = self.reader.read(dest)
+            # TODO: How do we check the capacity of a Span? Or UnsafePointer? For now just assume the buffer DOES have enough space.
+            # if space_available >= len(self.buf):
+            # Large read, empty buffer.
+            # Read directly into dest to avoid copy.
+            # var bytes_read: Int
+            # var err: Error
+            # bytes_read, err = self.reader.read(dest)
+            # print("bufio reader", bytes_read, err)
 
-                self.err = err
-                if bytes_read < 0:
-                    panic(ERR_NEGATIVE_READ)
+            # self.err = err
+            # if bytes_read < 0:
+            #     panic(ERR_NEGATIVE_READ)
 
-                if bytes_read > 0:
-                    self.last_byte = int(dest[bytes_read - 1])
-                    self.last_rune_size = -1
+            # if bytes_read > 0:
+            #     self.last_byte = int(dest[bytes_read - 1])
+            #     self.last_rune_size = -1
 
-                return bytes_read, self.read_error()
+            # return bytes_read, self.read_error()
 
             # One read.
             # Do not use self.fill, which will loop.
             self.read_pos = 0
             self.write_pos = 0
-            var buf = List[UInt8](self.as_bytes_slice())  # TODO: I'm hoping this reads into self.data directly lol
+            var buf = self.as_bytes_slice()  # TODO: I'm hoping this reads into self.data directly lol
             var bytes_read: Int
             var err: Error
             bytes_read, err = self.reader.read(buf)
@@ -281,11 +283,17 @@ struct Reader[R: io.Reader](Sized, io.Reader, io.ByteReader, io.ByteScanner):
             self.write_pos += bytes_read
 
         # copy as much as we can
-        # Note: if the slice panics here, it is probably because
-        # the underlying reader returned a bad count. See issue 49795.
-        bytes_read = copy(dest, self.as_bytes_slice()[self.read_pos : self.write_pos])
+        var source = self.as_bytes_slice()[self.read_pos : self.write_pos]
+        bytes_read = 0
+        var start = len(dest)
+
+        for i in range(len(source)):
+            dest[i + start] = source[i]
+            bytes_read += 1
+
+        dest._len += bytes_read
         self.read_pos += bytes_read
-        self.last_byte = int(self.as_bytes_slice()[self.read_pos - 1])
+        self.last_byte = int(self.buf[self.read_pos - 1])
         self.last_rune_size = -1
         return bytes_read, Error()
 
@@ -931,18 +939,17 @@ struct Writer[W: io.Writer, size: Int = io.BUFFER_SIZE](
             while nr < MAX_CONSECUTIVE_EMPTY_READS:
                 # TODO: should really be using a slice that returns refs and not a copy.
                 # Read into remaining unused space in the buffer. We need to reserve capacity for the slice otherwise read will never hit EOF.
-                var sl = List[UInt8](self.as_bytes_slice()[self.bytes_written : len(self.buf)])
-                sl.reserve(self.buf.capacity)
-                bytes_read, err = reader.read(sl)
-                if bytes_read > 0:
-                    # TODO: Temp copying of elements until I figure out a better pattern or slice refs are added
-                    var bytes_read = 0
-                    for i in range(len(sl)):
-                        if i + self.bytes_written > len(sl):
-                            self.buf[i + self.bytes_written] = sl[i]
-                        else:
-                            self.buf.append(sl[i])
-                        bytes_read += 1
+                var buf = self.as_bytes_slice()[self.bytes_written : len(self.buf)]
+                bytes_read, err = reader.read(buf)
+                # if bytes_read > 0:
+                #     # TODO: Temp copying of elements until I figure out a better pattern or slice refs are added
+                #     var bytes_read = 0
+                #     for i in range(len(sl)):
+                #         if i + self.bytes_written > len(sl):
+                #             self.buf[i + self.bytes_written] = sl[i]
+                #         else:
+                #             self.buf.append(sl[i])
+                #         bytes_read += 1
 
                 if bytes_read != 0 or err:
                     break