tommyskeff/futur4j
1
0
Fork 0
mirror of https://github.com/tommyskeff/futur4j.git synced 2026-01-18 07:16:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

release 2.0.0

Browse Source
This commit is contained in:
tommyskeff
2024-01-02 22:49:44 +00:00
parent d879cbcbfb
commit 0a05da2aeb
28 changed files with 183 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
futur-api/src/main/java/dev/tommyjs/futur/promise/AbstractPromise.java
View File

@@ -4,52 +4,29 @@ import dev.tommyjs.futur.function.ExceptionalConsumer;
import dev.tommyjs.futur.function.ExceptionalFunction;
import dev.tommyjs.futur.function.ExceptionalRunnable;
import dev.tommyjs.futur.function.ExceptionalSupplier;
import dev.tommyjs.futur.scheduler.Scheduler;
import dev.tommyjs.futur.trace.ExecutorTrace;
import dev.tommyjs.futur.trace.TraceUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Stream;
public abstract class AbstractPromise<T> implements Promise<T> {
private static final String PACKAGE;
static {
String[] packageElements = AbstractPromise.class.getPackageName().split("\\.");
int i = 0;
StringBuilder packageBuilder = new StringBuilder();
while (i < 3) {
packageBuilder.append(packageElements[i]);
i++;
}
PACKAGE = packageBuilder.toString();
}
private final Collection<PromiseListener<T>> listeners;
private final StackTraceElement[] stackTrace;
private @Nullable PromiseCompletion<T> completion;
public AbstractPromise() {
this.listeners = new ConcurrentLinkedQueue<>();
this.completion = null;
this.stackTrace = Arrays.stream(Thread.currentThread().getStackTrace())
.filter(v -> !v.getClassName().startsWith(PACKAGE))
.toArray(StackTraceElement[]::new);
}
protected abstract Scheduler getScheduler();
protected abstract ScheduledExecutorService getExecutor();
protected abstract Logger getLogger();
@@ -84,7 +61,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplySync(result -> {
task.run();
return null;
}, TraceUtil.getTrace(task));
});
}
@Override
@@ -92,7 +69,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyDelayedSync(result -> {
task.run();
return null;
}, delay, unit, TraceUtil.getTrace(task));
}, delay, unit);
}
@Override
@@ -100,7 +77,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplySync(result -> {
task.accept(result);
return null;
}, TraceUtil.getTrace(task));
});
}
@Override
@@ -108,42 +85,21 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyDelayedSync(result -> {
task.accept(result);
return null;
}, delay, unit, TraceUtil.getTrace(task));
}, delay, unit);
}
@Override
public <V> @NotNull Promise<V> thenSupplySync(@NotNull ExceptionalSupplier<V> task) {
return thenApplySync(result -> task.get(), TraceUtil.getTrace(task));
return thenApplySync(result -> task.get());
}
@Override
public <V> @NotNull Promise<V> thenSupplyDelayedSync(@NotNull ExceptionalSupplier<V> task, long delay, @NotNull TimeUnit unit) {
return thenApplyDelayedSync(result -> task.get(), delay, unit, TraceUtil.getTrace(task));
return thenApplyDelayedSync(result -> task.get(), delay, unit);
}
protected <V> @NotNull Promise<V> thenApplySync(@NotNull ExceptionalFunction<T, V> task, @NotNull ExecutorTrace trace) {
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
if (ctx.isError()) {
//noinspection ConstantConditions
promise.completeExceptionally(ctx.getException());
return;
}
Runnable runnable = createRunnable(ctx, promise, task);
getScheduler().runSync(runnable, trace);
});
return promise;
}
@Override
public <V> @NotNull Promise<V> thenApplySync(@NotNull ExceptionalFunction<T, V> task) {
return thenApplySync(task, TraceUtil.getTrace(task));
}
@Override
public <V> @NotNull Promise<V> thenApplyDelayedSync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit, @NotNull ExecutorTrace trace) {
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
if (ctx.isError()) {
@@ -153,7 +109,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
}
Runnable runnable = createRunnable(ctx, promise, task);
getScheduler().runDelayedSync(runnable, delay, unit, trace);
getExecutor().submit(runnable);
});
return promise;
@@ -161,13 +117,25 @@ public abstract class AbstractPromise<T> implements Promise<T> {
@Override
public <V> @NotNull Promise<V> thenApplyDelayedSync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit) {
return thenApplyDelayedSync(task, delay, unit, TraceUtil.getTrace(task));
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
if (ctx.isError()) {
//noinspection ConstantConditions
promise.completeExceptionally(ctx.getException());
return;
}
Runnable runnable = createRunnable(ctx, promise, task);
getExecutor().schedule(runnable, delay, unit);
});
return promise;
}
@Override
public <V> @NotNull Promise<V> thenComposeSync(@NotNull ExceptionalFunction<T, @NotNull Promise<V>> task) {
Promise<V> promise = getFactory().unresolved();
thenApplySync(task, TraceUtil.getTrace(task)).thenConsumeAsync(nestedPromise -> {
thenApplySync(task).thenConsumeAsync(nestedPromise -> {
nestedPromise.addListener(ctx1 -> {
if (ctx1.isError()) {
//noinspection ConstantConditions
@@ -192,7 +160,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyAsync(result -> {
task.run();
return null;
}, TraceUtil.getTrace(task));
});
}
@Override
@@ -200,7 +168,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyDelayedAsync(result -> {
task.run();
return null;
}, delay, unit, TraceUtil.getTrace(task));
}, delay, unit);
}
@Override
@@ -208,7 +176,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyAsync(result -> {
task.accept(result);
return null;
}, TraceUtil.getTrace(task));
});
}
@Override
@@ -216,17 +184,17 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return thenApplyDelayedAsync(result -> {
task.accept(result);
return null;
}, delay, unit, TraceUtil.getTrace(task));
}, delay, unit);
}
@Override
public <V> @NotNull Promise<V> thenSupplyAsync(@NotNull ExceptionalSupplier<V> task) {
return thenApplyAsync(result -> task.get(), TraceUtil.getTrace(task));
return thenApplyAsync(result -> task.get());
}
@Override
public <V> @NotNull Promise<V> thenSupplyDelayedAsync(@NotNull ExceptionalSupplier<V> task, long delay, @NotNull TimeUnit unit) {
return thenApplyDelayedAsync(result -> task.get(), delay, unit, TraceUtil.getTrace(task));
return thenApplyDelayedAsync(result -> task.get(), delay, unit);
}
@Override
@@ -236,8 +204,9 @@ public abstract class AbstractPromise<T> implements Promise<T> {
return result;
});
}
protected <V> @NotNull Promise<V> thenApplyAsync(@NotNull ExceptionalFunction<T, V> task, @NotNull ExecutorTrace trace) {
@Override
public <V> @NotNull Promise<V> thenApplyAsync(@NotNull ExceptionalFunction<T, V> task) {
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
if (ctx.isError()) {
@@ -247,23 +216,7 @@ public abstract class AbstractPromise<T> implements Promise<T> {
}
Runnable runnable = createRunnable(ctx, promise, task);
getScheduler().runAsync(runnable, trace);
});
return promise;
}
@Override
public <V> @NotNull Promise<V> thenApplyAsync(@NotNull ExceptionalFunction<T, V> task) {
return thenApplyAsync(task, TraceUtil.getTrace(task));
}
@Override
public <V> @NotNull Promise<V> thenApplyDelayedAsync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit, @NotNull ExecutorTrace trace) {
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
Runnable runnable = createRunnable(ctx, promise, task);
getScheduler().runDelayedAsync(runnable, delay, unit, trace);
getExecutor().submit(runnable);
});
return promise;
@@ -271,18 +224,19 @@ public abstract class AbstractPromise<T> implements Promise<T> {
@Override
public <V> @NotNull Promise<V> thenApplyDelayedAsync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit) {
return thenApplyDelayedAsync(task, delay, unit, TraceUtil.getTrace(task));
}
Promise<V> promise = getFactory().unresolved();
addListener(ctx -> {
Runnable runnable = createRunnable(ctx, promise, task);
getExecutor().schedule(runnable, delay, unit);
});
@Override
public <V> @NotNull Promise<V> thenCompose(@NotNull ExceptionalFunction<T, Promise<V>> task) {
return this.thenComposeAsync(task);
return promise;
}
@Override
public <V> @NotNull Promise<V> thenComposeAsync(@NotNull ExceptionalFunction<T, Promise<V>> task) {
Promise<V> promise = getFactory().unresolved();
thenApplyAsync(task, TraceUtil.getTrace(task)).thenConsumeAsync(nestedPromise -> {
thenApplyAsync(task).thenConsumeAsync(nestedPromise -> {
nestedPromise.addListener(ctx1 -> {
if (ctx1.isError()) {
//noinspection ConstantConditions
@@ -313,8 +267,8 @@ public abstract class AbstractPromise<T> implements Promise<T> {
try {
V result = task.apply(ctx.getResult());
promise.complete(result);
} catch (Exception e) {
promise.completeExceptionally(e, true);
} catch (Throwable e) {
promise.completeExceptionally(e);
}
};
}
@@ -331,14 +285,14 @@ public abstract class AbstractPromise<T> implements Promise<T> {
@Override
public @NotNull Promise<T> addListener(@NotNull PromiseListener<T> listener) {
if (isCompleted()) {
getScheduler().runAsync(() -> {
getExecutor().submit(() -> {
try {
//noinspection ConstantConditions
listener.handle(getCompletion());
} catch (Exception e) {
getLogger().error("Exception caught in promise listener", e);
}
}, TraceUtil.getTrace(listener));
});
} else {
getListeners().add(listener);
}
@@ -348,13 +302,11 @@ public abstract class AbstractPromise<T> implements Promise<T> {
@Override
public @NotNull Promise<T> timeout(long time, @NotNull TimeUnit unit) {
Runnable func = () -> {
getExecutor().schedule(() -> {
if (!isCompleted()) {
completeExceptionally(new TimeoutException("Promise timed out after " + time + " " + unit), true);
completeExceptionally(new TimeoutException("Promise timed out after " + time + " " + unit));
}
};
getScheduler().runDelayedAsync(func, time, unit, TraceUtil.getTrace(func));
}, time, unit);
return this;
}
@@ -368,19 +320,18 @@ public abstract class AbstractPromise<T> implements Promise<T> {
if (this.isCompleted()) return;
setCompletion(ctx);
Runnable func = () -> {
getExecutor().submit(() -> {
for (PromiseListener<T> listener : getListeners()) {
if (!ctx.isActive()) return;
try {
listener.handle(ctx);
} catch (Exception e) {
e.printStackTrace();
getLogger().error("Exception caught in promise listener", e);
}
}
};
getScheduler().runAsync(func, TraceUtil.getTrace(func));
});
}
@Override
@@ -388,23 +339,9 @@ public abstract class AbstractPromise<T> implements Promise<T> {
handleCompletion(new PromiseCompletion<>(result));
}
@Override
public void completeExceptionally(@NotNull Throwable result, boolean appendStacktrace) {
if (appendStacktrace && this.stackTrace != null) {
result.setStackTrace(Stream.of(result.getStackTrace(), this.stackTrace)
.flatMap(Stream::of)
.filter(v -> !v.getClassName().startsWith(PACKAGE))
.filter(v -> !v.getClassName().startsWith("java.lang.Thread"))
.filter(v -> !v.getClassName().startsWith("java.util.concurrent"))
.toArray(StackTraceElement[]::new));
}
handleCompletion(new PromiseCompletion<>(result));
}
@Override
public void completeExceptionally(@NotNull Throwable result) {
completeExceptionally(result, false);
handleCompletion(new PromiseCompletion<>(result));
}
@Override

32
futur-api/src/main/java/dev/tommyjs/futur/promise/Promise.java
View File

@@ -4,7 +4,6 @@ import dev.tommyjs.futur.function.ExceptionalConsumer;
import dev.tommyjs.futur.function.ExceptionalFunction;
import dev.tommyjs.futur.function.ExceptionalRunnable;
import dev.tommyjs.futur.function.ExceptionalSupplier;
import dev.tommyjs.futur.trace.ExecutorTrace;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -22,25 +21,12 @@ public interface Promise<T> {
return factory.error(error);
}
static <T> @NotNull Promise<T> unresolved(PromiseFactory factory) {
return factory.unresolved();
}
static @NotNull Promise<Void> start(PromiseFactory factory) {
return factory.start();
}
static <T> @NotNull Promise<T> resolve(T value) {
return resolve(value, UnpooledPromiseFactory.INSTANCE);
}
static <T> @NotNull Promise<T> error(Throwable error) {
return error(error, UnpooledPromiseFactory.INSTANCE);
}
static @NotNull Promise<Void> start() {
return start(UnpooledPromiseFactory.INSTANCE);
}
@Deprecated
static <T> @NotNull Promise<T> start(T start) {
return resolve(start);
return factory.resolve(null);
}
PromiseFactory getFactory();
@@ -61,8 +47,6 @@ public interface Promise<T> {
<V> @NotNull Promise<V> thenApplySync(@NotNull ExceptionalFunction<T, V> task);
<V> @NotNull Promise<V> thenApplyDelayedSync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit, @NotNull ExecutorTrace trace);
<V> @NotNull Promise<V> thenApplyDelayedSync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit);
<V> @NotNull Promise<V> thenComposeSync(@NotNull ExceptionalFunction<T, @NotNull Promise<V>> task);
@@ -83,12 +67,8 @@ public interface Promise<T> {
<V> @NotNull Promise<V> thenApplyAsync(@NotNull ExceptionalFunction<T, V> task);
<V> @NotNull Promise<V> thenApplyDelayedAsync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit, @NotNull ExecutorTrace trace);
<V> @NotNull Promise<V> thenApplyDelayedAsync(@NotNull ExceptionalFunction<T, V> task, long delay, @NotNull TimeUnit unit);
<V> @NotNull Promise<V> thenCompose(@NotNull ExceptionalFunction<T, Promise<V>> task);
<V> @NotNull Promise<V> thenComposeAsync(@NotNull ExceptionalFunction<T, Promise<V>> task);
@NotNull Promise<T> logExceptions();
@@ -101,8 +81,6 @@ public interface Promise<T> {
void complete(@Nullable T result);
void completeExceptionally(@NotNull Throwable result, boolean appendStacktrace);
void completeExceptionally(@NotNull Throwable result);
boolean isCompleted();

22
futur-api/src/main/java/dev/tommyjs/futur/promise/PromiseFactory.java
View File

@@ -1,6 +1,12 @@
package dev.tommyjs.futur.promise;
import dev.tommyjs.futur.impl.SimplePromiseFactory;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public interface PromiseFactory {
@@ -10,6 +16,20 @@ public interface PromiseFactory {
<T> @NotNull Promise<T> error(Throwable error);
@NotNull Promise<Void> start();
static PromiseFactory create(ScheduledExecutorService executor, Logger logger) {
return new SimplePromiseFactory(executor, logger);
}
static PromiseFactory create(ScheduledExecutorService executor) {
return create(executor, LoggerFactory.getLogger(SimplePromiseFactory.class));
}
static PromiseFactory create(int threadPoolSize) {
return create(Executors.newScheduledThreadPool(threadPoolSize));
}
static PromiseFactory create() {
return create(Runtime.getRuntime().availableProcessors());
}
}

76
futur-api/src/main/java/dev/tommyjs/futur/promise/Promises.java
View File

@@ -71,41 +71,23 @@ public class Promises {
return promise.timeout(timeout);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, long timeout, @Nullable BiConsumer<K, Throwable> exceptionHandler) {
return combine(promises, timeout, exceptionHandler, obtainFactory(promises.values()));
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, long timeout, boolean strict, PromiseFactory factory) {
return combine(promises, timeout, strict ? null : (_k, _v) -> {}, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, long timeout, boolean strict) {
return combine(promises, timeout, strict, obtainFactory(promises.values()));
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, long timeout, PromiseFactory factory) {
return combine(promises, timeout, true, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, long timeout) {
return combine(promises, timeout, true, obtainFactory(promises.values()));
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises, PromiseFactory factory) {
return combine(promises, 1500L, true, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Map<K, Promise<V>> promises) {
return combine(promises, obtainFactory(promises.values()));
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises, long timeout, boolean strict, PromiseFactory factory) {
AtomicInteger index = new AtomicInteger();
return combine(
promises.stream()
.collect(Collectors.toMap(s -> index.getAndIncrement(), v -> v)),
timeout,
strict
promises.stream().collect(Collectors.toMap(s -> index.getAndIncrement(), v -> v)),
timeout, strict, factory
).thenApplySync(v ->
v.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
@@ -114,24 +96,12 @@ public class Promises {
);
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises, long timeout, boolean strict) {
return combine(promises, timeout, strict, obtainFactory(promises));
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises, long timeout, PromiseFactory factory) {
return combine(promises, timeout, true, factory);
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises, long timeout) {
return combine(promises, timeout, obtainFactory(promises));
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises, PromiseFactory factory) {
return combine(promises, 1500L, true);
}
public static <V> @NotNull Promise<List<V>> combine(@NotNull List<Promise<V>> promises) {
return combine(promises, obtainFactory(promises));
return combine(promises, 1500L, true, factory);
}
public static @NotNull Promise<Void> all(@NotNull List<Promise<?>> promises, PromiseFactory factory) {
@@ -149,17 +119,6 @@ public class Promises {
return promise;
}
public static @NotNull Promise<Void> all(@NotNull List<Promise<?>> promises) {
PromiseFactory factory;
if (promises.isEmpty()) {
factory = UnpooledPromiseFactory.INSTANCE;
} else {
factory = promises.get(0).getFactory();
}
return all(promises, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper, long timeout, boolean strict, PromiseFactory factory) {
Map<K, Promise<V>> promises = new HashMap<>();
for (K key : keys) {
@@ -167,29 +126,17 @@ public class Promises {
promises.put(key, promise);
}
return combine(promises, timeout, strict);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper, long timeout, boolean strict) {
return combine(keys, mapper, timeout, strict, UnpooledPromiseFactory.INSTANCE);
return combine(promises, timeout, strict, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper, long timeout, PromiseFactory factory) {
return combine(keys, mapper, timeout, true, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper, long timeout) {
return combine(keys, mapper, timeout, UnpooledPromiseFactory.INSTANCE);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper, PromiseFactory factory) {
return combine(keys, mapper, 1500L, true, factory);
}
public static <K, V> @NotNull Promise<Map<K, V>> combine(@NotNull Collection<K> keys, @NotNull ExceptionalFunction<K, V> mapper) {
return combine(keys, mapper, UnpooledPromiseFactory.INSTANCE);
}
public static @NotNull Promise<Void> erase(@NotNull Promise<?> p, PromiseFactory factory) {
Promise<Void> promise = factory.unresolved();
p.addListener(ctx -> {
@@ -221,19 +168,4 @@ public class Promises {
return promise;
}
public static <T> @NotNull Promise<T> wrap(@NotNull CompletableFuture<T> future) {
return wrap(future, UnpooledPromiseFactory.INSTANCE);
}
public static <T> PromiseFactory obtainFactory(Collection<Promise<T>> promises) {
PromiseFactory factory;
if (promises.isEmpty()) {
factory = UnpooledPromiseFactory.INSTANCE;
} else {
factory = promises.stream().findFirst().get().getFactory();
}
return factory;
}
}

24
futur-api/src/main/java/dev/tommyjs/futur/promise/StaticPromise.java Normal file
View File

@@ -0,0 +1,24 @@
package dev.tommyjs.futur.promise;
import org.slf4j.Logger;
import java.util.concurrent.ScheduledExecutorService;
public class StaticPromise<T> extends AbstractPromise<T> {
@Override
protected ScheduledExecutorService getExecutor() {
return StaticPromiseFactory.EXECUTOR;
}
@Override
protected Logger getLogger() {
return StaticPromiseFactory.LOGGER;
}
@Override
public PromiseFactory getFactory() {
return StaticPromiseFactory.INSTANCE;
}
}

44
futur-api/src/main/java/dev/tommyjs/futur/promise/StaticPromiseFactory.java Normal file
View File

@@ -0,0 +1,44 @@
package dev.tommyjs.futur.promise;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class StaticPromiseFactory implements PromiseFactory {
public static final @NotNull PromiseFactory INSTANCE;
public static final @NotNull ScheduledExecutorService EXECUTOR;
public static final @NotNull Logger LOGGER;
static {
INSTANCE = new StaticPromiseFactory();
EXECUTOR = Executors.newSingleThreadScheduledExecutor();
LOGGER = LoggerFactory.getLogger(StaticPromiseFactory.class);
}
private StaticPromiseFactory() {
}
@Override
public @NotNull <T> Promise<T> resolve(T value) {
AbstractPromise<T> promise = new StaticPromise<>();
promise.setCompletion(new PromiseCompletion<>(value));
return promise;
}
@Override
public @NotNull <T> Promise<T> unresolved() {
return new StaticPromise<>();
}
@Override
public @NotNull <T> Promise<T> error(Throwable error) {
AbstractPromise<T> promise = new StaticPromise<>();
promise.completeExceptionally(error);
return promise;
}
}

23
futur-api/src/main/java/dev/tommyjs/futur/promise/UnpooledPromise.java
View File

@@ -1,23 +0,0 @@
package dev.tommyjs.futur.promise;
import dev.tommyjs.futur.scheduler.Scheduler;
import org.slf4j.Logger;
public class UnpooledPromise<T> extends AbstractPromise<T> {
@Override
protected Scheduler getScheduler() {
return UnpooledPromiseFactory.SCHEDULER;
}
@Override
protected Logger getLogger() {
return UnpooledPromiseFactory.LOGGER;
}
@Override
public PromiseFactory getFactory() {
return UnpooledPromiseFactory.INSTANCE;
}
}

50
futur-api/src/main/java/dev/tommyjs/futur/promise/UnpooledPromiseFactory.java
View File

@@ -1,50 +0,0 @@
package dev.tommyjs.futur.promise;
import dev.tommyjs.futur.scheduler.Scheduler;
import dev.tommyjs.futur.scheduler.SingleExecutorScheduler;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.Executors;
public class UnpooledPromiseFactory implements PromiseFactory {
public static final @NotNull PromiseFactory INSTANCE;
public static final @NotNull Scheduler SCHEDULER;
public static final @NotNull Logger LOGGER;
static {
INSTANCE = new UnpooledPromiseFactory();
SCHEDULER = new SingleExecutorScheduler(Executors.newSingleThreadScheduledExecutor());
LOGGER = LoggerFactory.getLogger(UnpooledPromiseFactory.class);
}
private UnpooledPromiseFactory() {
}
@Override
public @NotNull <T> Promise<T> resolve(T value) {
AbstractPromise<T> promise = new UnpooledPromise<>();
promise.setCompletion(new PromiseCompletion<>(value));
return promise;
}
@Override
public @NotNull <T> Promise<T> unresolved() {
return new UnpooledPromise<>();
}
@Override
public @NotNull <T> Promise<T> error(Throwable error) {
AbstractPromise<T> promise = new UnpooledPromise<>();
promise.completeExceptionally(error);
return promise;
}
@Override
public @NotNull Promise<Void> start() {
return resolve(null);
}
}