diff --git a/pom.xml b/pom.xml index 2931d5a..dd0e002 100644 --- a/pom.xml +++ b/pom.xml @@ -50,10 +50,10 @@ target/mods - 2.1.5 + 3.1.0 2.0.3-final - 4.11 - 3.0.0 + 4.12 + 3.2.0 3.0 @@ -75,12 +75,6 @@ ${vertx.version} provided - - io.vertx - vertx-platform - ${vertx.version} - provided - io.vertx vertx-hazelcast @@ -120,48 +114,6 @@ - - - io.vertx - vertx-maven-plugin - ${maven.vertx.plugin.version} - - - - - io.vertx - vertx-platform - ${vertx.version} - - - io.vertx - vertx-core - ${vertx.version} - - - io.vertx - vertx-hazelcast - ${vertx.version} - - - - - PullInDeps - prepare-package - - pullInDeps - - - - - org.apache.maven.plugins @@ -278,23 +230,6 @@ - - maven-assembly-plugin - - - src/main/assembly/mod.xml - - - - - assemble - package - - single - - - - diff --git a/src/main/README.txt b/src/main/README.txt deleted file mode 100644 index 0447763..0000000 --- a/src/main/README.txt +++ /dev/null @@ -1,6 +0,0 @@ -Put any Java or Groovy classes used in your module in the java or groovy directories. - -Put any other resources that you want included in your module in the resources directory, this includes any -JavaScript, Ruby, Python, Groovy or CoffeeScript scripts or any other stuff you want in your module. - -The mod.json file also goes in the resources directory so it's copied over too. \ No newline at end of file diff --git a/src/main/assembly/mod.xml b/src/main/assembly/mod.xml deleted file mode 100644 index 941934a..0000000 --- a/src/main/assembly/mod.xml +++ /dev/null @@ -1,22 +0,0 @@ - - - - mod - - zip - - - false - - - - - ${mods.directory}/${module.name} - - ** - - - - diff --git a/src/main/java/org/simondean/vertx/async/AsyncResultHandlerWrapper.java b/src/main/java/org/simondean/vertx/async/AsyncResultHandlerWrapper.java index 7bb6f51..47abefc 100644 --- a/src/main/java/org/simondean/vertx/async/AsyncResultHandlerWrapper.java +++ b/src/main/java/org/simondean/vertx/async/AsyncResultHandlerWrapper.java @@ -1,26 +1,27 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResult; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResult; +import io.vertx.core.AsyncResultHandler; public class AsyncResultHandlerWrapper implements AsyncResultHandler { - private final AsyncResultHandler handler; - public AsyncResultHandlerWrapper(AsyncResultHandler handler) { - this.handler = handler; - } + private final AsyncResultHandler handler; - public static AsyncResultHandler wrap(AsyncResultHandler handler) { - return new AsyncResultHandlerWrapper<>(handler); - } + public AsyncResultHandlerWrapper(AsyncResultHandler handler) { + this.handler = handler; + } - @Override - public void handle(AsyncResult asyncResult) { - if (asyncResult.failed()) { - handler.handle(DefaultAsyncResult.fail(asyncResult.cause())); - return; + public static AsyncResultHandler wrap(AsyncResultHandler handler) { + return new AsyncResultHandlerWrapper<>(handler); } - handler.handle(DefaultAsyncResult.succeed((T) asyncResult.result())); - } + @Override + public void handle(AsyncResult asyncResult) { + if (asyncResult.failed()) { + handler.handle(DefaultAsyncResult.fail(asyncResult.cause())); + return; + } + + handler.handle(DefaultAsyncResult.succeed((T) asyncResult.result())); + } } diff --git a/src/main/java/org/simondean/vertx/async/DefaultAsyncResult.java b/src/main/java/org/simondean/vertx/async/DefaultAsyncResult.java index 5e2bab0..e2346ef 100644 --- a/src/main/java/org/simondean/vertx/async/DefaultAsyncResult.java +++ b/src/main/java/org/simondean/vertx/async/DefaultAsyncResult.java @@ -1,53 +1,54 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResult; +import io.vertx.core.AsyncResult; public class DefaultAsyncResult implements AsyncResult { - private Throwable cause; - private T result; - public DefaultAsyncResult(Throwable cause, T result) { - this.cause = cause; - this.result = result; - } + private Throwable cause; + private T result; - public static AsyncResult succeed(T result) { - return new DefaultAsyncResult<>(null, result); - } + public DefaultAsyncResult(Throwable cause, T result) { + this.cause = cause; + this.result = result; + } - public static AsyncResult succeed() { - return succeed(null); - } + public static AsyncResult succeed(T result) { + return new DefaultAsyncResult<>(null, result); + } - public static AsyncResult fail(Throwable cause) { - if (cause == null) { - throw new IllegalArgumentException("cause argument cannot be null"); + public static AsyncResult succeed() { + return succeed(null); } - return new DefaultAsyncResult<>(cause, null); - } + public static AsyncResult fail(Throwable cause) { + if (cause == null) { + throw new IllegalArgumentException("cause argument cannot be null"); + } - public static AsyncResult fail(AsyncResult result) { - return fail(result.cause()); - } + return new DefaultAsyncResult<>(cause, null); + } - @Override - public T result() { - return result; - } + public static AsyncResult fail(AsyncResult result) { + return fail(result.cause()); + } - @Override - public Throwable cause() { - return cause; - } + @Override + public T result() { + return result; + } - @Override - public boolean succeeded() { - return cause == null; - } + @Override + public Throwable cause() { + return cause; + } + + @Override + public boolean succeeded() { + return cause == null; + } - @Override - public boolean failed() { - return cause != null; - } + @Override + public boolean failed() { + return cause != null; + } } diff --git a/src/main/java/org/simondean/vertx/async/EachBuilder.java b/src/main/java/org/simondean/vertx/async/EachBuilder.java index 009945d..aaaf28a 100644 --- a/src/main/java/org/simondean/vertx/async/EachBuilder.java +++ b/src/main/java/org/simondean/vertx/async/EachBuilder.java @@ -1,7 +1,7 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.Vertx; +import io.vertx.core.AsyncResultHandler; +import io.vertx.core.Vertx; public interface EachBuilder { void run(Vertx vertx, AsyncResultHandler handler); diff --git a/src/main/java/org/simondean/vertx/async/Forever.java b/src/main/java/org/simondean/vertx/async/Forever.java index e82c8ac..bd98dc8 100644 --- a/src/main/java/org/simondean/vertx/async/Forever.java +++ b/src/main/java/org/simondean/vertx/async/Forever.java @@ -1,7 +1,7 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.Vertx; +import io.vertx.core.AsyncResultHandler; +import io.vertx.core.Vertx; public interface Forever { void run(Vertx vertx, AsyncResultHandler handler); diff --git a/src/main/java/org/simondean/vertx/async/ForeverBuilder.java b/src/main/java/org/simondean/vertx/async/ForeverBuilder.java index 24f9ba8..d4bdadc 100644 --- a/src/main/java/org/simondean/vertx/async/ForeverBuilder.java +++ b/src/main/java/org/simondean/vertx/async/ForeverBuilder.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/IterableBuilder.java b/src/main/java/org/simondean/vertx/async/IterableBuilder.java index 73ae2fb..c476bab 100644 --- a/src/main/java/org/simondean/vertx/async/IterableBuilder.java +++ b/src/main/java/org/simondean/vertx/async/IterableBuilder.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.BiConsumer; diff --git a/src/main/java/org/simondean/vertx/async/Retry.java b/src/main/java/org/simondean/vertx/async/Retry.java index 0aff2d5..c647ae9 100644 --- a/src/main/java/org/simondean/vertx/async/Retry.java +++ b/src/main/java/org/simondean/vertx/async/Retry.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; public interface Retry { void run(AsyncResultHandler handler); diff --git a/src/main/java/org/simondean/vertx/async/RetryBuilder.java b/src/main/java/org/simondean/vertx/async/RetryBuilder.java index b30ff73..0b302eb 100644 --- a/src/main/java/org/simondean/vertx/async/RetryBuilder.java +++ b/src/main/java/org/simondean/vertx/async/RetryBuilder.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/Series.java b/src/main/java/org/simondean/vertx/async/Series.java index 4730d28..e5c552a 100644 --- a/src/main/java/org/simondean/vertx/async/Series.java +++ b/src/main/java/org/simondean/vertx/async/Series.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.List; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/Waterfall.java b/src/main/java/org/simondean/vertx/async/Waterfall.java index 9ea2788..e2bf17c 100644 --- a/src/main/java/org/simondean/vertx/async/Waterfall.java +++ b/src/main/java/org/simondean/vertx/async/Waterfall.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.BiConsumer; diff --git a/src/main/java/org/simondean/vertx/async/WaterfallBuilder.java b/src/main/java/org/simondean/vertx/async/WaterfallBuilder.java index 771a652..fe16588 100644 --- a/src/main/java/org/simondean/vertx/async/WaterfallBuilder.java +++ b/src/main/java/org/simondean/vertx/async/WaterfallBuilder.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/DefaultWaterfall.java b/src/main/java/org/simondean/vertx/async/internal/DefaultWaterfall.java index 4be4d80..b5c6cbb 100644 --- a/src/main/java/org/simondean/vertx/async/internal/DefaultWaterfall.java +++ b/src/main/java/org/simondean/vertx/async/internal/DefaultWaterfall.java @@ -1,7 +1,7 @@ package org.simondean.vertx.async.internal; import org.simondean.vertx.async.Waterfall; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.BiConsumer; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/EachBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/EachBuilderImpl.java index 60311e9..3364939 100644 --- a/src/main/java/org/simondean/vertx/async/internal/EachBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/EachBuilderImpl.java @@ -3,8 +3,8 @@ import org.simondean.vertx.async.DefaultAsyncResult; import org.simondean.vertx.async.EachBuilder; import org.simondean.vertx.async.ObjectWrapper; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.Vertx; +import io.vertx.core.AsyncResultHandler; +import io.vertx.core.Vertx; import java.util.ArrayList; import java.util.function.BiConsumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/ForeverBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/ForeverBuilderImpl.java index 0f22e2b..e558a72 100644 --- a/src/main/java/org/simondean/vertx/async/internal/ForeverBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/ForeverBuilderImpl.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.Forever; import org.simondean.vertx.async.ForeverBuilder; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/ForeverImpl.java b/src/main/java/org/simondean/vertx/async/internal/ForeverImpl.java index 44db362..8a18d29 100644 --- a/src/main/java/org/simondean/vertx/async/internal/ForeverImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/ForeverImpl.java @@ -3,8 +3,8 @@ import org.simondean.vertx.async.DefaultAsyncResult; import org.simondean.vertx.async.Forever; import org.simondean.vertx.async.FunctionWrapper; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.Vertx; +import io.vertx.core.AsyncResultHandler; +import io.vertx.core.Vertx; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/IterableBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/IterableBuilderImpl.java index 8b9ae6a..63715a4 100644 --- a/src/main/java/org/simondean/vertx/async/internal/IterableBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/IterableBuilderImpl.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.EachBuilder; import org.simondean.vertx.async.IterableBuilder; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.BiConsumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/NestedWaterfall.java b/src/main/java/org/simondean/vertx/async/internal/NestedWaterfall.java index 27fe034..62ef43e 100644 --- a/src/main/java/org/simondean/vertx/async/internal/NestedWaterfall.java +++ b/src/main/java/org/simondean/vertx/async/internal/NestedWaterfall.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.DefaultAsyncResult; import org.simondean.vertx.async.Waterfall; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.BiConsumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/RetryBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/RetryBuilderImpl.java index 7cc13aa..8960a57 100644 --- a/src/main/java/org/simondean/vertx/async/internal/RetryBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/RetryBuilderImpl.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.RetryBuilder; import org.simondean.vertx.async.RetryTimesBuilder; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/RetryImpl.java b/src/main/java/org/simondean/vertx/async/internal/RetryImpl.java index be9fca6..ba8543f 100644 --- a/src/main/java/org/simondean/vertx/async/internal/RetryImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/RetryImpl.java @@ -4,7 +4,7 @@ import org.simondean.vertx.async.FunctionWrapper; import org.simondean.vertx.async.ObjectWrapper; import org.simondean.vertx.async.Retry; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/RetryTimesBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/RetryTimesBuilderImpl.java index 9fdd90b..dada6d8 100644 --- a/src/main/java/org/simondean/vertx/async/internal/RetryTimesBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/RetryTimesBuilderImpl.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.Retry; import org.simondean.vertx.async.RetryTimesBuilder; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/java/org/simondean/vertx/async/internal/SeriesImpl.java b/src/main/java/org/simondean/vertx/async/internal/SeriesImpl.java index d5eae6e..0e46180 100644 --- a/src/main/java/org/simondean/vertx/async/internal/SeriesImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/SeriesImpl.java @@ -1,53 +1,51 @@ - package org.simondean.vertx.async.internal; -import org.simondean.vertx.async.DefaultAsyncResult; -import org.simondean.vertx.async.FunctionWrapper; -import org.simondean.vertx.async.Series; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; - +import io.vertx.core.AsyncResultHandler; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.function.Consumer; +import org.simondean.vertx.async.DefaultAsyncResult; +import org.simondean.vertx.async.FunctionWrapper; +import org.simondean.vertx.async.Series; public class SeriesImpl implements Series { - private ArrayList>> tasks = new ArrayList<>(); - - @Override - public Series task(Consumer> task) { - tasks.add(task); - return this; - } - - @Override - public void run(AsyncResultHandler> handler) { - Iterator>> iterator = tasks.iterator(); - List results = new ArrayList<>(); - - FunctionWrapper visitor = new FunctionWrapper<>(); - visitor.wrap(() -> { - if (!iterator.hasNext()) { - handler.handle(DefaultAsyncResult.succeed(results)); - return; - } - - Consumer> task = iterator.next(); - - AsyncResultHandler taskHandler = (result) -> { - if (result.failed()) { - handler.handle(DefaultAsyncResult.fail(result)); - return; - } - - results.add(result.result()); - visitor.f().run(); - }; - task.accept(taskHandler); - }); + private ArrayList>> tasks = new ArrayList<>(); - visitor.f().run(); - } + @Override + public Series task(Consumer> task) { + tasks.add(task); + return this; + } + + @Override + public void run(AsyncResultHandler> handler) { + Iterator>> iterator = tasks.iterator(); + List results = new ArrayList<>(); + + FunctionWrapper visitor = new FunctionWrapper<>(); + visitor.wrap(() -> { + if (!iterator.hasNext()) { + handler.handle(DefaultAsyncResult.succeed(results)); + return; + } + + Consumer> task = iterator.next(); + + AsyncResultHandler taskHandler = (result) -> { + if (result.failed()) { + handler.handle(DefaultAsyncResult.fail(result)); + return; + } + + results.add(result.result()); + visitor.f().run(); + }; + + task.accept(taskHandler); + }); + + visitor.f().run(); + } } diff --git a/src/main/java/org/simondean/vertx/async/internal/WaterfallBuilderImpl.java b/src/main/java/org/simondean/vertx/async/internal/WaterfallBuilderImpl.java index 4e40e5f..832be2f 100644 --- a/src/main/java/org/simondean/vertx/async/internal/WaterfallBuilderImpl.java +++ b/src/main/java/org/simondean/vertx/async/internal/WaterfallBuilderImpl.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.WaterfallBuilder; import org.simondean.vertx.async.Waterfall; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/main/platform_lib/README.txt b/src/main/platform_lib/README.txt deleted file mode 100644 index 5760834..0000000 --- a/src/main/platform_lib/README.txt +++ /dev/null @@ -1,3 +0,0 @@ -If you want override the default langs.properties, cluster.xml or any other config for the Vert.x platform (i.e. -not for the module!) then you can add them in here and they will be added to the platform classpath when running -your module using Gradle. \ No newline at end of file diff --git a/src/main/resources/mod.json b/src/main/resources/mod.json deleted file mode 100644 index caa9140..0000000 --- a/src/main/resources/mod.json +++ /dev/null @@ -1,14 +0,0 @@ -{ - "description":"Async helpers for Vert.x", - "licenses": ["MIT"], - "author": "Simon Dean", - - "developers": [], - "keywords": [ - "async", - "vert.x" - ], - "homepage": "https://github.com/simondean/vertx-async", - - "auto-redeploy": true -} diff --git a/src/main/resources/platform_lib/README.txt b/src/main/resources/platform_lib/README.txt deleted file mode 100644 index b603fa9..0000000 --- a/src/main/resources/platform_lib/README.txt +++ /dev/null @@ -1,5 +0,0 @@ -If you are using fatjars and you want override the default langs.properties, cluster.xml or any other config for the Vert.x platform (i.e. -not for the module!) then you can add them in here and they will be added to the platform classpath when running -your module using Gradle. - -The fatjar starter knows to add this directory (and any jars/zips inside it) to the Vert.x platform classpath when executing your module as a fatjar. \ No newline at end of file diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/BaseExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/BaseExample.java index 8b768b6..6a8d91b 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/BaseExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/BaseExample.java @@ -1,7 +1,7 @@ package org.simondean.vertx.async.unit.examples; import org.simondean.vertx.async.unit.fakes.FakeVertx; -import org.vertx.java.core.Vertx; +import io.vertx.core.Vertx; public class BaseExample { protected Vertx vertx; diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/EachExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/EachExample.java index 261c935..30a9f6c 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/EachExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/EachExample.java @@ -1,43 +1,42 @@ package org.simondean.vertx.async.unit.examples; -import org.simondean.vertx.async.Async; -import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; - +import io.vertx.core.AsyncResultHandler; import java.util.ArrayList; import java.util.Arrays; import java.util.List; +import org.simondean.vertx.async.Async; +import org.simondean.vertx.async.DefaultAsyncResult; public class EachExample extends BaseExample { - private final boolean succeed; - private ArrayList items = new ArrayList<>(); - - public EachExample(boolean succeed) { - this.succeed = succeed; - } - - public void eachExample(AsyncResultHandler handler) { - List list = Arrays.asList("one", "two", "three"); - - Async.iterable(list) - .each((item, eachHandler) -> { - doSomethingWithItem(item, eachHandler); - }) - .run(vertx, handler); - } - - private void doSomethingWithItem(String item, AsyncResultHandler handler) { - if (!succeed) { - handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); - return; + + private final boolean succeed; + private ArrayList items = new ArrayList<>(); + + public EachExample(boolean succeed) { + this.succeed = succeed; } - items.add(item); - handler.handle(DefaultAsyncResult.succeed()); - } + public void eachExample(AsyncResultHandler handler) { + List list = Arrays.asList("one", "two", "three"); - public List items() { - return items; - } + Async.iterable(list) + .each((item, eachHandler) -> { + doSomethingWithItem(item, eachHandler); + }) + .run(vertx, handler); + } + + private void doSomethingWithItem(String item, AsyncResultHandler handler) { + if (!succeed) { + handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); + return; + } + + items.add(item); + handler.handle(DefaultAsyncResult.succeed()); + } + + public List items() { + return items; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/ForeverExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/ForeverExample.java index 820c608..1d287a5 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/ForeverExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/ForeverExample.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.Async; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; public class ForeverExample extends BaseExample { public void foreverExample(AsyncResultHandler handler) { diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/RetryExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/RetryExample.java index dc70bf5..2ed4ad2 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/RetryExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/RetryExample.java @@ -2,7 +2,7 @@ import org.simondean.vertx.async.Async; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; public class RetryExample extends BaseExample { private final boolean succeed; diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/SeriesExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/SeriesExample.java index b1f88a7..74b4fdf 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/SeriesExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/SeriesExample.java @@ -1,60 +1,59 @@ package org.simondean.vertx.async.unit.examples; +import io.vertx.core.AsyncResultHandler; +import java.util.List; import org.simondean.vertx.async.Async; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; - -import java.util.List; public class SeriesExample extends BaseExample { - private final boolean succeed; - private List results; - - public SeriesExample(boolean succeed) { - this.succeed = succeed; - } - - public void seriesExample(AsyncResultHandler> handler) { - Async.series() - .task(taskHandler -> { - String result = getSomeResult(); - taskHandler.handle(DefaultAsyncResult.succeed(result)); - }) - .task(taskHandler -> { - someAsyncMethodThatTakesAHandler(taskHandler); - }) - .run(result -> { - if (result.failed()) { - handler.handle(DefaultAsyncResult.fail(result)); - return; - } - List resultList = result.result(); - doSomethingWithTheResults(resultList); + private final boolean succeed; + private List results; - handler.handle(DefaultAsyncResult.succeed(resultList)); - }); - } + public SeriesExample(boolean succeed) { + this.succeed = succeed; + } - private String getSomeResult() { - return "Result"; - } + public void seriesExample(AsyncResultHandler> handler) { + Async.series() + .task(taskHandler -> { + String result = getSomeResult(); + taskHandler.handle(DefaultAsyncResult.succeed(result)); + }) + .task(taskHandler -> { + someAsyncMethodThatTakesAHandler(taskHandler); + }) + .run(result -> { + if (result.failed()) { + handler.handle(DefaultAsyncResult.fail(result)); + return; + } + + List resultList = result.result(); + doSomethingWithTheResults(resultList); + + handler.handle(DefaultAsyncResult.succeed(resultList)); + }); + } - private void someAsyncMethodThatTakesAHandler(AsyncResultHandler handler) { - if (!succeed) { - handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); - return; + private String getSomeResult() { + return "Result"; } - handler.handle(DefaultAsyncResult.succeed("Async result")); - } + private void someAsyncMethodThatTakesAHandler(AsyncResultHandler handler) { + if (!succeed) { + handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); + return; + } - private void doSomethingWithTheResults(List results) { - this.results = results; - } + handler.handle(DefaultAsyncResult.succeed("Async result")); + } - public List results() { - return results; - } + private void doSomethingWithTheResults(List results) { + this.results = results; + } + + public List results() { + return results; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/examples/WaterfallExample.java b/src/test/java/org/simondean/vertx/async/unit/examples/WaterfallExample.java index 4eba1fd..3d5c46b 100644 --- a/src/test/java/org/simondean/vertx/async/unit/examples/WaterfallExample.java +++ b/src/test/java/org/simondean/vertx/async/unit/examples/WaterfallExample.java @@ -1,58 +1,58 @@ package org.simondean.vertx.async.unit.examples; +import io.vertx.core.AsyncResultHandler; import org.simondean.vertx.async.Async; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; public class WaterfallExample extends BaseExample { - private final boolean succeed; - private Integer result; - - public WaterfallExample(boolean succeed) { - this.succeed = succeed; - } - - public void waterfallExample(AsyncResultHandler handler) { - Async.waterfall() - .task(taskHandler -> { - String result = getSomeResult(); - taskHandler.handle(DefaultAsyncResult.succeed(result)); - }) - .task((result, taskHandler) -> { - someAsyncMethodThatTakesAResultAndHandler(result, taskHandler); - }) - .run(result -> { - if (result.failed()) { - handler.handle(DefaultAsyncResult.fail(result.cause())); - return; - } - Integer resultValue = result.result(); - doSomethingWithTheResults(resultValue); + private final boolean succeed; + private Integer result; - handler.handle(DefaultAsyncResult.succeed(resultValue)); - }); - } + public WaterfallExample(boolean succeed) { + this.succeed = succeed; + } - private String getSomeResult() { - return "42"; - } + public void waterfallExample(AsyncResultHandler handler) { + Async.waterfall() + .task(taskHandler -> { + String result = getSomeResult(); + taskHandler.handle(DefaultAsyncResult.succeed(result)); + }) + .task((result, taskHandler) -> { + someAsyncMethodThatTakesAResultAndHandler(result, taskHandler); + }) + .run(result -> { + if (result.failed()) { + handler.handle(DefaultAsyncResult.fail(result.cause())); + return; + } + + Integer resultValue = result.result(); + doSomethingWithTheResults(resultValue); + + handler.handle(DefaultAsyncResult.succeed(resultValue)); + }); + } - private void someAsyncMethodThatTakesAResultAndHandler(String result, AsyncResultHandler handler) { - if (!succeed) { - handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); - return; + private String getSomeResult() { + return "42"; } - handler.handle(DefaultAsyncResult.succeed(Integer.parseInt(result))); - } + private void someAsyncMethodThatTakesAResultAndHandler(String result, AsyncResultHandler handler) { + if (!succeed) { + handler.handle(DefaultAsyncResult.fail(new Exception("Fail"))); + return; + } + + handler.handle(DefaultAsyncResult.succeed(Integer.parseInt(result))); + } - private void doSomethingWithTheResults(Integer result) { - this.result = result; - } + private void doSomethingWithTheResults(Integer result) { + this.result = result; + } - public Integer result() { - return result; - } + public Integer result() { + return result; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncFunction.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncFunction.java index 66ca674..7e4a2b6 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncFunction.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncFunction.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async.unit.fakes; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.ArrayList; import java.util.List; diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncSupplier.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncSupplier.java index d7c9d40..a3f19fc 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncSupplier.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeAsyncSupplier.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async.unit.fakes; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; import java.util.function.Consumer; diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncFunction.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncFunction.java index 1d23537..66f6f45 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncFunction.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncFunction.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async.unit.fakes; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; public class FakeErrorThrowingAsyncFunction extends FakeAsyncFunction { private final Error cause; diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncSupplier.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncSupplier.java index 72befa0..0f589a6 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncSupplier.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeErrorThrowingAsyncSupplier.java @@ -1,6 +1,6 @@ package org.simondean.vertx.async.unit.fakes; -import org.vertx.java.core.AsyncResultHandler; +import io.vertx.core.AsyncResultHandler; public class FakeErrorThrowingAsyncSupplier extends FakeAsyncSupplier { private final Error cause; diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncFunction.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncFunction.java index d51610d..c0d06c3 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncFunction.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncFunction.java @@ -1,38 +1,37 @@ package org.simondean.vertx.async.unit.fakes; +import io.vertx.core.AsyncResultHandler; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; public class FakeFailingAsyncFunction extends FakeAsyncFunction { - private final int successCount; - private final R result; - private final Throwable cause; - - public FakeFailingAsyncFunction(Throwable cause) { - this(0, null, cause); - } - - public FakeFailingAsyncFunction(int successCount, R result, Throwable cause) { - this.successCount = successCount; - this.result = result; - this.cause = cause; - } - - @Override - public void accept(T value, AsyncResultHandler handler) { - addConsumedValue(value); - incrementRunCount(); - - if (runCount() > successCount) { - handler.handle(DefaultAsyncResult.fail(cause)); + + private final int successCount; + private final R result; + private final Throwable cause; + + public FakeFailingAsyncFunction(Throwable cause) { + this(0, null, cause); } - else { - handler.handle(DefaultAsyncResult.succeed(result)); + + public FakeFailingAsyncFunction(int successCount, R result, Throwable cause) { + this.successCount = successCount; + this.result = result; + this.cause = cause; } - } - public Throwable cause() { - return cause; - } + @Override + public void accept(T value, AsyncResultHandler handler) { + addConsumedValue(value); + incrementRunCount(); + + if (runCount() > successCount) { + handler.handle(DefaultAsyncResult.fail(cause)); + } else { + handler.handle(DefaultAsyncResult.succeed(result)); + } + } + + public Throwable cause() { + return cause; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncSupplier.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncSupplier.java index 478a818..440f40a 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncSupplier.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeFailingAsyncSupplier.java @@ -1,37 +1,36 @@ package org.simondean.vertx.async.unit.fakes; +import io.vertx.core.AsyncResultHandler; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; public class FakeFailingAsyncSupplier extends FakeAsyncSupplier { - private final int successCount; - private final T result; - private final Throwable cause; - - public FakeFailingAsyncSupplier(Throwable cause) { - this(0, null, cause); - } - - public FakeFailingAsyncSupplier(int successCount, T result, Throwable cause) { - this.successCount = successCount; - this.result = result; - this.cause = cause; - } - - @Override - public void accept(AsyncResultHandler handler) { - incrementRunCount(); - - if (runCount() > successCount) { - handler.handle(DefaultAsyncResult.fail(cause)); + + private final int successCount; + private final T result; + private final Throwable cause; + + public FakeFailingAsyncSupplier(Throwable cause) { + this(0, null, cause); } - else { - handler.handle(DefaultAsyncResult.succeed(result)); + + public FakeFailingAsyncSupplier(int successCount, T result, Throwable cause) { + this.successCount = successCount; + this.result = result; + this.cause = cause; } - } - public Throwable cause() { - return cause; - } + @Override + public void accept(AsyncResultHandler handler) { + incrementRunCount(); + + if (runCount() > successCount) { + handler.handle(DefaultAsyncResult.fail(cause)); + } else { + handler.handle(DefaultAsyncResult.succeed(result)); + } + } + + public Throwable cause() { + return cause; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncFunction.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncFunction.java index 5c4e46e..f33de46 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncFunction.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncFunction.java @@ -1,38 +1,37 @@ package org.simondean.vertx.async.unit.fakes; +import io.vertx.core.AsyncResultHandler; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; public class FakeSuccessfulAsyncFunction extends FakeAsyncFunction { - private final int failureCount; - private final R result; - private final Throwable cause; - - public FakeSuccessfulAsyncFunction(R result) { - this(0, null, result); - } - - public FakeSuccessfulAsyncFunction(int failureCount, Throwable cause, R result) { - this.failureCount = failureCount; - this.result = result; - this.cause = cause; - } - - @Override - public void accept(T value, AsyncResultHandler handler) { - addConsumedValue(value); - incrementRunCount(); - - if (runCount() > failureCount) { - handler.handle(DefaultAsyncResult.succeed(result)); + + private final int failureCount; + private final R result; + private final Throwable cause; + + public FakeSuccessfulAsyncFunction(R result) { + this(0, null, result); } - else { - handler.handle(DefaultAsyncResult.fail(cause)); + + public FakeSuccessfulAsyncFunction(int failureCount, Throwable cause, R result) { + this.failureCount = failureCount; + this.result = result; + this.cause = cause; } - } - public R result() { - return result; - } + @Override + public void accept(T value, AsyncResultHandler handler) { + addConsumedValue(value); + incrementRunCount(); + + if (runCount() > failureCount) { + handler.handle(DefaultAsyncResult.succeed(result)); + } else { + handler.handle(DefaultAsyncResult.fail(cause)); + } + } + + public R result() { + return result; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncSupplier.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncSupplier.java index 62452aa..83aa1bf 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncSupplier.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeSuccessfulAsyncSupplier.java @@ -1,37 +1,36 @@ package org.simondean.vertx.async.unit.fakes; +import io.vertx.core.AsyncResultHandler; import org.simondean.vertx.async.DefaultAsyncResult; -import org.vertx.java.core.AsyncResultHandler; -import org.vertx.java.core.impl.DefaultFutureResult; public class FakeSuccessfulAsyncSupplier extends FakeAsyncSupplier { - private final int failureCount; - private final T result; - private final Throwable cause; - - public FakeSuccessfulAsyncSupplier(T result) { - this(0, null, result); - } - - public FakeSuccessfulAsyncSupplier(int failureCount, Throwable cause, T result) { - this.failureCount = failureCount; - this.result = result; - this.cause = cause; - } - - @Override - public void accept(AsyncResultHandler handler) { - incrementRunCount(); - - if (runCount() > failureCount) { - handler.handle(DefaultAsyncResult.succeed(result)); + + private final int failureCount; + private final T result; + private final Throwable cause; + + public FakeSuccessfulAsyncSupplier(T result) { + this(0, null, result); } - else { - handler.handle(DefaultAsyncResult.fail(cause)); + + public FakeSuccessfulAsyncSupplier(int failureCount, Throwable cause, T result) { + this.failureCount = failureCount; + this.result = result; + this.cause = cause; } - } - public T result() { - return result; - } + @Override + public void accept(AsyncResultHandler handler) { + incrementRunCount(); + + if (runCount() > failureCount) { + handler.handle(DefaultAsyncResult.succeed(result)); + } else { + handler.handle(DefaultAsyncResult.fail(cause)); + } + } + + public T result() { + return result; + } } diff --git a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeVertx.java b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeVertx.java index 206ce64..deafe72 100644 --- a/src/test/java/org/simondean/vertx/async/unit/fakes/FakeVertx.java +++ b/src/test/java/org/simondean/vertx/async/unit/fakes/FakeVertx.java @@ -1,110 +1,232 @@ package org.simondean.vertx.async.unit.fakes; -import org.vertx.java.core.Context; -import org.vertx.java.core.Handler; -import org.vertx.java.core.Vertx; -import org.vertx.java.core.datagram.DatagramSocket; -import org.vertx.java.core.datagram.InternetProtocolFamily; -import org.vertx.java.core.dns.DnsClient; -import org.vertx.java.core.eventbus.EventBus; -import org.vertx.java.core.file.FileSystem; -import org.vertx.java.core.http.HttpClient; -import org.vertx.java.core.http.HttpServer; -import org.vertx.java.core.net.NetClient; -import org.vertx.java.core.net.NetServer; -import org.vertx.java.core.shareddata.SharedData; -import org.vertx.java.core.sockjs.SockJSServer; - -import java.net.InetSocketAddress; +import io.netty.channel.EventLoopGroup; +import io.vertx.core.AsyncResult; +import io.vertx.core.Context; +import io.vertx.core.DeploymentOptions; +import io.vertx.core.Future; +import io.vertx.core.Handler; +import io.vertx.core.TimeoutStream; +import io.vertx.core.Verticle; +import io.vertx.core.Vertx; +import io.vertx.core.datagram.DatagramSocket; +import io.vertx.core.datagram.DatagramSocketOptions; +import io.vertx.core.dns.DnsClient; +import io.vertx.core.eventbus.EventBus; +import io.vertx.core.file.FileSystem; +import io.vertx.core.http.HttpClient; +import io.vertx.core.http.HttpClientOptions; +import io.vertx.core.http.HttpServer; +import io.vertx.core.http.HttpServerOptions; +import io.vertx.core.net.NetClient; +import io.vertx.core.net.NetClientOptions; +import io.vertx.core.net.NetServer; +import io.vertx.core.net.NetServerOptions; +import io.vertx.core.shareddata.SharedData; +import io.vertx.core.spi.VerticleFactory; +import java.util.Set; public class FakeVertx implements Vertx { - @Override - public NetServer createNetServer() { - return null; - } - - @Override - public NetClient createNetClient() { - return null; - } - - @Override - public HttpServer createHttpServer() { - return null; - } - - @Override - public HttpClient createHttpClient() { - return null; - } - - @Override - public DatagramSocket createDatagramSocket(InternetProtocolFamily internetProtocolFamily) { - return null; - } - - @Override - public SockJSServer createSockJSServer(HttpServer httpServer) { - return null; - } - - @Override - public FileSystem fileSystem() { - return null; - } - - @Override - public EventBus eventBus() { - return null; - } - - @Override - public DnsClient createDnsClient(InetSocketAddress... inetSocketAddresses) { - return null; - } - - @Override - public SharedData sharedData() { - return null; - } - - @Override - public long setTimer(long l, Handler handler) { - return 0; - } - - @Override - public long setPeriodic(long l, Handler handler) { - return 0; - } - - @Override - public boolean cancelTimer(long l) { - return false; - } - - @Override - public Context currentContext() { - return null; - } - - @Override - public void runOnContext(Handler handler) { - handler.handle(null); - } - - @Override - public boolean isEventLoop() { - return false; - } - - @Override - public boolean isWorker() { - return false; - } - - @Override - public void stop() { - - } + + @Override + public NetServer createNetServer() { + return null; + } + + @Override + public NetClient createNetClient() { + return null; + } + + @Override + public HttpServer createHttpServer() { + return null; + } + + @Override + public HttpClient createHttpClient() { + return null; + } + + @Override + public FileSystem fileSystem() { + return null; + } + + @Override + public EventBus eventBus() { + return null; + } + + @Override + public SharedData sharedData() { + return null; + } + + @Override + public long setTimer(long l, Handler handler) { + return 0; + } + + @Override + public long setPeriodic(long l, Handler handler) { + return 0; + } + + @Override + public boolean cancelTimer(long l) { + return false; + } + + @Override + public void runOnContext(Handler handler) { + handler.handle(null); + } + + @Override + public Context getOrCreateContext() { + return null; + } + + @Override + public NetServer createNetServer(NetServerOptions options) { + return null; + } + + @Override + public NetClient createNetClient(NetClientOptions options) { + return null; + } + + @Override + public HttpServer createHttpServer(HttpServerOptions options) { + return null; + } + + @Override + public HttpClient createHttpClient(HttpClientOptions options) { + return null; + } + + @Override + public DatagramSocket createDatagramSocket(DatagramSocketOptions options) { + return null; + } + + @Override + public DatagramSocket createDatagramSocket() { + return null; + } + + @Override + public DnsClient createDnsClient(int port, String host) { + return null; + } + + @Override + public TimeoutStream timerStream(long delay) { + return null; + } + + @Override + public TimeoutStream periodicStream(long delay) { + return null; + } + + @Override + public void close() { + } + + @Override + public void close(Handler> completionHandler) { + } + + @Override + public void deployVerticle(Verticle verticle) { + } + + @Override + public void deployVerticle(Verticle verticle, Handler> handler) { + handler.handle(null); + } + + @Override + public void deployVerticle(Verticle verticle, DeploymentOptions options) { + } + + @Override + public void deployVerticle(Verticle verticle, DeploymentOptions options, Handler> handler) { + handler.handle(null); + } + + @Override + public void deployVerticle(String name) { + } + + @Override + public void deployVerticle(String name, Handler> handler) { + handler.handle(null); + } + + @Override + public void deployVerticle(String name, DeploymentOptions options) { + } + + @Override + public void deployVerticle(String name, DeploymentOptions options, Handler> handler) { + handler.handle(null); + } + + @Override + public void undeploy(String deploymentID) { + } + + @Override + public void undeploy(String deploymentID, Handler> handler) { + handler.handle(null); + } + + @Override + public Set deploymentIDs() { + return null; + } + + @Override + public void registerVerticleFactory(VerticleFactory factory) { + } + + @Override + public void unregisterVerticleFactory(VerticleFactory factory) { + } + + @Override + public Set verticleFactories() { + return null; + } + + @Override + public boolean isClustered() { + return false; + } + + @Override + public void executeBlocking(Handler> blockingCodeHandler, boolean ordered, Handler> handler) { + handler.handle(null); + } + + @Override + public void executeBlocking(Handler> blockingCodeHandler, Handler> handler) { + handler.handle(null); + } + + @Override + public EventLoopGroup nettyEventLoopGroup() { + return null; + } + + @Override + public boolean isMetricsEnabled() { + return false; + } + }