Use separate methods for Poll read, write and readWrite (#34)

* Use separate methods for Poll read, write and readWrite

* Reintroduce start with dynamic in and out

* Bump utest to 0.7.5

* Add PollTests

Author: lolgab

build.sbt

@@ -44,7 +44,7 @@ lazy val commonSettings = Seq(
     "-Ywarn-unused-import"
   ),
   Compile / doc / scalacOptions -= "-Xfatal-warnings",
-  libraryDependencies += "com.lihaoyi" %%% "utest" % "0.7.4" % Test,
+  libraryDependencies += "com.lihaoyi" %%% "utest" % "0.7.5" % Test,
   testFrameworks += new TestFramework("utest.runner.Framework"),
   Test / nativeLinkStubs := true,
   publish / skip := true,

client/curl.scala

@@ -178,20 +178,20 @@ object Curl {
         new Poll(socket_data)
       }
 
-      val readable = action == POLL_IN || action == POLL_INOUT
-      val writable = action == POLL_OUT || action == POLL_INOUT
+      val in = action == POLL_IN || action == POLL_INOUT
+      val out = action == POLL_OUT || action == POLL_INOUT
 
-      if (readable || writable) {
+      if (in || out) {
         println(
-          s"starting poll with readable = $readable and writable = $writable"
+          s"starting poll with in = $in and out = $out"
         )
-        pollHandle.start(readable, writable) { (status, readable, writable) =>
+        pollHandle.start(in, out) { res =>
           println(
-            s"ready_for_curl fired with status $status and readable = $readable writable = $writable"
+            s"ready_for_curl fired with status ${res.result} and readable = ${res.readable} writable = ${res.writable}"
           )
           var actions = 0
-          if (readable) actions |= 1
-          if (writable) actions |= 2
+          if (res.readable) actions |= 1
+          if (res.writable) actions |= 2
           val running_handles = stackalloc[Int]
           val result =
             multi_socket_action(multi, socket, actions, running_handles)

core/src/main/scala/scala/scalanative/loop/Poll.scala

@@ -5,15 +5,29 @@ import LibUV._, LibUVConstants._
 import scala.scalanative.unsafe.Ptr
 import internals.HandleUtils
 
+class RWResult(val result: Int, val readable: Boolean, val writable: Boolean)
 @inline class Poll(val ptr: Ptr[Byte]) extends AnyVal {
-  def start(in: Boolean, out: Boolean)(
-      callback: (Int, Boolean, Boolean) => Unit
-  ): Unit = {
+  def start(in: Boolean, out: Boolean)(callback: RWResult => Unit): Unit = {
     HandleUtils.setData(ptr, callback)
     var events = 0
     if (out) events |= UV_WRITABLE
     if (in) events |= UV_READABLE
-    uv_poll_start(ptr, events, Poll.pollCB)
+    uv_poll_start(ptr, events, Poll.pollReadWriteCB)
+  }
+
+  def startReadWrite(callback: RWResult => Unit): Unit = {
+    HandleUtils.setData(ptr, callback)
+    uv_poll_start(ptr, UV_READABLE | UV_WRITABLE, Poll.pollReadWriteCB)
+  }
+
+  def startRead(callback: Int => Unit): Unit = {
+    HandleUtils.setData(ptr, callback)
+    uv_poll_start(ptr, UV_READABLE, Poll.pollReadCB)
+  }
+
+  def startWrite(callback: Int => Unit): Unit = {
+    HandleUtils.setData(ptr, callback)
+    uv_poll_start(ptr, UV_WRITABLE, Poll.pollWriteCB)
   }
 
   def stop(): Unit = {
@@ -23,17 +37,31 @@ import internals.HandleUtils
 }
 
 object Poll {
-  private val pollCB = new PollCB {
+  private val pollReadWriteCB = new PollCB {
     def apply(handle: PollHandle, status: Int, events: Int): Unit = {
       val callback =
-        HandleUtils.getData[(Int, Boolean, Boolean) => Unit](handle)
+        HandleUtils.getData[RWResult => Unit](handle)
       callback.apply(
-        status,
-        (events & UV_READABLE) != 0,
-        (events & UV_WRITABLE) != 0
+        new RWResult(
+          result = status,
+          readable = (events & UV_READABLE) != 0,
+          writable = (events & UV_WRITABLE) != 0
+        )
       )
     }
   }
+  private val pollReadCB = new PollCB {
+    def apply(handle: PollHandle, status: Int, events: Int): Unit = {
+      val callback = HandleUtils.getData[Int => Unit](handle)
+      if ((events & UV_READABLE) != 0) callback.apply(status)
+    }
+  }
+  private val pollWriteCB = new PollCB {
+    def apply(handle: PollHandle, status: Int, events: Int): Unit = {
+      val callback = HandleUtils.getData[Int => Unit](handle)
+      if ((events & UV_WRITABLE) != 0) callback.apply(status)
+    }
+  }
 
   private lazy val size = uv_handle_size(UV_POLL_T)
 

core/src/test/scala/scala/scalanative/loop/PollTests.scala

@@ -0,0 +1,48 @@
+package scala.scalanative.loop
+
+import utest._
+import scala.scalanative.unsafe._
+import scala.scalanative.posix.unistd._
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.{Future, Promise}
+
+object PollTests extends LoopTestSuite {
+  def usingPipe(f: (Int, Int) => Future[Unit]): Future[Unit] = {
+    val fildes = stackalloc[CInt](2)
+    if (pipe(fildes) != 0) {
+      throw new Exception("Failed to create pipe")
+    }
+    val future = f(fildes(0), fildes(1))
+    future.onComplete { _ =>
+      close(fildes(0))
+      close(fildes(1))
+    }
+    future
+  }
+
+  val tests = Tests {
+    test("startRead") {
+      usingPipe { (r, w) =>
+        val promise = Promise[Unit]()
+        val byte    = 10.toByte
+        val poll    = Poll(r)
+        poll.startRead { i =>
+          if (i != 0) {
+            throw new Exception("Poll result != 0")
+          }
+          val buf       = stackalloc[Byte]
+          val bytesRead = read(r, buf, 1)
+          assert(bytesRead == 1)
+          assert(buf(0) == byte)
+          promise.success(())
+          poll.stop()
+        }
+        val buf = stackalloc[Byte]
+        buf(0) = byte
+        val bytesWrote = write(w, buf, 1)
+        assert(bytesWrote == 1)
+        promise.future
+      }
+    }
+  }
+}