Enable to use AsyncInvoker in Rx client

Signed-off-by: Jan Supol <[email protected]>

core-client/src/main/java/org/glassfish/jersey/client/AbstractNonSyncInvoker.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.client;
+
+import org.glassfish.jersey.client.internal.LocalizationMessages;
+
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.SyncInvoker;
+import javax.ws.rs.core.GenericType;
+
+/* package */ abstract class AbstractNonSyncInvoker<T> {
+    private final SyncInvoker invocationBuilder;
+
+    protected AbstractNonSyncInvoker(SyncInvoker invocationBuilder) {
+        if (invocationBuilder == null) {
+            throw new IllegalArgumentException(LocalizationMessages.NULL_INVOCATION_BUILDER());
+        }
+        this.invocationBuilder = invocationBuilder;
+    }
+
+    /**
+     * Return invocation builder this reactive invoker was initialized with.
+     *
+     * @return non-null invocation builder.
+     */
+    protected SyncInvoker getSyncInvoker() {
+        return invocationBuilder;
+    }
+
+    public T get() {
+        return method("GET");
+    }
+
+    public <R> T get(final Class<R> responseType) {
+        return method("GET", responseType);
+    }
+
+    public <R> T get(final GenericType<R> responseType) {
+        return method("GET", responseType);
+    }
+
+    public T put(final Entity<?> entity) {
+        return method("PUT", entity);
+    }
+
+    public <R> T put(final Entity<?> entity, final Class<R> clazz) {
+        return method("PUT", entity, clazz);
+    }
+
+    public <R> T put(final Entity<?> entity, final GenericType<R> type) {
+        return method("PUT", entity, type);
+    }
+
+    public T post(final Entity<?> entity) {
+        return method("POST", entity);
+    }
+
+    public <R> T post(final Entity<?> entity, final Class<R> clazz) {
+        return method("POST", entity, clazz);
+    }
+
+    public <R> T post(final Entity<?> entity, final GenericType<R> type) {
+        return method("POST", entity, type);
+    }
+
+    public T delete() {
+        return method("DELETE");
+    }
+
+    public <R> T delete(final Class<R> responseType) {
+        return method("DELETE", responseType);
+    }
+
+    public <R> T delete(final GenericType<R> responseType) {
+        return method("DELETE", responseType);
+    }
+
+    public T head() {
+        return method("HEAD");
+    }
+
+    public T options() {
+        return method("OPTIONS");
+    }
+
+    public <R> T options(final Class<R> responseType) {
+        return method("OPTIONS", responseType);
+    }
+
+    public <R> T options(final GenericType<R> responseType) {
+        return method("OPTIONS", responseType);
+    }
+
+    public T trace() {
+        return method("TRACE");
+    }
+
+    public <R> T trace(final Class<R> responseType) {
+        return method("TRACE", responseType);
+    }
+
+    public <R> T trace(final GenericType<R> responseType) {
+        return method("TRACE", responseType);
+    }
+
+    public abstract T method(final String name);
+
+    public abstract <R> T method(final String name, final Class<R> responseType);
+
+    public abstract <R> T method(final String name, final GenericType<R> responseType);
+
+    public abstract T method(final String name, final Entity<?> entity);
+
+    public abstract <R> T method(final String name, final Entity<?> entity, final Class<R> responseType);
+
+    public abstract <R> T method(final String name, final Entity<?> entity, final GenericType<R> responseType);
+}

core-client/src/main/java/org/glassfish/jersey/client/AbstractRxInvoker.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2018 Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2019 Oracle and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -25,7 +25,7 @@
 import javax.ws.rs.core.Response;
 
 /**
- * Default implementation of {@link javax.ws.rs.client.rx.RxInvoker reactive invoker}. Extensions of this class are
+ * Default implementation of {@link javax.ws.rs.client.RxInvoker reactive invoker}. Extensions of this class are
  * supposed to implement {@link #method(String, Entity, Class)} and
  * {@link #method(String, Entity, GenericType)} methods to which implementations of the rest
  * of the methods from the contract delegate to.
@@ -35,29 +35,15 @@
  * @author Michal Gajdos
  * @since 2.26
  */
-public abstract class AbstractRxInvoker<T> implements RxInvoker<T> {
+public abstract class AbstractRxInvoker<T> extends AbstractNonSyncInvoker<T> implements RxInvoker<T> {
 
-    private final SyncInvoker syncInvoker;
     private final ExecutorService executorService;
 
     public AbstractRxInvoker(final SyncInvoker syncInvoker, final ExecutorService executor) {
-        if (syncInvoker == null) {
-            throw new IllegalArgumentException("Invocation builder cannot be null.");
-        }
-
-        this.syncInvoker = syncInvoker;
+        super(syncInvoker);
         this.executorService = executor;
     }
 
-    /**
-     * Return invocation builder this reactive invoker was initialized with.
-     *
-     * @return non-null invocation builder.
-     */
-    protected SyncInvoker getSyncInvoker() {
-        return syncInvoker;
-    }
-
     /**
      * Return executorService service this reactive invoker was initialized with.
      *
@@ -67,101 +53,6 @@ protected ExecutorService getExecutorService() {
         return executorService;
     }
 
-    @Override
-    public T get() {
-        return method("GET");
-    }
-
-    @Override
-    public <R> T get(final Class<R> responseType) {
-        return method("GET", responseType);
-    }
-
-    @Override
-    public <R> T get(final GenericType<R> responseType) {
-        return method("GET", responseType);
-    }
-
-    @Override
-    public T put(final Entity<?> entity) {
-        return method("PUT", entity);
-    }
-
-    @Override
-    public <R> T put(final Entity<?> entity, final Class<R> clazz) {
-        return method("PUT", entity, clazz);
-    }
-
-    @Override
-    public <R> T put(final Entity<?> entity, final GenericType<R> type) {
-        return method("PUT", entity, type);
-    }
-
-    @Override
-    public T post(final Entity<?> entity) {
-        return method("POST", entity);
-    }
-
-    @Override
-    public <R> T post(final Entity<?> entity, final Class<R> clazz) {
-        return method("POST", entity, clazz);
-    }
-
-    @Override
-    public <R> T post(final Entity<?> entity, final GenericType<R> type) {
-        return method("POST", entity, type);
-    }
-
-    @Override
-    public T delete() {
-        return method("DELETE");
-    }
-
-    @Override
-    public <R> T delete(final Class<R> responseType) {
-        return method("DELETE", responseType);
-    }
-
-    @Override
-    public <R> T delete(final GenericType<R> responseType) {
-        return method("DELETE", responseType);
-    }
-
-    @Override
-    public T head() {
-        return method("HEAD");
-    }
-
-    @Override
-    public T options() {
-        return method("OPTIONS");
-    }
-
-    @Override
-    public <R> T options(final Class<R> responseType) {
-        return method("OPTIONS", responseType);
-    }
-
-    @Override
-    public <R> T options(final GenericType<R> responseType) {
-        return method("OPTIONS", responseType);
-    }
-
-    @Override
-    public T trace() {
-        return method("TRACE");
-    }
-
-    @Override
-    public <R> T trace(final Class<R> responseType) {
-        return method("TRACE", responseType);
-    }
-
-    @Override
-    public <R> T trace(final GenericType<R> responseType) {
-        return method("TRACE", responseType);
-    }
-
     @Override
     public T method(final String name) {
         return method(name, Response.class);
@@ -181,4 +72,5 @@ public <R> T method(final String name, final GenericType<R> responseType) {
     public T method(final String name, final Entity<?> entity) {
         return method(name, entity, Response.class);
     }
+
 }

core-client/src/main/java/org/glassfish/jersey/client/CompletableFutureAsyncInvoker.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2019 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package org.glassfish.jersey.client;
+
+import javax.ws.rs.client.AsyncInvoker;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.InvocationCallback;
+import javax.ws.rs.core.GenericType;
+import javax.ws.rs.core.Response;
+import java.util.concurrent.CompletableFuture;
+
+/*package*/ abstract class CompletableFutureAsyncInvoker
+                extends AbstractNonSyncInvoker<CompletableFuture> implements AsyncInvoker {
+
+    protected CompletableFutureAsyncInvoker(JerseyInvocation.Builder invocationBuilder) {
+        super(invocationBuilder);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> get(InvocationCallback<T> callback) {
+        return method("GET", callback);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> put(Entity<?> entity, InvocationCallback<T> callback) {
+        return method("PUT", callback);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> post(Entity<?> entity, InvocationCallback<T> callback) {
+        return method("POST", callback);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> delete(InvocationCallback<T> callback) {
+        return method("DELETE", callback);
+    }
+
+    @Override
+    public CompletableFuture<Response> head(InvocationCallback<Response> callback) {
+        return method("HEAD", callback);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> options(InvocationCallback<T> callback) {
+        return method("OPTIONS", callback);
+    }
+
+    @Override
+    public <T> CompletableFuture<T> trace(InvocationCallback<T> callback) {
+        return method("TRACE", callback);
+    }
+
+    @Override
+    public abstract <T> CompletableFuture<T> method(String name, InvocationCallback<T> callback);
+
+    @Override
+    public abstract <T> CompletableFuture<T> method(String name, Entity<?> entity, InvocationCallback<T> callback);
+
+    @Override
+    public abstract <R> CompletableFuture method(String name, Entity<?> entity, Class<R> responseType);
+
+    @Override
+    public abstract <R> CompletableFuture method(String name, Entity<?> entity, GenericType<R> responseType);
+}