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

equal deleted inserted replaced

-:48dec0c13bec
+:df8ae450fce3
 * @param openOptions any options to use when opening/creating the file
 * @return a response body handler
 * @throws IllegalArgumentException if an invalid set of open options
 *          are specified
 * @throws SecurityException If a security manager has been installed
-*          and it denies {@link SecurityManager#checkWrite(String)
+*          and it denies {@linkplain SecurityManager#checkWrite(String)
 *          write access} to the file.
 */
 public static BodyHandler<Path> ofFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
 List<OpenOption> opts = List.of(openOptions);
 * that the {@code BodyHandler} is not shared with untrusted code.
 *
 * @param file the file to store the body in
 * @return a response body handler
 * @throws SecurityException If a security manager has been installed
-*          and it denies {@link SecurityManager#checkWrite(String)
+*          and it denies {@linkplain SecurityManager#checkWrite(String)
 *          write access} to the file.
 */
 public static BodyHandler<Path> ofFile(Path file) {
 return BodyHandlers.ofFile(file, CREATE, WRITE);
 }
 return (responseInfo) -> BodySubscribers.ofByteArrayConsumer(consumer);
 }
 /**
 * Returns a {@code BodyHandler<byte[]>} that returns a
-* {@link BodySubscriber BodySubscriber}&lt;{@code byte[]}&gt; obtained
+* {@link BodySubscriber BodySubscriber}{@code <byte[]>} obtained
 * from {@link BodySubscribers#ofByteArray() BodySubscribers.ofByteArray()}.
 *
 * <p> When the {@code HttpResponse} object is returned, the body has
 * been completely written to the byte array.
 *
 * BodySubscribers.ofPublisher()}.
 *
 * <p> When the {@code HttpResponse} object is returned, the response
 * headers will have been completely read, but the body may not have
 * been fully received yet. The {@link #body()} method returns a
-* {@link Publisher Publisher<List<ByteBuffer>>} from which the body
+* {@link Publisher Publisher}{@code <List<ByteBuffer>>} from which the body
 * response bytes can be obtained as they are received. The publisher
 * can and must be subscribed to only once.
 *
 * @apiNote See {@link BodySubscribers#ofPublisher()} for more
 * information.
 * <p> Entries are added to the given map for each push promise accepted.
 * The entry's key is the push request, and the entry's value is a
 * {@code CompletableFuture} that completes with the response
 * corresponding to the key's push request. A push request is rejected /
 * cancelled if there is already an entry in the map whose key is
-* {@link HttpRequest#equals equal} to it. A push request is
+* {@linkplain HttpRequest#equals equal} to it. A push request is
 * rejected / cancelled if it  does not have the same origin as its
 * initiating request.
 *
 * <p> Entries are added to the given map as soon as practically
 * possible when a push promise is received and accepted. That way code,
 * once passed to the subscriber, are no longer used by the HTTP Client. The
 * subscriber converts the incoming buffers of data to some higher-level
 * Java type {@code T}.
 *
 * <p> The {@link #getBody()} method returns a
-* {@link CompletionStage}&lt;{@code T}&gt; that provides the response body
+* {@link CompletionStage}{@code <T>} that provides the response body
 * object. The {@code CompletionStage} must be obtainable at any time. When
 * it completes depends on the nature of type {@code T}. In many cases,
 * when {@code T} represents the entire body after being consumed then
 * the {@code CompletionStage} completes after the body has been consumed.
 * If  {@code T} is a streaming type, such as {@link java.io.InputStream
 * InputStream}, then it completes before the body has been read, because
 * the calling code uses the {@code InputStream} to consume the data.
 *
 * @apiNote To ensure that all resources associated with the corresponding
 * HTTP exchange are properly released, an implementation of {@code
-* BodySubscriber} should ensure to {@link Flow.Subscription#request
+* BodySubscriber} should ensure to {@linkplain Flow.Subscription#request
 * request} more data until one of {@link #onComplete() onComplete} or
 * {@link #onError(Throwable) onError} are signalled, or {@link
 * Flow.Subscription#request cancel} its {@linkplain
 * #onSubscribe(Flow.Subscription) subscription} if unable or unwilling to
 * do so. Calling {@code cancel} before exhausting the response body data
 * @param openOptions the list of options to open the file with
 * @return a body subscriber
 * @throws IllegalArgumentException if an invalid set of open options
 *          are specified
 * @throws SecurityException if a security manager has been installed
-*          and it denies {@link SecurityManager#checkWrite(String)
+*          and it denies {@linkplain SecurityManager#checkWrite(String)
 *          write access} to the file
 */
 public static BodySubscriber<Path> ofFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
 List<OpenOption> opts = List.of(openOptions);
 * that the {@code BodyHandler} is not shared with untrusted code.
 *
 * @param file the file to store the body in
 * @return a body subscriber
 * @throws SecurityException if a security manager has been installed
-*          and it denies {@link SecurityManager#checkWrite(String)
+*          and it denies {@linkplain SecurityManager#checkWrite(String)
 *          write access} to the file
 */
 public static BodySubscriber<Path> ofFile(Path file) {
 return ofFile(file, CREATE, WRITE);
 }
 return new ResponseSubscribers.HttpResponseInputStream();
 }
 /**
 * Returns a {@code BodySubscriber} which streams the response body as
-* a {@link Stream Stream<String>}, where each string in the stream
+* a {@link Stream Stream}{@code <String>}, where each string in the stream
 * corresponds to a line as defined by {@link BufferedReader#lines()}.
 *
 * <p> The {@link HttpResponse} using this subscriber is available
 * immediately after the response headers have been read, without
 * requiring to wait for the entire body to be processed. The response
 * the underlying HTTP connection to be closed and prevent it
 * from being reused for subsequent operations.
 *
 * @param charset the character set to use when converting bytes to characters
 * @return a body subscriber that streams the response body as a
-*         {@link Stream Stream<String>}.
+*         {@link Stream Stream}{@code <String>}.
 *
 * @see BufferedReader#lines()
 */
 public static BodySubscriber<Stream<String>> ofLines(Charset charset) {
 return ResponseSubscribers.createLineStream(charset);

changeset 51982	df8ae450fce3
parent 51128	f0193a4828ef
child 53508	04dcc65c9d58