From 4251f2fd82b5189032fc6eddef948ce8955482e8 Mon Sep 17 00:00:00 2001
From: WhatCats <whatcater@gmail.com>
Date: Sat, 25 May 2024 21:17:14 +0200
Subject: [PATCH] add more direct listener methods

---
 .../futur/promise/AbstractPromise.java        | 52 +++++++++++++++++++
 .../dev/tommyjs/futur/promise/Promise.java    | 10 ++++
 2 files changed, 62 insertions(+)

diff --git a/futur-api/src/main/java/dev/tommyjs/futur/promise/AbstractPromise.java b/futur-api/src/main/java/dev/tommyjs/futur/promise/AbstractPromise.java
index 351e1b4..bb823eb 100644
--- a/futur-api/src/main/java/dev/tommyjs/futur/promise/AbstractPromise.java
+++ b/futur-api/src/main/java/dev/tommyjs/futur/promise/AbstractPromise.java
@@ -103,6 +103,58 @@ public abstract class AbstractPromise<T, F> implements Promise<T> {
         return completion.getResult();
     }
 
+    @Override
+    public @NotNull Promise<Void> thenRun(@NotNull ExceptionalRunnable task) {
+        return thenApply(result -> {
+            task.run();
+            return null;
+        });
+    }
+
+    @Override
+    public @NotNull Promise<Void> thenConsume(@NotNull ExceptionalConsumer<T> task) {
+        return thenApply(result -> {
+            task.accept(result);
+            return null;
+        });
+    }
+
+    @Override
+    public <V> @NotNull Promise<V> thenSupply(@NotNull ExceptionalSupplier<V> task) {
+        return thenApply(result -> task.get());
+    }
+
+    @Override
+    public <V> @NotNull Promise<V> thenApply(@NotNull ExceptionalFunction<T, V> task) {
+        Promise<V> promise = getFactory().unresolved();
+        addDirectListener(
+            res -> createRunnable(res, promise, task).run(),
+            promise::completeExceptionally
+        );
+
+        propagateCancel(promise, this);
+        return promise;
+    }
+
+    @Override
+    public <V> @NotNull Promise<V> thenCompose(@NotNull ExceptionalFunction<T, Promise<V>> task) {
+        Promise<V> promise = getFactory().unresolved();
+        thenApply(task).addDirectListener(
+            nestedPromise -> {
+                if (nestedPromise == null) {
+                    promise.complete(null);
+                } else {
+                    propagateResult(nestedPromise, promise);
+                    propagateCancel(promise, nestedPromise);
+                }
+            },
+            promise::completeExceptionally
+        );
+
+        propagateCancel(promise, this);
+        return promise;
+    }
+
     @Override
     public @NotNull Promise<Void> thenRunSync(@NotNull ExceptionalRunnable task) {
         return thenApplySync(result -> {
diff --git a/futur-api/src/main/java/dev/tommyjs/futur/promise/Promise.java b/futur-api/src/main/java/dev/tommyjs/futur/promise/Promise.java
index 52f6e1f..1fc93f4 100644
--- a/futur-api/src/main/java/dev/tommyjs/futur/promise/Promise.java
+++ b/futur-api/src/main/java/dev/tommyjs/futur/promise/Promise.java
@@ -19,6 +19,16 @@ public interface Promise<T> {
 
     PromiseFactory getFactory();
 
+    @NotNull Promise<Void> thenRun(@NotNull ExceptionalRunnable task);
+
+    @NotNull Promise<Void> thenConsume(@NotNull ExceptionalConsumer<T> task);
+
+    <V> @NotNull Promise<V> thenSupply(@NotNull ExceptionalSupplier<V> task);
+
+    <V> @NotNull Promise<V> thenApply(@NotNull ExceptionalFunction<T, V> task);
+
+    <V> @NotNull Promise<V> thenCompose(@NotNull ExceptionalFunction<T, Promise<V>> task);
+
     @NotNull Promise<Void> thenRunSync(@NotNull ExceptionalRunnable task);
 
     @NotNull Promise<Void> thenRunDelayedSync(@NotNull ExceptionalRunnable task, long delay, @NotNull TimeUnit unit);