Apply spotless formatting

Author: Subramanya-Veeregowda

sdks/java/core/src/main/java/org/apache/beam/sdk/coders/Coder.java

@@ -54,7 +54,8 @@
  * @param <T> the type of values being encoded and decoded
  */
 /**
- * <p><b>Example usage:</b>
+ * <b>Example usage:</b>
+ *
  * <pre>{@code
  * Coder<String> coder = StringUtf8Coder.of();
  *
@@ -67,9 +68,8 @@
  * }
  * }</pre>
  *
- * <p>When multiple values are encoded into the same stream, coders must ensure
- * that each value can be correctly decoded. This is typically done by encoding
- * length or delimiter information.
+ * <p>When multiple values are encoded into the same stream, coders must ensure that each value can
+ * be correctly decoded. This is typically done by encoding length or delimiter information.
  */
 public abstract class Coder<T> implements Serializable {
   /**
@@ -82,32 +82,32 @@ public abstract class Coder<T> implements Serializable {
   @Deprecated
   public static class Context {
     /**
-    * The outer context indicates that the value being encoded or decoded
-    * occupies the entire remaining stream.
-    *
-    * <p>In this context, the coder does not need to include length or boundary
-    * information, since the value extends to the end of the stream.
-    *
-    * <p><b>Example:</b> Encoding a single standalone value.
-    */
+     * The outer context indicates that the value being encoded or decoded occupies the entire
+     * remaining stream.
+     *
+     * <p>In this context, the coder does not need to include length or boundary information, since
+     * the value extends to the end of the stream.
+     *
+     * <p><b>Example:</b> Encoding a single standalone value.
+     */
     public static final Context OUTER = new Context(true);
     /**
-    * The nested context indicates that the value being encoded or decoded
-    * is part of a larger structure or stream containing multiple values.
-    *
-    * <p>In this context, the coder must include enough information (such as
-    * length or delimiters) to allow correct decoding of individual elements.
-    *
-    * <p><b>Example:</b> Encoding elements inside a collection or record.
-    */
+     * The nested context indicates that the value being encoded or decoded is part of a larger
+     * structure or stream containing multiple values.
+     *
+     * <p>In this context, the coder must include enough information (such as length or delimiters)
+     * to allow correct decoding of individual elements.
+     *
+     * <p><b>Example:</b> Encoding elements inside a collection or record.
+     */
     public static final Context NESTED = new Context(false);
 
     /**
-    * Indicates whether the encoded/decoded value consumes the entire remaining stream.
-    *
-    * <p>If true, no additional length information is required.
-    * If false, the coder must encode boundaries to allow correct decoding.
-    */    
+     * Indicates whether the encoded/decoded value consumes the entire remaining stream.
+     *
+     * <p>If true, no additional length information is required. If false, the coder must encode
+     * boundaries to allow correct decoding.
+     */
     public final boolean isWholeStream;
 
     public Context(boolean isWholeStream) {
@@ -144,11 +144,12 @@ public String toString() {
    * be encoded next to each other on the output stream, each coder should encode information to
    * know how many bytes to read when decoding. A common approach is to prefix the encoding with the
    * element's encoded length.
-   * <p>The behavior of encoding depends on the {@link Context} in which it is used.
-   * When using {@link Context#OUTER}, the encoded value may consume the entire remaining stream,
-   * so no additional length information is required. In contrast, when using {@link Context#NESTED},
-   * the encoded value is part of a larger structure, and the coder must include sufficient
-   * boundary information (such as length prefixes) to allow correct decoding of individual elements.
+   *
+   * <p>The behavior of encoding depends on the {@link Context} in which it is used. When using
+   * {@link Context#OUTER}, the encoded value may consume the entire remaining stream, so no
+   * additional length information is required. In contrast, when using {@link Context#NESTED}, the
+   * encoded value is part of a larger structure, and the coder must include sufficient boundary
+   * information (such as length prefixes) to allow correct decoding of individual elements.
    */
   public abstract void encode(T value, OutputStream outStream) throws CoderException, IOException;
 
@@ -172,10 +173,10 @@ public void encode(T value, OutputStream outStream, Context context)
    * how many bytes to read for each element. This is typically achieved by encoding length or
    * delimiter information during encoding.
    *
-   * <p>The behavior of decoding depends on the {@link Context} in which it is used.
-   * When decoding in {@link Context#OUTER}, the value is expected to consume the entire remaining
-   * stream. In {@link Context#NESTED}, the value is part of a larger structure, so the coder must
-   * rely on encoded boundaries (such as length prefixes) to correctly extract individual elements.
+   * <p>The behavior of decoding depends on the {@link Context} in which it is used. When decoding
+   * in {@link Context#OUTER}, the value is expected to consume the entire remaining stream. In
+   * {@link Context#NESTED}, the value is part of a larger structure, so the coder must rely on
+   * encoded boundaries (such as length prefixes) to correctly extract individual elements.
    *
    * @throws IOException if reading from the {@code InputStream} fails for some reason
    * @throws CoderException if the value could not be decoded for some reason