working on unix socket

gojo/bufio/bufio.mojo

@@ -618,32 +618,32 @@ struct Reader[R: io.Reader, size: Int = MIN_READ_BUFFER_SIZE](Sized, io.Reader,
 
     #     return bytes_written, Error()
 
-    # fn write_buf[W: io.Writer](inout self, inout writer: W) -> (Int, Error):
-    #     """Writes the [Reader]'s buffer to the writer.
+    fn write_buf[W: io.Writer](inout self, inout writer: W) -> (Int, Error):
+        """Writes the [Reader]'s buffer to the writer.
 
-    #     Args:
-    #         writer: The writer to write to.
+        Args:
+            writer: The writer to write to.
 
-    #     Returns:
-    #         The number of bytes written.
-    #     """
-    #     # Nothing to write
-    #     if self.read_pos == self.write_pos:
-    #         return Int(0), Error()
+        Returns:
+            The number of bytes written.
+        """
+        # Nothing to write
+        if self.read_pos == self.write_pos:
+            return Int(0), Error()
 
-    #     # Write the buffer to the writer, if we hit EOF it's fine. That's not a failure condition.
-    #     var bytes_written: Int
-    #     var err: Error
-    #     var buf_to_write = self.as_bytes_slice()[self.read_pos : self.write_pos]
-    #     bytes_written, err = writer.write(List[UInt8](buf_to_write))
-    #     if err:
-    #         return bytes_written, err
+        # Write the buffer to the writer, if we hit EOF it's fine. That's not a failure condition.
+        var bytes_written: Int
+        var err: Error
+        var buf_to_write = self.as_bytes_slice()[self.read_pos : self.write_pos]
+        bytes_written, err = writer.write(List[UInt8](buf_to_write))
+        if err:
+            return bytes_written, err
 
-    #     if bytes_written < 0:
-    #         panic(ERR_NEGATIVE_WRITE)
+        if bytes_written < 0:
+            panic(ERR_NEGATIVE_WRITE)
 
-    #     self.read_pos += bytes_written
-    #     return Int(bytes_written), Error()
+        self.read_pos += bytes_written
+        return Int(bytes_written), Error()
 
 
 fn new_reader[R: io.Reader, size: Int = MIN_READ_BUFFER_SIZE](owned reader: R) -> Reader[R, size]:

gojo/net/udp.mojo

@@ -63,7 +63,7 @@ struct UDPConnection(Movable):
         var err = Error()
         bytes_read, remote, err = self.socket.receive_from_into(dest)
         if err:
-            if str(err) != io.EOF:
+            if str(err) != str(io.EOF):
                 return bytes_read, remote, err
 
         return bytes_read, remote, err

gojo/net/unix.mojo

@@ -0,0 +1,35 @@
+@value
+struct UnixAddr(Addr):
+    """Represents the address of a Unix domain socket end point."""
+
+    var name: String
+    var net: String
+
+    fn network(self) -> String:
+        """Returns the network type."""
+        return self.net
+
+    fn __str__(self) -> String:
+        return self.name
+
+
+# TODO
+fn resolve_unix_addr(network: String, address: String) -> (UnixAddr, Error):
+    return UnixAddr(address, network), Error()
+
+
+# TODO
+struct UnixConnection(Movable):
+    """Connection to a Unix domain socket."""
+
+    var socket: Socket
+
+    fn __init__(inout self, owned socket: Socket):
+        self.socket = socket^
+
+    fn __moveinit__(inout self, owned existing: Self):
+        self.socket = existing.socket^
+
+    fn write(inout self, data: List[UInt8]) -> Error:
+        """Writes data to the connection."""
+        return self.socket.write(data)