Refactor futures layout

Author: mqxf

src/main/java/dev/mv/utilsx/async/MVSync.java

@@ -0,0 +1,7 @@
+package dev.mv.utilsx.async;
+
+public class MVSync {
+
+    //blanket class, implement async runtime in here
+
+}

src/main/java/dev/mv/utilsx/async/SignalFuture.java

@@ -1,8 +1,10 @@
 package dev.mv.utilsx.futures;
 
-import dev.mv.utilsx.async.Signal;
+import dev.mv.utilsx.generic.Null;
 import org.jetbrains.annotations.NotNull;
 
+import java.time.Duration;
+
 public interface Future<T> {
 
     @NotNull
@@ -18,4 +20,24 @@ default T awaitSync() {
             signal.await();
         }
     }
+
+    static Future<Null> yield() {
+        return new Yield();
+    }
+
+    static Future<Null> sleep(Duration duration) {
+        return new Sleep(duration);
+    }
+
+    static Future<Null> sleep(long millis) {
+        return new Sleep(millis);
+    }
+
+    static <T> Future<T> pending() {
+        return new Pending<>();
+    }
+
+    static <T> Future<T> ready(T value) {
+        return new Ready<>(value);
+    }
 }

src/main/java/dev/mv/utilsx/futures/Future.java

@@ -1,6 +1,5 @@
-package dev.mv.utilsx.async;
+package dev.mv.utilsx.futures;
 
-import dev.mv.utilsx.futures.*;
 import dev.mv.utilsx.generic.Null;
 
 import java.time.Duration;
@@ -10,10 +9,10 @@
 
 public class Signal implements Wake {
 
-    final Mutex<Boolean> ready = new Mutex<>(false);
-    final CondVar condition = new CondVar(ready);
-    final List<Waker> wakers = new ArrayList<>(1);
-    final AtomicInteger waiting = new AtomicInteger(0);
+    private final Mutex<Boolean> ready = new Mutex<>(false);
+    private final CondVar condition = new CondVar(ready);
+    private final List<Waker> wakers = new ArrayList<>(1);
+    private final AtomicInteger waiting = new AtomicInteger(0);
 
     public boolean ready() {
         return ready.get();
@@ -62,4 +61,28 @@ public void wake() {
         condition.signalAll();
         ready.unlock();
     }
+
+    public static class SignalFuture implements Future<Null> {
+
+        private final Signal signal;
+        private boolean started = false;
+
+        private SignalFuture(Signal signal) {
+            this.signal = signal;
+        }
+
+        @Override
+        public Poll<Null> poll(Context context) {
+            try {
+                signal.ready.lock();
+                if (signal.ready.getLocked()) return new Poll<>(Null.INSTANCE);
+                if (!started) {
+                    signal.wakers.add(context.waker());
+                }
+                return new Poll<>();
+            } finally {
+                signal.ready.unlock();
+            }
+        }
+    }
 }