jdk-sandbox: comparison src/jdk.incubator.httpclient/share/classes/jdk/incubator/http/HttpResponse.java

equal deleted inserted replaced

-:8898d000aec5
+:5cb7c3fbddcd
 */
 public abstract int statusCode();
 /**
 * Returns the {@link HttpRequest} corresponding to this response.
-* <p>
+*
-* This may not be the original request provided by the caller,
+* <p> This may not be the original request provided by the caller,
 * for example, if that request was redirected.
 *
 * @see #previousResponse()
 *
 * @return the request
 */
 public abstract HttpRequest request();
 /**
-* Returns an {@code Optional} containing the previous intermediate response if
+* Returns an {@code Optional} containing the previous intermediate response
-* one was received. An intermediate response is one that is received
+* if one was received. An intermediate response is one that is received
 * as a result of redirection or authentication. If no previous response
 * was received then an empty {@code Optional} is returned.
 *
 * @return an Optional containing the HttpResponse, if any.
 */
 /**
 * Returns the body. Depending on the type of {@code T}, the returned body
 * may represent the body after it was read (such as {@code byte[]}, or
 * {@code String}, or {@code Path}) or it may represent an object with
 * which the body is read, such as an {@link java.io.InputStream}.
-* <p>
+*
-* If this {@code HttpResponse} was returned from an invocation of
+* <p> If this {@code HttpResponse} was returned from an invocation of
 * {@link #previousResponse()} then this method returns {@code null}
 *
 * @return the body
 */
 public abstract T body();
 *
 * @since 9
 */
 public interface MultiSubscriber<U,T> {
 /**
-* Called for the main request from the user. This {@link HttpRequest} parameter
+* Called for the main request from the user. This {@link HttpRequest}
-* is the request that was supplied to {@link HttpClient#sendAsync(HttpRequest, MultiSubscriber)}. The
+* parameter is the request that was supplied to {@link
-* implementation must return an {@link BodyHandler} for
+* HttpClient#sendAsync(HttpRequest, MultiSubscriber)}. The
-* the response body.
+* implementation must return an {@link BodyHandler} for the response
+* body.
 *
 * @param request the request
 *
 * @return an optional body handler
 */
 BodyHandler<T> onRequest(HttpRequest request);
 /**
-* Called for each push promise that is received. The {@link HttpRequest} parameter
+* Called for each push promise that is received. The {@link HttpRequest}
-* represents the PUSH_PROMISE. The implementation must return an {@code Optional} of
+* parameter represents the PUSH_PROMISE. The implementation must return
-* {@link BodyHandler} for the response body. Different handlers (of the same type) can be returned
+* an {@code Optional} of {@link BodyHandler} for the response body.
-* for different pushes within the same multi send. If no handler
+* Different handlers (of the same type) can be returned for different
-* (an empty {@code Optional}) is returned, then the push will be canceled.
+* pushes within the same multi send. If no handler (an empty {@code
-* If required, the {@code CompletableFuture<Void>} supplied to the {@code onFinalPushPromise} parameter
+* Optional}) is returned, then the push will be canceled. If required,
-* of {@link #completion(CompletableFuture, CompletableFuture)} can be used to determine
+* the {@code CompletableFuture<Void>} supplied to the {@code
-* when the final PUSH_PROMISE is received.
+* onFinalPushPromise} parameter of {@link
+* #completion(CompletableFuture, CompletableFuture)} can be used to
+* determine when the final PUSH_PROMISE is received.
 *
 * @param pushPromise the push promise
 *
 * @return an optional body handler
 */
 /**
 * Returns a {@link java.util.concurrent.CompletableFuture}{@code <U>}
 * which completes when the aggregate result object itself is available.
 * It is expected that the returned {@code CompletableFuture} will depend
-* on one of the given {@code CompletableFuture<Void}s which themselves complete
+* on one of the given {@code CompletableFuture<Void}s which themselves
-* after all individual responses associated with the multi response
+* complete after all individual responses associated with the multi
-* have completed, or after all push promises have been received.
+* response have completed, or after all push promises have been received.
 * This method is called after {@link #onRequest(HttpRequest)} but
 * before any other methods.
 *
 * @implNote Implementations might follow the pattern shown below
 * <pre>
 *
 * <p> See {@link #asMap(Function, boolean)} for a code sample of using
 * this interface.
 *
 * @param <V> the body type used for all responses
-* @param reqHandler a function invoked for the user's request and each push promise
+* @param reqHandler a function invoked for the user's request and each
+*                   push promise
 * @param completion {@code true} if the aggregate CompletableFuture
 *                   completes after all responses have been received,
 *                   or {@code false} after all push promises received
 *
 * @return a MultiSubscriber
 */
 public static <V> MultiSubscriber<MultiMapResult<V>,V> asMap(
 Function<HttpRequest, Optional<HttpResponse.BodyHandler<V>>> reqHandler,
 boolean completion) {
-return new MultiSubscriberImpl<V>(reqHandler.andThen(optv -> optv.get()), reqHandler, completion);
+return new MultiSubscriberImpl<V>(reqHandler.andThen(optv -> optv.get()),
+reqHandler,
+completion);
 }
 /**
 * Returns a general purpose handler for multi responses. This is a
 * convenience method which invokes {@link #asMap(Function,boolean)
 * headers, and every push that the server sends is accepted. When the
 * join() call returns, all {@code HttpResponse}s and their associated
 * body objects are available.
 *
 * @param <V> the body type used for all responses
-* @param reqHandler a function invoked for each push promise and the main request
+* @param reqHandler a function invoked for each push promise and the
+*                   main request
 * @return a MultiSubscriber
 */
 public static <V> MultiSubscriber<MultiMapResult<V>,V> asMap(
 Function<HttpRequest, Optional<HttpResponse.BodyHandler<V>>> reqHandler) {

branch	http-client-branch
changeset 55855	5cb7c3fbddcd
parent 55852	32f6aefec11e
child 55858	cd5eeec735fb