Add BaseNCodec.AbstractBuilder.setDecodeTable(byte[]) and refactor

subclasses

Author: garydgregory

src/changes/changes.xml

@@ -54,6 +54,7 @@ The <action> type attribute can be add,update,fix,remove.
       <action type="add" dev="ggregory" due-to="Gary Gregory">Add builders to org.apache.commons.codec.digest streams and deprecate some old constructors.</action>
       <action type="add" dev="ggregory" due-to="Gary Gregory">Add builder to Base16 streams and deprecate some old constructors.</action>
       <action type="add" dev="ggregory" due-to="Gary Gregory">Add support for SHAKE128-256 and SHAKE256-512 to `DigestUtils` and `MessageDigestAlgorithms` on Java 25 and up.</action>
+      <action type="add" dev="ggregory" due-to="Gary Gregory">Add BaseNCodec.AbstractBuilder.setDecodeTable(byte[]) and refactor subclasses.</action>
       <!-- UPDATE -->
       <action type="update" dev="ggregory" due-to="Gary Gregory, Dependabot">Bump org.apache.commons:commons-parent from 85 to 89.</action>
       <action type="update" dev="ggregory" due-to="Gary Gregory">[test] Bump org.apache.commons:commons-lang3 from 3.18.0 to 3.19.0.</action>

src/main/java/org/apache/commons/codec/binary/Base16.java

@@ -65,6 +65,8 @@ public static class Builder extends AbstractBuilder<Base16, Builder> {
          */
         public Builder() {
             super(null);
+            setDecodeTable(UPPER_CASE_DECODE_TABLE);
+            setEncodeTable(UPPER_CASE_ENCODE_TABLE);
             setEncodedBlockSize(BYTES_PER_ENCODED_BLOCK);
             setUnencodedBlockSize(BYTES_PER_UNENCODED_BLOCK);
             setLineLength(0);
@@ -76,6 +78,12 @@ public Base16 get() {
             return new Base16(this);
         }
 
+        @Override
+        public Builder setEncodeTable(byte... encodeTable) {
+            super.setDecodeTableRaw(Arrays.equals(encodeTable, LOWER_CASE_ENCODE_TABLE) ? LOWER_CASE_DECODE_TABLE : UPPER_CASE_DECODE_TABLE);
+            return super.setEncodeTable(encodeTable);
+        }
+
         /**
          * Sets whether to use the the lower-case Base16 alphabet.
          *
@@ -151,11 +159,6 @@ public static Builder builder() {
         return new Builder();
     }
 
-    /**
-     * Decode table to use.
-     */
-    private final byte[] decodeTable;
-
     /**
      * Constructs a Base16 codec used for decoding and encoding.
      */
@@ -188,7 +191,6 @@ public Base16(final boolean lowerCase, final CodecPolicy decodingPolicy) {
 
     private Base16(final Builder builder) {
         super(builder);
-        this.decodeTable = Arrays.equals(encodeTable, LOWER_CASE_ENCODE_TABLE) ? LOWER_CASE_DECODE_TABLE : UPPER_CASE_DECODE_TABLE;
     }
 
     @Override

src/main/java/org/apache/commons/codec/binary/Base32.java

@@ -18,7 +18,6 @@
 package org.apache.commons.codec.binary;
 
 import java.util.Arrays;
-import java.util.Objects;
 
 import org.apache.commons.codec.CodecPolicy;
 
@@ -86,6 +85,8 @@ public static class Builder extends AbstractBuilder<Base32, Builder> {
          */
         public Builder() {
             super(ENCODE_TABLE);
+            setDecodeTableRaw(DECODE_TABLE);
+            setEncodeTableRaw(ENCODE_TABLE);
             setEncodedBlockSize(BYTES_PER_ENCODED_BLOCK);
             setUnencodedBlockSize(BYTES_PER_UNENCODED_BLOCK);
         }
@@ -95,6 +96,12 @@ public Base32 get() {
             return new Base32(this);
         }
 
+        @Override
+        public Builder setEncodeTable(byte... encodeTable) {
+            super.setDecodeTableRaw(Arrays.equals(encodeTable, HEX_ENCODE_TABLE) ? HEX_DECODE_TABLE : DECODE_TABLE);
+            return super.setEncodeTable(encodeTable);
+        }
+
         /**
          * Sets the decode table to use Base32 hexadecimal if {@code true}, otherwise use the Base32 alphabet.
          * <p>
@@ -269,11 +276,6 @@ private static byte[] encodeTable(final boolean useHex) {
         return useHex ? HEX_ENCODE_TABLE : ENCODE_TABLE;
     }
 
-    /**
-     * Decode table to use.
-     */
-    private final byte[] decodeTable;
-
     /**
      * Convenience variable to help us determine when our buffer is going to run out of room and needs resizing. {@code encodeSize = {@link
      * #BYTES_PER_ENCODED_BLOCK} + lineSeparator.length;}
@@ -338,8 +340,6 @@ public Base32(final boolean useHex, final byte padding) {
 
     private Base32(final Builder builder) {
         super(builder);
-        Objects.requireNonNull(builder.getEncodeTable(), "encodeTable");
-        this.decodeTable = Arrays.equals(builder.getEncodeTable(), HEX_ENCODE_TABLE) ? HEX_DECODE_TABLE : DECODE_TABLE;
         if (builder.getLineLength() > 0) {
             final byte[] lineSeparator = builder.getLineSeparator();
             // Must be done after initializing the tables
@@ -489,8 +489,15 @@ public Base32(final int lineLength, final byte[] lineSeparator, final boolean us
      */
     @Deprecated
     public Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, final byte padding, final CodecPolicy decodingPolicy) {
-        this(builder().setLineLength(lineLength).setLineSeparator(lineSeparator != null ? lineSeparator : EMPTY_BYTE_ARRAY)
-                .setEncodeTableRaw(encodeTable(useHex)).setPadding(padding).setDecodingPolicy(decodingPolicy));
+        // @formatter:off
+        this(builder()
+                .setLineLength(lineLength)
+                .setLineSeparator(lineSeparator != null ? lineSeparator : EMPTY_BYTE_ARRAY)
+                .setDecodeTable(decodeTable(useHex))
+                .setEncodeTableRaw(encodeTable(useHex))
+                .setPadding(padding)
+                .setDecodingPolicy(decodingPolicy));
+        // @formatter:on
     }
 
     /**

src/main/java/org/apache/commons/codec/binary/Base64.java

@@ -98,6 +98,8 @@ public static class Builder extends AbstractBuilder<Base64, Builder> {
          */
         public Builder() {
             super(STANDARD_ENCODE_TABLE);
+            setDecodeTableRaw(DECODE_TABLE);
+            setEncodeTableRaw(STANDARD_ENCODE_TABLE);
             setEncodedBlockSize(BYTES_PER_ENCODED_BLOCK);
             setUnencodedBlockSize(BYTES_PER_UNENCODED_BLOCK);
         }
@@ -107,6 +109,14 @@ public Base64 get() {
             return new Base64(this);
         }
 
+        @Override
+        public Builder setEncodeTable(final byte... encodeTable) {
+            final boolean isStandardEncodeTable = Arrays.equals(encodeTable, STANDARD_ENCODE_TABLE);
+            final boolean isUrlSafe = Arrays.equals(encodeTable, URL_SAFE_ENCODE_TABLE);
+            super.setDecodeTableRaw(isStandardEncodeTable || isUrlSafe ? DECODE_TABLE : calculateDecodeTable(encodeTable));
+            return super.setEncodeTable(encodeTable);
+        }
+
         /**
          * Sets the URL-safe encoding policy.
          *
@@ -222,6 +232,21 @@ public static Builder builder() {
         return new Builder();
     }
 
+    /**
+     * Calculates a decode table for a given encode table.
+     *
+     * @param encodeTable that is used to determine decode lookup table
+     * @return decodeTable
+     */
+    private static byte[] calculateDecodeTable(final byte[] encodeTable) {
+        final byte[] decodeTable = new byte[DECODING_TABLE_LENGTH];
+        Arrays.fill(decodeTable, (byte) -1);
+        for (int i = 0; i < encodeTable.length; i++) {
+            decodeTable[encodeTable[i]] = (byte) i;
+        }
+        return decodeTable;
+    }
+
     /**
      * Decodes Base64 data into octets.
      * <p>
@@ -505,11 +530,6 @@ static byte[] toUrlSafeEncodeTable(final boolean urlSafe) {
         return urlSafe ? URL_SAFE_ENCODE_TABLE : STANDARD_ENCODE_TABLE;
     }
 
-    /**
-     * Decode table to use.
-     */
-    private final byte[] decodeTable;
-
     /**
      * Line separator for encoding. Not used when decoding. Only used if lineLength &gt; 0.
      */
@@ -523,8 +543,8 @@ static byte[] toUrlSafeEncodeTable(final boolean urlSafe) {
 
     private final boolean isUrlSafe;
 
-    private final boolean isStandardEncodeTable;
 
+    private final boolean isStandardEncodeTable;
 
     /**
      * Constructs a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
@@ -559,6 +579,35 @@ public Base64(final boolean urlSafe) {
         this(MIME_CHUNK_SIZE, CHUNK_SEPARATOR, urlSafe);
     }
 
+    private Base64(final Builder builder) {
+        super(builder);
+        final byte[] encTable = builder.getEncodeTable();
+        if (encTable.length != STANDARD_ENCODE_TABLE.length) {
+            throw new IllegalArgumentException("encodeTable must have exactly 64 entries.");
+        }
+        this.isStandardEncodeTable = Arrays.equals(encTable, STANDARD_ENCODE_TABLE);
+        this.isUrlSafe = Arrays.equals(encTable, URL_SAFE_ENCODE_TABLE);
+        // TODO could be simplified if there is no requirement to reject invalid line sep when length <=0
+        // @see test case Base64Test.testConstructors()
+        if (builder.getLineSeparator().length > 0) {
+            final byte[] lineSeparatorB = builder.getLineSeparator();
+            if (containsAlphabetOrPad(lineSeparatorB)) {
+                final String sep = StringUtils.newStringUtf8(lineSeparatorB);
+                throw new IllegalArgumentException("lineSeparator must not contain base64 characters: [" + sep + "]");
+            }
+            if (builder.getLineLength() > 0) { // null line-sep forces no chunking rather than throwing IAE
+                this.encodeSize = BYTES_PER_ENCODED_BLOCK + lineSeparatorB.length;
+                this.lineSeparator = lineSeparatorB;
+            } else {
+                this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+                this.lineSeparator = null;
+            }
+        } else {
+            this.encodeSize = BYTES_PER_ENCODED_BLOCK;
+            this.lineSeparator = null;
+        }
+    }
+
     /**
      * Constructs a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
      * <p>
@@ -682,51 +731,6 @@ public Base64(final int lineLength, final byte[] lineSeparator, final boolean ur
                 .setDecodingPolicy(decodingPolicy));
     }
 
-    private Base64(final Builder builder) {
-        super(builder);
-        Objects.requireNonNull(builder.getEncodeTable(), "encodeTable");
-        if (builder.getEncodeTable().length != STANDARD_ENCODE_TABLE.length) {
-            throw new IllegalArgumentException("encodeTable must have exactly 64 entries.");
-        }
-        this.isStandardEncodeTable = Arrays.equals(builder.getEncodeTable(), STANDARD_ENCODE_TABLE);
-        this.isUrlSafe = Arrays.equals(builder.getEncodeTable(), URL_SAFE_ENCODE_TABLE);
-        this.decodeTable = this.isStandardEncodeTable || this.isUrlSafe ? DECODE_TABLE : calculateDecodeTable(this.encodeTable);
-        // TODO could be simplified if there is no requirement to reject invalid line sep when length <=0
-        // @see test case Base64Test.testConstructors()
-        if (builder.getLineSeparator().length > 0) {
-            final byte[] lineSeparatorB = builder.getLineSeparator();
-            if (containsAlphabetOrPad(lineSeparatorB)) {
-                final String sep = StringUtils.newStringUtf8(lineSeparatorB);
-                throw new IllegalArgumentException("lineSeparator must not contain base64 characters: [" + sep + "]");
-            }
-            if (builder.getLineLength() > 0) { // null line-sep forces no chunking rather than throwing IAE
-                this.encodeSize = BYTES_PER_ENCODED_BLOCK + lineSeparatorB.length;
-                this.lineSeparator = lineSeparatorB;
-            } else {
-                this.encodeSize = BYTES_PER_ENCODED_BLOCK;
-                this.lineSeparator = null;
-            }
-        } else {
-            this.encodeSize = BYTES_PER_ENCODED_BLOCK;
-            this.lineSeparator = null;
-        }
-    }
-
-    /**
-     * Calculates a decode table for a given encode table.
-     *
-     * @param encodeTable that is used to determine decode lookup table
-     * @return decodeTable
-     */
-    private byte[] calculateDecodeTable(final byte[] encodeTable) {
-        final byte[] decodeTable = new byte[DECODING_TABLE_LENGTH];
-        Arrays.fill(decodeTable, (byte) -1);
-        for (int i = 0; i < encodeTable.length; i++) {
-            decodeTable[encodeTable[i]] = (byte) i;
-        }
-        return decodeTable;
-    }
-
     /**
      * <p>
      * Decodes all of the provided data, starting at inPos, for inAvail bytes. Should be called at least twice: once

src/main/java/org/apache/commons/codec/binary/BaseNCodec.java

@@ -65,6 +65,8 @@ public abstract static class AbstractBuilder<T, B extends AbstractBuilder<T, B>>
         private byte[] lineSeparator = CHUNK_SEPARATOR;
         private final byte[] defaultEncodeTable;
         private byte[] encodeTable;
+        private byte[] decodeTable;
+
         /** Padding byte. */
         private byte padding = PAD_DEFAULT;
 
@@ -90,6 +92,10 @@ B asThis() {
             return (B) this;
         }
 
+        byte[] getDecodeTable() {
+            return decodeTable;
+        }
+
         CodecPolicy getDecodingPolicy() {
             return decodingPolicy;
         }
@@ -118,6 +124,29 @@ int getUnencodedBlockSize() {
             return unencodedBlockSize;
         }
 
+        /**
+         * Sets the decode table.
+         *
+         * @param decodeTable the decode table.
+         * @return {@code this} instance.
+         * @since 1.20.0
+         */
+        public B setDecodeTable(final byte[] decodeTable) {
+            this.decodeTable = decodeTable != null ? decodeTable.clone() : null;
+            return asThis();
+        }
+
+        /**
+         * Sets the decode table.
+         *
+         * @param decodeTable the decode table, null resets to the default.
+         * @return {@code this} instance.
+         */
+        B setDecodeTableRaw(final byte[] decodeTable) {
+            this.decodeTable = decodeTable;
+            return asThis();
+        }
+
         /**
          * Sets the decoding policy.
          *
@@ -133,7 +162,7 @@ public B setDecodingPolicy(final CodecPolicy decodingPolicy) {
          * Sets the encoded block size, subclasses normally set this on construction.
          *
          * @param encodedBlockSize the encoded block size, subclasses normally set this on construction.
-         * @return this
+         * @return {@code this} instance.
          */
         B setEncodedBlockSize(final int encodedBlockSize) {
             this.encodedBlockSize = encodedBlockSize;
@@ -199,7 +228,7 @@ public B setPadding(final byte padding) {
          * Sets the unencoded block size, subclasses normally set this on construction.
          *
          * @param unencodedBlockSize the unencoded block size, subclasses normally set this on construction.
-         * @return this
+         * @return {@code this} instance.
          */
         B setUnencodedBlockSize(final int unencodedBlockSize) {
             this.unencodedBlockSize = unencodedBlockSize;
@@ -444,6 +473,12 @@ private static byte[] resizeBuffer(final Context context, final int minCapacity)
      * </p>
      */
     private final CodecPolicy decodingPolicy;
+
+    /**
+     * Decode table to use.
+     */
+    final byte[] decodeTable;
+
     /**
      * Encode table.
      */
@@ -463,7 +498,8 @@ protected BaseNCodec(final AbstractBuilder<?, ?> builder) {
         this.chunkSeparatorLength = builder.lineSeparator.length;
         this.pad = builder.padding;
         this.decodingPolicy = Objects.requireNonNull(builder.decodingPolicy, "codecPolicy");
-        this.encodeTable = builder.getEncodeTable();
+        this.encodeTable = Objects.requireNonNull(builder.getEncodeTable(), "builder.getEncodeTable()");
+        this.decodeTable = builder.getDecodeTable();
     }
 
     /**
@@ -530,6 +566,7 @@ protected BaseNCodec(final int unencodedBlockSize, final int encodedBlockSize, f
         this.pad = pad;
         this.decodingPolicy = Objects.requireNonNull(decodingPolicy, "codecPolicy");
         this.encodeTable = null;
+        this.decodeTable = null;
     }
 
     /**

src/test/java/org/apache/commons/codec/binary/Base32Test.java

@@ -494,7 +494,7 @@ void testIsInAlphabet() {
         // hex table
         b32 = new Base32(true);
         for (char c = '0'; c <= '9'; c++) {
-            assertTrue(b32.isInAlphabet((byte) c));
+            assertTrue(b32.isInAlphabet((byte) c), String.valueOf(c));
         }
         for (char c = 'A'; c <= 'V'; c++) {
             assertTrue(b32.isInAlphabet((byte) c));