jdk-sandbox: comparison jdk/src/java.base/share/classes/java/nio/charset/Charset-X-Coder.java.template

equal deleted inserted replaced

-:bb38b4bc2063
+:394ab6a6658d
 *
 *   <li><p> Reset the $coder$ via the {@link #reset reset} method, unless it
 *   has not been used before; </p></li>
 *
 *   <li><p> Invoke the {@link #$code$ $code$} method zero or more times, as
-*   long as additional input may be available, passing <tt>false</tt> for the
+*   long as additional input may be available, passing {@code false} for the
-*   <tt>endOfInput</tt> argument and filling the input buffer and flushing the
+*   {@code endOfInput} argument and filling the input buffer and flushing the
 *   output buffer between invocations; </p></li>
 *
 *   <li><p> Invoke the {@link #$code$ $code$} method one final time, passing
-*   <tt>true</tt> for the <tt>endOfInput</tt> argument; and then </p></li>
+*   {@code true} for the {@code endOfInput} argument; and then </p></li>
 *
 *   <li><p> Invoke the {@link #flush flush} method so that the $coder$ can
 *   flush any internal state to the output buffer. </p></li>
 *
 * </ol>
 * @param  max$ItypesPerOtype$
 *         A positive float value indicating the maximum number of
 *         $otype$s that will be produced for each input $itype$
 *
 * @param  replacement
-*         The initial replacement; must not be <tt>null</tt>, must have
+*         The initial replacement; must not be {@code null}, must have
 *         non-zero length, must not be longer than max$ItypesPerOtype$,
 *         and must be {@linkplain #isLegalReplacement legal}
 *
 * @throws  IllegalArgumentException
 *          If the preconditions on the parameters do not hold
 /**
 * Returns this $coder$'s replacement value.
 *
 * @return  This $coder$'s current replacement,
-*          which is never <tt>null</tt> and is never empty
+*          which is never {@code null} and is never empty
 */
 public final $replType$ replacement() {
 #if[decoder]
 return replacement;
 #end[decoder]
 * <p> This method invokes the {@link #implReplaceWith implReplaceWith}
 * method, passing the new replacement, after checking that the new
 * replacement is acceptable.  </p>
 *
 * @param  newReplacement  The new replacement; must not be
-*         <tt>null</tt>, must have non-zero length,
+*         {@code null}, must have non-zero length,
 #if[decoder]
 *         and must not be longer than the value returned by the
 *         {@link #max$ItypesPerOtype$() max$ItypesPerOtype$} method
 #end[decoder]
 #if[encoder]
 * <p> The default implementation of this method is not very efficient; it
 * should generally be overridden to improve performance.  </p>
 *
 * @param  repl  The byte array to be tested
 *
-* @return  <tt>true</tt> if, and only if, the given byte array
+* @return  {@code true} if, and only if, the given byte array
 *          is a legal replacement value for this encoder
 */
 public boolean isLegalReplacement(byte[] repl) {
 WeakReference<CharsetDecoder> wr = cachedDecoder;
 CharsetDecoder dec = null;
 #end[encoder]
 /**
 * Returns this $coder$'s current action for malformed-input errors.
 *
-* @return The current malformed-input action, which is never <tt>null</tt>
+* @return The current malformed-input action, which is never {@code null}
 */
 public CodingErrorAction malformedInputAction() {
 return malformedInputAction;
 }
 * Changes this $coder$'s action for malformed-input errors.
 *
 * <p> This method invokes the {@link #implOnMalformedInput
 * implOnMalformedInput} method, passing the new action.  </p>
 *
-* @param  newAction  The new action; must not be <tt>null</tt>
+* @param  newAction  The new action; must not be {@code null}
 *
 * @return  This $coder$
 *
 * @throws IllegalArgumentException
 *         If the precondition on the parameter does not hold
 /**
 * Returns this $coder$'s current action for unmappable-character errors.
 *
 * @return The current unmappable-character action, which is never
-*         <tt>null</tt>
+*         {@code null}
 */
 public CodingErrorAction unmappableCharacterAction() {
 return unmappableCharacterAction;
 }
 * Changes this $coder$'s action for unmappable-character errors.
 *
 * <p> This method invokes the {@link #implOnUnmappableCharacter
 * implOnUnmappableCharacter} method, passing the new action.  </p>
 *
-* @param  newAction  The new action; must not be <tt>null</tt>
+* @param  newAction  The new action; must not be {@code null}
 *
 * @return  This $coder$
 *
 * @throws IllegalArgumentException
 *         If the precondition on the parameter does not hold
 *
 * In any case, if this method is to be reinvoked in the same $coding$
 * operation then care should be taken to preserve any $itype$s remaining
 * in the input buffer so that they are available to the next invocation.
 *
-* <p> The <tt>endOfInput</tt> parameter advises this method as to whether
+* <p> The {@code endOfInput} parameter advises this method as to whether
 * the invoker can provide further input beyond that contained in the given
 * input buffer.  If there is a possibility of providing additional input
-* then the invoker should pass <tt>false</tt> for this parameter; if there
+* then the invoker should pass {@code false} for this parameter; if there
 * is no possibility of providing further input then the invoker should
-* pass <tt>true</tt>.  It is not erroneous, and in fact it is quite
+* pass {@code true}.  It is not erroneous, and in fact it is quite
-* common, to pass <tt>false</tt> in one invocation and later discover that
+* common, to pass {@code false} in one invocation and later discover that
 * no further input was actually available.  It is critical, however, that
 * the final invocation of this method in a sequence of invocations always
-* pass <tt>true</tt> so that any remaining un$code$d input will be treated
+* pass {@code true} so that any remaining un$code$d input will be treated
 * as being malformed.
 *
 * <p> This method works by invoking the {@link #$code$Loop $code$Loop}
 * method, interpreting its results, handling error conditions, and
 * reinvoking it as necessary.  </p>
 *
 * @param  out
 *         The output $otype$ buffer
 *
 * @param  endOfInput
-*         <tt>true</tt> if, and only if, the invoker can provide no
+*         {@code true} if, and only if, the invoker can provide no
 *         additional input $itype$s beyond those in the given buffer
 *
 * @return  A coder-result object describing the reason for termination
 *
 * @throws  IllegalStateException
 *          If $a$ $coding$ operation is already in progress and the previous
 *          step was an invocation neither of the {@link #reset reset}
-*          method, nor of this method with a value of <tt>false</tt> for
+*          method, nor of this method with a value of {@code false} for
-*          the <tt>endOfInput</tt> parameter, nor of this method with a
+*          the {@code endOfInput} parameter, nor of this method with a
-*          value of <tt>true</tt> for the <tt>endOfInput</tt> parameter
+*          value of {@code true} for the {@code endOfInput} parameter
 *          but a return value indicating an incomplete $coding$ operation
 *
 * @throws  CoderMalfunctionError
 *          If an invocation of the $code$Loop method threw
 *          an unexpected exception
 * @throws  IllegalStateException
 *          If the previous step of the current $coding$ operation was an
 *          invocation neither of the {@link #flush flush} method nor of
 *          the three-argument {@link
 *          #$code$($Itype$Buffer,$Otype$Buffer,boolean) $code$} method
-*          with a value of <tt>true</tt> for the <tt>endOfInput</tt>
+*          with a value of {@code true} for the {@code endOfInput}
 *          parameter
 */
 public final CoderResult flush($Otype$Buffer out) {
 if (state == ST_END) {
 CoderResult cr = implFlush(out);
 /**
 * Tells whether or not this decoder implements an auto-detecting charset.
 *
 * <p> The default implementation of this method always returns
-* <tt>false</tt>; it should be overridden by auto-detecting decoders to
+* {@code false}; it should be overridden by auto-detecting decoders to
-* return <tt>true</tt>.  </p>
+* return {@code true}.  </p>
 *
-* @return  <tt>true</tt> if, and only if, this decoder implements an
+* @return  {@code true} if, and only if, this decoder implements an
 *          auto-detecting charset
 */
 public boolean isAutoDetecting() {
 return false;
 }
 * Tells whether or not this decoder has yet detected a
 * charset&nbsp;&nbsp;<i>(optional operation)</i>.
 *
 * <p> If this decoder implements an auto-detecting charset then at a
 * single point during a decoding operation this method may start returning
-* <tt>true</tt> to indicate that a specific charset has been detected in
+* {@code true} to indicate that a specific charset has been detected in
 * the input byte sequence.  Once this occurs, the {@link #detectedCharset
 * detectedCharset} method may be invoked to retrieve the detected charset.
 *
-* <p> That this method returns <tt>false</tt> does not imply that no bytes
+* <p> That this method returns {@code false} does not imply that no bytes
 * have yet been decoded.  Some auto-detecting decoders are capable of
 * decoding some, or even all, of an input byte sequence without fixing on
 * a particular charset.
 *
 * <p> The default implementation of this method always throws an {@link
 * UnsupportedOperationException}; it should be overridden by
-* auto-detecting decoders to return <tt>true</tt> once the input charset
+* auto-detecting decoders to return {@code true} once the input charset
 * has been determined.  </p>
 *
-* @return  <tt>true</tt> if, and only if, this decoder has detected a
+* @return  {@code true} if, and only if, this decoder has detected a
 *          specific charset
 *
 * @throws  UnsupportedOperationException
 *          If this decoder does not implement an auto-detecting charset
 */
 * <p> The default implementation of this method always throws an {@link
 * UnsupportedOperationException}; it should be overridden by
 * auto-detecting decoders to return the appropriate value.  </p>
 *
 * @return  The charset detected by this auto-detecting decoder,
-*          or <tt>null</tt> if the charset has not yet been determined
+*          or {@code null} if the charset has not yet been determined
 *
 * @throws  IllegalStateException
 *          If insufficient bytes have been read to determine a charset
 *
 * @throws  UnsupportedOperationException
 }
 /**
 * Tells whether or not this encoder can encode the given character.
 *
-* <p> This method returns <tt>false</tt> if the given character is a
+* <p> This method returns {@code false} if the given character is a
 * surrogate character; such characters can be interpreted only when they
 * are members of a pair consisting of a high surrogate followed by a low
 * surrogate.  The {@link #canEncode(java.lang.CharSequence)
 * canEncode(CharSequence)} method may be used to test whether or not a
 * character sequence can be encoded.
 * should generally be overridden to improve performance.  </p>
 *
 * @param   c
 *          The given character
 *
-* @return  <tt>true</tt> if, and only if, this encoder can encode
+* @return  {@code true} if, and only if, this encoder can encode
 *          the given character
 *
 * @throws  IllegalStateException
 *          If $a$ $coding$ operation is already in progress
 */
 /**
 * Tells whether or not this encoder can encode the given character
 * sequence.
 *
-* <p> If this method returns <tt>false</tt> for a particular character
+* <p> If this method returns {@code false} for a particular character
 * sequence then more information about why the sequence cannot be encoded
 * may be obtained by performing a full <a href="#steps">encoding
 * operation</a>.
 *
 * <p> This method may modify this encoder's state; it should therefore not
 * should generally be overridden to improve performance.  </p>
 *
 * @param   cs
 *          The given character sequence
 *
-* @return  <tt>true</tt> if, and only if, this encoder can encode
+* @return  {@code true} if, and only if, this encoder can encode
 *          the given character without throwing any exceptions and without
 *          performing any replacements
 *
 * @throws  IllegalStateException
 *          If $a$ $coding$ operation is already in progress

changeset 32143	394ab6a6658d
parent 29367	eaa2bfc500e8
child 44851	3439a92526a0