svn commit: r1088700 [10/33] - in /websites/production/commons/content/proper/commons-codec: ./ apidocs/ apidocs/org/apache/commons/codec/ apidocs/org/apache/commons/codec/binary/ apidocs/org/apache/commons/codec/binary/class-use/ apidocs/org/apache/co...

[ggregory]

Modified: 
websites/production/commons/content/proper/commons-codec/apidocs/src-html/org/apache/commons/codec/binary/Base32.html
==============================================================================
--- 
websites/production/commons/content/proper/commons-codec/apidocs/src-html/org/apache/commons/codec/binary/Base32.html
 (original)
+++ 
websites/production/commons/content/proper/commons-codec/apidocs/src-html/org/apache/commons/codec/binary/Base32.html
 Mon Jan 27 18:12:24 2025
@@ -88,581 +88,616 @@
 <span class="source-line-no">075</span><span id="line-75">            return 
new Base32(getLineLength(), getLineSeparator(), getEncodeTable(), getPadding(), 
getDecodingPolicy());</span>
 <span class="source-line-no">076</span><span id="line-76">        }</span>
 <span class="source-line-no">077</span><span id="line-77"></span>
-<span class="source-line-no">078</span><span id="line-78">    }</span>
-<span class="source-line-no">079</span><span id="line-79"></span>
-<span class="source-line-no">080</span><span id="line-80">    /**</span>
-<span class="source-line-no">081</span><span id="line-81">     * BASE32 
characters are 5 bits in length. They are formed by taking a block of five 
octets to form a 40-bit string, which is converted into eight BASE32</span>
-<span class="source-line-no">082</span><span id="line-82">     * 
characters.</span>
-<span class="source-line-no">083</span><span id="line-83">     */</span>
-<span class="source-line-no">084</span><span id="line-84">    private static 
final int BITS_PER_ENCODED_BYTE = 5;</span>
-<span class="source-line-no">085</span><span id="line-85"></span>
-<span class="source-line-no">086</span><span id="line-86">    private static 
final int BYTES_PER_ENCODED_BLOCK = 8;</span>
-<span class="source-line-no">087</span><span id="line-87">    private static 
final int BYTES_PER_UNENCODED_BLOCK = 5;</span>
-<span class="source-line-no">088</span><span id="line-88">    /**</span>
-<span class="source-line-no">089</span><span id="line-89">     * This array is 
a lookup table that translates Unicode characters drawn from the "Base32 
Alphabet" (as specified in Table 3 of RFC 4648) into their 5-bit</span>
-<span class="source-line-no">090</span><span id="line-90">     * positive 
integer equivalents. Characters that are not in the Base32 alphabet but fall 
within the bounds of the array are translated to -1.</span>
-<span class="source-line-no">091</span><span id="line-91">     */</span>
-<span class="source-line-no">092</span><span id="line-92">    // 
@formatter:off</span>
-<span class="source-line-no">093</span><span id="line-93">    private static 
final byte[] DECODE_TABLE = {</span>
-<span class="source-line-no">094</span><span id="line-94">         //  0   1   
2   3   4   5   6   7   8   9   A   B   C   D   E   F</span>
-<span class="source-line-no">095</span><span id="line-95">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f</span>
-<span class="source-line-no">096</span><span id="line-96">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f</span>
-<span class="source-line-no">097</span><span id="line-97">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f</span>
-<span class="source-line-no">098</span><span id="line-98">            -1, -1, 
26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1, // 30-3f 2-7</span>
-<span class="source-line-no">099</span><span id="line-99">            -1,  0,  
1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 40-4f A-O</span>
-<span class="source-line-no">100</span><span id="line-100">            15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25,                     // 50-5a P-Z</span>
-<span class="source-line-no">101</span><span id="line-101">                    
                                    -1, -1, -1, -1, -1, // 5b-5f</span>
-<span class="source-line-no">102</span><span id="line-102">            -1,  0, 
 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 60-6f a-o</span>
-<span class="source-line-no">103</span><span id="line-103">            15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25,                     // 70-7a p-z</span>
-<span class="source-line-no">104</span><span id="line-104">    };</span>
-<span class="source-line-no">105</span><span id="line-105">    // 
@formatter:on</span>
+<span class="source-line-no">078</span><span id="line-78">        /**</span>
+<span class="source-line-no">079</span><span id="line-79">         * Sets the 
decode table to use Base32 hexadecimal if {@code true}, otherwise use the 
Base32 alphabet.</span>
+<span class="source-line-no">080</span><span id="line-80">         * 
&lt;p&gt;</span>
+<span class="source-line-no">081</span><span id="line-81">         * This 
overrides a value previously set with {@link #setEncodeTable(byte...)}.</span>
+<span class="source-line-no">082</span><span id="line-82">         * 
&lt;/p&gt;</span>
+<span class="source-line-no">083</span><span id="line-83">         *</span>
+<span class="source-line-no">084</span><span id="line-84">         * @param 
useHex use Base32 hexadecimal if {@code true}, otherwise use the Base32 
alphabet.</span>
+<span class="source-line-no">085</span><span id="line-85">         * @return 
this instance.</span>
+<span class="source-line-no">086</span><span id="line-86">         * @since 
1.18.0</span>
+<span class="source-line-no">087</span><span id="line-87">         */</span>
+<span class="source-line-no">088</span><span id="line-88">        public 
Builder setHexDecodeTable(final boolean useHex) {</span>
+<span class="source-line-no">089</span><span id="line-89">            return 
setEncodeTable(decodeTable(useHex));</span>
+<span class="source-line-no">090</span><span id="line-90">        }</span>
+<span class="source-line-no">091</span><span id="line-91"></span>
+<span class="source-line-no">092</span><span id="line-92">        /**</span>
+<span class="source-line-no">093</span><span id="line-93">         * Sets the 
encode table to use Base32 hexadecimal if {@code true}, otherwise use the 
Base32 alphabet.</span>
+<span class="source-line-no">094</span><span id="line-94">         * 
&lt;p&gt;</span>
+<span class="source-line-no">095</span><span id="line-95">         * This 
overrides a value previously set with {@link #setEncodeTable(byte...)}.</span>
+<span class="source-line-no">096</span><span id="line-96">         * 
&lt;/p&gt;</span>
+<span class="source-line-no">097</span><span id="line-97">         *</span>
+<span class="source-line-no">098</span><span id="line-98">         * @param 
useHex use Base32 hexadecimal if {@code true}, otherwise use the Base32 
alphabet.</span>
+<span class="source-line-no">099</span><span id="line-99">         * @return 
this instance.</span>
+<span class="source-line-no">100</span><span id="line-100">         * @since 
1.18.0</span>
+<span class="source-line-no">101</span><span id="line-101">         */</span>
+<span class="source-line-no">102</span><span id="line-102">        public 
Builder setHexEncodeTable(final boolean useHex) {</span>
+<span class="source-line-no">103</span><span id="line-103">            return 
setEncodeTable(encodeTable(useHex));</span>
+<span class="source-line-no">104</span><span id="line-104">        }</span>
+<span class="source-line-no">105</span><span id="line-105">    }</span>
 <span class="source-line-no">106</span><span id="line-106"></span>
 <span class="source-line-no">107</span><span id="line-107">    /**</span>
-<span class="source-line-no">108</span><span id="line-108">     * This array 
is a lookup table that translates 5-bit positive integer index values into 
their "Base32 Alphabet" equivalents as specified in Table 3 of RFC</span>
-<span class="source-line-no">109</span><span id="line-109">     * 4648.</span>
+<span class="source-line-no">108</span><span id="line-108">     * BASE32 
characters are 5 bits in length. They are formed by taking a block of five 
octets to form a 40-bit string, which is converted into eight BASE32</span>
+<span class="source-line-no">109</span><span id="line-109">     * 
characters.</span>
 <span class="source-line-no">110</span><span id="line-110">     */</span>
-<span class="source-line-no">111</span><span id="line-111">    // 
@formatter:off</span>
-<span class="source-line-no">112</span><span id="line-112">    private static 
final byte[] ENCODE_TABLE = {</span>
-<span class="source-line-no">113</span><span id="line-113">            'A', 
'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',</span>
-<span class="source-line-no">114</span><span id="line-114">            'N', 
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',</span>
-<span class="source-line-no">115</span><span id="line-115">            '2', 
'3', '4', '5', '6', '7',</span>
-<span class="source-line-no">116</span><span id="line-116">    };</span>
-<span class="source-line-no">117</span><span id="line-117">    // 
@formatter:on</span>
-<span class="source-line-no">118</span><span id="line-118"></span>
-<span class="source-line-no">119</span><span id="line-119">    /**</span>
-<span class="source-line-no">120</span><span id="line-120">     * This array 
is a lookup table that translates Unicode characters drawn from the "Base32 Hex 
Alphabet" (as specified in Table 4 of RFC 4648) into their</span>
-<span class="source-line-no">121</span><span id="line-121">     * 5-bit 
positive integer equivalents. Characters that are not in the Base32 Hex 
alphabet but fall within the bounds of the array are translated to -1.</span>
-<span class="source-line-no">122</span><span id="line-122">     */</span>
-<span class="source-line-no">123</span><span id="line-123">    // 
@formatter:off</span>
-<span class="source-line-no">124</span><span id="line-124">    private static 
final byte[] HEX_DECODE_TABLE = {</span>
-<span class="source-line-no">125</span><span id="line-125">         //  0   1  
 2   3   4   5   6   7   8   9   A   B   C   D   E   F</span>
-<span class="source-line-no">126</span><span id="line-126">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f</span>
-<span class="source-line-no">127</span><span id="line-127">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f</span>
-<span class="source-line-no">128</span><span id="line-128">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f</span>
-<span class="source-line-no">129</span><span id="line-129">             0,  1, 
 2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1, // 30-3f 0-9</span>
-<span class="source-line-no">130</span><span id="line-130">            -1, 10, 
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 40-4f A-O</span>
-<span class="source-line-no">131</span><span id="line-131">            25, 26, 
27, 28, 29, 30, 31,                                     // 50-56 P-V</span>
-<span class="source-line-no">132</span><span id="line-132">                    
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, // 57-5f</span>
-<span class="source-line-no">133</span><span id="line-133">            -1, 10, 
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 60-6f a-o</span>
-<span class="source-line-no">134</span><span id="line-134">            25, 26, 
27, 28, 29, 30, 31                                      // 70-76 p-v</span>
-<span class="source-line-no">135</span><span id="line-135">    };</span>
-<span class="source-line-no">136</span><span id="line-136">    // 
@formatter:on</span>
-<span class="source-line-no">137</span><span id="line-137"></span>
-<span class="source-line-no">138</span><span id="line-138">    /**</span>
-<span class="source-line-no">139</span><span id="line-139">     * This array 
is a lookup table that translates 5-bit positive integer index values into 
their "Base32 Hex Alphabet" equivalents as specified in Table 4 of</span>
-<span class="source-line-no">140</span><span id="line-140">     * RFC 
4648.</span>
-<span class="source-line-no">141</span><span id="line-141">     */</span>
-<span class="source-line-no">142</span><span id="line-142">    // 
@formatter:off</span>
-<span class="source-line-no">143</span><span id="line-143">    private static 
final byte[] HEX_ENCODE_TABLE = {</span>
-<span class="source-line-no">144</span><span id="line-144">            '0', 
'1', '2', '3', '4', '5', '6', '7', '8', '9',</span>
-<span class="source-line-no">145</span><span id="line-145">            'A', 
'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',</span>
-<span class="source-line-no">146</span><span id="line-146">            'N', 
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',</span>
-<span class="source-line-no">147</span><span id="line-147">    };</span>
-<span class="source-line-no">148</span><span id="line-148">    // 
@formatter:on</span>
-<span class="source-line-no">149</span><span id="line-149"></span>
-<span class="source-line-no">150</span><span id="line-150">    /** Mask used 
to extract 5 bits, used when encoding Base32 bytes */</span>
-<span class="source-line-no">151</span><span id="line-151">    private static 
final int MASK_5BITS = 0x1f;</span>
-<span class="source-line-no">152</span><span id="line-152"></span>
-<span class="source-line-no">153</span><span id="line-153">    /** Mask used 
to extract 4 bits, used when decoding final trailing character. */</span>
-<span class="source-line-no">154</span><span id="line-154">    private static 
final long MASK_4BITS = 0x0fL;</span>
-<span class="source-line-no">155</span><span id="line-155"></span>
-<span class="source-line-no">156</span><span id="line-156">    /** Mask used 
to extract 3 bits, used when decoding final trailing character. */</span>
-<span class="source-line-no">157</span><span id="line-157">    private static 
final long MASK_3BITS = 0x07L;</span>
-<span class="source-line-no">158</span><span id="line-158"></span>
-<span class="source-line-no">159</span><span id="line-159">    /** Mask used 
to extract 2 bits, used when decoding final trailing character. */</span>
-<span class="source-line-no">160</span><span id="line-160">    private static 
final long MASK_2BITS = 0x03L;</span>
-<span class="source-line-no">161</span><span id="line-161"></span>
-<span class="source-line-no">162</span><span id="line-162">    /** Mask used 
to extract 1 bits, used when decoding final trailing character. */</span>
-<span class="source-line-no">163</span><span id="line-163">    private static 
final long MASK_1BITS = 0x01L;</span>
+<span class="source-line-no">111</span><span id="line-111">    private static 
final int BITS_PER_ENCODED_BYTE = 5;</span>
+<span class="source-line-no">112</span><span id="line-112"></span>
+<span class="source-line-no">113</span><span id="line-113">    private static 
final int BYTES_PER_ENCODED_BLOCK = 8;</span>
+<span class="source-line-no">114</span><span id="line-114">    private static 
final int BYTES_PER_UNENCODED_BLOCK = 5;</span>
+<span class="source-line-no">115</span><span id="line-115">    /**</span>
+<span class="source-line-no">116</span><span id="line-116">     * This array 
is a lookup table that translates Unicode characters drawn from the "Base32 
Alphabet" (as specified in Table 3 of RFC 4648) into their 5-bit</span>
+<span class="source-line-no">117</span><span id="line-117">     * positive 
integer equivalents. Characters that are not in the Base32 alphabet but fall 
within the bounds of the array are translated to -1.</span>
+<span class="source-line-no">118</span><span id="line-118">     */</span>
+<span class="source-line-no">119</span><span id="line-119">    // 
@formatter:off</span>
+<span class="source-line-no">120</span><span id="line-120">    private static 
final byte[] DECODE_TABLE = {</span>
+<span class="source-line-no">121</span><span id="line-121">         //  0   1  
 2   3   4   5   6   7   8   9   A   B   C   D   E   F</span>
+<span class="source-line-no">122</span><span id="line-122">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f</span>
+<span class="source-line-no">123</span><span id="line-123">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f</span>
+<span class="source-line-no">124</span><span id="line-124">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f</span>
+<span class="source-line-no">125</span><span id="line-125">            -1, -1, 
26, 27, 28, 29, 30, 31, -1, -1, -1, -1, -1, -1, -1, -1, // 30-3f 2-7</span>
+<span class="source-line-no">126</span><span id="line-126">            -1,  0, 
 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 40-4f A-O</span>
+<span class="source-line-no">127</span><span id="line-127">            15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25,                     // 50-5a P-Z</span>
+<span class="source-line-no">128</span><span id="line-128">                    
                                    -1, -1, -1, -1, -1, // 5b-5f</span>
+<span class="source-line-no">129</span><span id="line-129">            -1,  0, 
 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 60-6f a-o</span>
+<span class="source-line-no">130</span><span id="line-130">            15, 16, 
17, 18, 19, 20, 21, 22, 23, 24, 25,                     // 70-7a p-z</span>
+<span class="source-line-no">131</span><span id="line-131">    };</span>
+<span class="source-line-no">132</span><span id="line-132">    // 
@formatter:on</span>
+<span class="source-line-no">133</span><span id="line-133"></span>
+<span class="source-line-no">134</span><span id="line-134">    /**</span>
+<span class="source-line-no">135</span><span id="line-135">     * This array 
is a lookup table that translates 5-bit positive integer index values into 
their "Base32 Alphabet" equivalents as specified in Table 3 of RFC</span>
+<span class="source-line-no">136</span><span id="line-136">     * 4648.</span>
+<span class="source-line-no">137</span><span id="line-137">     */</span>
+<span class="source-line-no">138</span><span id="line-138">    // 
@formatter:off</span>
+<span class="source-line-no">139</span><span id="line-139">    private static 
final byte[] ENCODE_TABLE = {</span>
+<span class="source-line-no">140</span><span id="line-140">            'A', 
'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',</span>
+<span class="source-line-no">141</span><span id="line-141">            'N', 
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',</span>
+<span class="source-line-no">142</span><span id="line-142">            '2', 
'3', '4', '5', '6', '7',</span>
+<span class="source-line-no">143</span><span id="line-143">    };</span>
+<span class="source-line-no">144</span><span id="line-144">    // 
@formatter:on</span>
+<span class="source-line-no">145</span><span id="line-145"></span>
+<span class="source-line-no">146</span><span id="line-146">    /**</span>
+<span class="source-line-no">147</span><span id="line-147">     * This array 
is a lookup table that translates Unicode characters drawn from the "Base32 Hex 
Alphabet" (as specified in Table 4 of RFC 4648) into their</span>
+<span class="source-line-no">148</span><span id="line-148">     * 5-bit 
positive integer equivalents. Characters that are not in the Base32 Hex 
alphabet but fall within the bounds of the array are translated to -1.</span>
+<span class="source-line-no">149</span><span id="line-149">     */</span>
+<span class="source-line-no">150</span><span id="line-150">    // 
@formatter:off</span>
+<span class="source-line-no">151</span><span id="line-151">    private static 
final byte[] HEX_DECODE_TABLE = {</span>
+<span class="source-line-no">152</span><span id="line-152">         //  0   1  
 2   3   4   5   6   7   8   9   A   B   C   D   E   F</span>
+<span class="source-line-no">153</span><span id="line-153">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 00-0f</span>
+<span class="source-line-no">154</span><span id="line-154">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 10-1f</span>
+<span class="source-line-no">155</span><span id="line-155">            -1, -1, 
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 20-2f</span>
+<span class="source-line-no">156</span><span id="line-156">             0,  1, 
 2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1, // 30-3f 0-9</span>
+<span class="source-line-no">157</span><span id="line-157">            -1, 10, 
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 40-4f A-O</span>
+<span class="source-line-no">158</span><span id="line-158">            25, 26, 
27, 28, 29, 30, 31,                                     // 50-56 P-V</span>
+<span class="source-line-no">159</span><span id="line-159">                    
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, // 57-5f</span>
+<span class="source-line-no">160</span><span id="line-160">            -1, 10, 
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 60-6f a-o</span>
+<span class="source-line-no">161</span><span id="line-161">            25, 26, 
27, 28, 29, 30, 31                                      // 70-76 p-v</span>
+<span class="source-line-no">162</span><span id="line-162">    };</span>
+<span class="source-line-no">163</span><span id="line-163">    // 
@formatter:on</span>
 <span class="source-line-no">164</span><span id="line-164"></span>
 <span class="source-line-no">165</span><span id="line-165">    /**</span>
-<span class="source-line-no">166</span><span id="line-166">     * Creates a 
new Builder.</span>
-<span class="source-line-no">167</span><span id="line-167">     *</span>
-<span class="source-line-no">168</span><span id="line-168">     * @return a 
new Builder.</span>
-<span class="source-line-no">169</span><span id="line-169">     * @since 
1.17.0</span>
-<span class="source-line-no">170</span><span id="line-170">     */</span>
-<span class="source-line-no">171</span><span id="line-171">    public static 
Builder builder() {</span>
-<span class="source-line-no">172</span><span id="line-172">        return new 
Builder();</span>
-<span class="source-line-no">173</span><span id="line-173">    }</span>
-<span class="source-line-no">174</span><span id="line-174"></span>
-<span class="source-line-no">175</span><span id="line-175">    // The static 
final fields above are used for the original static byte[] methods on 
Base32.</span>
-<span class="source-line-no">176</span><span id="line-176">    // The private 
member fields below are used with the new streaming approach, which 
requires</span>
-<span class="source-line-no">177</span><span id="line-177">    // some state 
be preserved between calls of encode() and decode().</span>
-<span class="source-line-no">178</span><span id="line-178"></span>
-<span class="source-line-no">179</span><span id="line-179">    /**</span>
-<span class="source-line-no">180</span><span id="line-180">     * Decode table 
to use.</span>
-<span class="source-line-no">181</span><span id="line-181">     */</span>
-<span class="source-line-no">182</span><span id="line-182">    private final 
byte[] decodeTable;</span>
-<span class="source-line-no">183</span><span id="line-183"></span>
-<span class="source-line-no">184</span><span id="line-184">    /**</span>
-<span class="source-line-no">185</span><span id="line-185">     * Convenience 
variable to help us determine when our buffer is going to run out of room and 
needs resizing. {@code encodeSize = {@link</span>
-<span class="source-line-no">186</span><span id="line-186">     * 
#BYTES_PER_ENCODED_BLOCK} + lineSeparator.length;}</span>
-<span class="source-line-no">187</span><span id="line-187">     */</span>
-<span class="source-line-no">188</span><span id="line-188">    private final 
int encodeSize;</span>
-<span class="source-line-no">189</span><span id="line-189"></span>
-<span class="source-line-no">190</span><span id="line-190">    /**</span>
-<span class="source-line-no">191</span><span id="line-191">     * Encode table 
to use.</span>
-<span class="source-line-no">192</span><span id="line-192">     */</span>
-<span class="source-line-no">193</span><span id="line-193">    private final 
byte[] encodeTable;</span>
-<span class="source-line-no">194</span><span id="line-194"></span>
-<span class="source-line-no">195</span><span id="line-195">    /**</span>
-<span class="source-line-no">196</span><span id="line-196">     * Line 
separator for encoding. Not used when decoding. Only used if lineLength 
&amp;gt; 0.</span>
-<span class="source-line-no">197</span><span id="line-197">     */</span>
-<span class="source-line-no">198</span><span id="line-198">    private final 
byte[] lineSeparator;</span>
-<span class="source-line-no">199</span><span id="line-199"></span>
-<span class="source-line-no">200</span><span id="line-200">    /**</span>
-<span class="source-line-no">201</span><span id="line-201">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
-<span class="source-line-no">202</span><span id="line-202">     * 
&lt;p&gt;</span>
-<span class="source-line-no">203</span><span id="line-203">     * When 
encoding the line length is 0 (no chunking).</span>
-<span class="source-line-no">204</span><span id="line-204">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">205</span><span id="line-205">     */</span>
-<span class="source-line-no">206</span><span id="line-206">    public Base32() 
{</span>
-<span class="source-line-no">207</span><span id="line-207">        
this(false);</span>
+<span class="source-line-no">166</span><span id="line-166">     * This array 
is a lookup table that translates 5-bit positive integer index values into 
their "Base32 Hex Alphabet" equivalents as specified in Table 4 of</span>
+<span class="source-line-no">167</span><span id="line-167">     * RFC 
4648.</span>
+<span class="source-line-no">168</span><span id="line-168">     */</span>
+<span class="source-line-no">169</span><span id="line-169">    // 
@formatter:off</span>
+<span class="source-line-no">170</span><span id="line-170">    private static 
final byte[] HEX_ENCODE_TABLE = {</span>
+<span class="source-line-no">171</span><span id="line-171">            '0', 
'1', '2', '3', '4', '5', '6', '7', '8', '9',</span>
+<span class="source-line-no">172</span><span id="line-172">            'A', 
'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',</span>
+<span class="source-line-no">173</span><span id="line-173">            'N', 
'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',</span>
+<span class="source-line-no">174</span><span id="line-174">    };</span>
+<span class="source-line-no">175</span><span id="line-175">    // 
@formatter:on</span>
+<span class="source-line-no">176</span><span id="line-176"></span>
+<span class="source-line-no">177</span><span id="line-177">    /** Mask used 
to extract 5 bits, used when encoding Base32 bytes */</span>
+<span class="source-line-no">178</span><span id="line-178">    private static 
final int MASK_5BITS = 0x1f;</span>
+<span class="source-line-no">179</span><span id="line-179"></span>
+<span class="source-line-no">180</span><span id="line-180">    /** Mask used 
to extract 4 bits, used when decoding final trailing character. */</span>
+<span class="source-line-no">181</span><span id="line-181">    private static 
final long MASK_4BITS = 0x0fL;</span>
+<span class="source-line-no">182</span><span id="line-182"></span>
+<span class="source-line-no">183</span><span id="line-183">    /** Mask used 
to extract 3 bits, used when decoding final trailing character. */</span>
+<span class="source-line-no">184</span><span id="line-184">    private static 
final long MASK_3BITS = 0x07L;</span>
+<span class="source-line-no">185</span><span id="line-185"></span>
+<span class="source-line-no">186</span><span id="line-186">    /** Mask used 
to extract 2 bits, used when decoding final trailing character. */</span>
+<span class="source-line-no">187</span><span id="line-187">    private static 
final long MASK_2BITS = 0x03L;</span>
+<span class="source-line-no">188</span><span id="line-188"></span>
+<span class="source-line-no">189</span><span id="line-189">    /** Mask used 
to extract 1 bits, used when decoding final trailing character. */</span>
+<span class="source-line-no">190</span><span id="line-190">    private static 
final long MASK_1BITS = 0x01L;</span>
+<span class="source-line-no">191</span><span id="line-191"></span>
+<span class="source-line-no">192</span><span id="line-192">    // The static 
final fields above are used for the original static byte[] methods on 
Base32.</span>
+<span class="source-line-no">193</span><span id="line-193">    // The private 
member fields below are used with the new streaming approach, which 
requires</span>
+<span class="source-line-no">194</span><span id="line-194">    // some state 
be preserved between calls of encode() and decode().</span>
+<span class="source-line-no">195</span><span id="line-195"></span>
+<span class="source-line-no">196</span><span id="line-196">    /**</span>
+<span class="source-line-no">197</span><span id="line-197">     * Creates a 
new Builder.</span>
+<span class="source-line-no">198</span><span id="line-198">     *</span>
+<span class="source-line-no">199</span><span id="line-199">     * @return a 
new Builder.</span>
+<span class="source-line-no">200</span><span id="line-200">     * @since 
1.17.0</span>
+<span class="source-line-no">201</span><span id="line-201">     */</span>
+<span class="source-line-no">202</span><span id="line-202">    public static 
Builder builder() {</span>
+<span class="source-line-no">203</span><span id="line-203">        return new 
Builder();</span>
+<span class="source-line-no">204</span><span id="line-204">    }</span>
+<span class="source-line-no">205</span><span id="line-205"></span>
+<span class="source-line-no">206</span><span id="line-206">    private static 
byte[] decodeTable(final boolean useHex) {</span>
+<span class="source-line-no">207</span><span id="line-207">        return 
useHex ? HEX_DECODE_TABLE : DECODE_TABLE;</span>
 <span class="source-line-no">208</span><span id="line-208">    }</span>
 <span class="source-line-no">209</span><span id="line-209"></span>
-<span class="source-line-no">210</span><span id="line-210">    /**</span>
-<span class="source-line-no">211</span><span id="line-211">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
-<span class="source-line-no">212</span><span id="line-212">     * 
&lt;p&gt;</span>
-<span class="source-line-no">213</span><span id="line-213">     * When 
encoding the line length is 0 (no chunking).</span>
-<span class="source-line-no">214</span><span id="line-214">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">215</span><span id="line-215">     *</span>
-<span class="source-line-no">216</span><span id="line-216">     * @param 
useHex if {@code true} then use Base32 Hex alphabet</span>
-<span class="source-line-no">217</span><span id="line-217">     */</span>
-<span class="source-line-no">218</span><span id="line-218">    public 
Base32(final boolean useHex) {</span>
-<span class="source-line-no">219</span><span id="line-219">        this(0, 
null, useHex, PAD_DEFAULT);</span>
-<span class="source-line-no">220</span><span id="line-220">    }</span>
-<span class="source-line-no">221</span><span id="line-221"></span>
-<span class="source-line-no">222</span><span id="line-222">    /**</span>
-<span class="source-line-no">223</span><span id="line-223">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
-<span class="source-line-no">224</span><span id="line-224">     * 
&lt;p&gt;</span>
-<span class="source-line-no">225</span><span id="line-225">     * When 
encoding the line length is 0 (no chunking).</span>
-<span class="source-line-no">226</span><span id="line-226">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">227</span><span id="line-227">     *</span>
-<span class="source-line-no">228</span><span id="line-228">     * @param 
useHex  if {@code true} then use Base32 Hex alphabet</span>
-<span class="source-line-no">229</span><span id="line-229">     * @param 
padding byte used as padding byte.</span>
-<span class="source-line-no">230</span><span id="line-230">     */</span>
-<span class="source-line-no">231</span><span id="line-231">    public 
Base32(final boolean useHex, final byte padding) {</span>
-<span class="source-line-no">232</span><span id="line-232">        this(0, 
null, useHex, padding);</span>
-<span class="source-line-no">233</span><span id="line-233">    }</span>
+<span class="source-line-no">210</span><span id="line-210">    private static 
byte[] encodeTable(final boolean useHex) {</span>
+<span class="source-line-no">211</span><span id="line-211">        return 
useHex ? HEX_ENCODE_TABLE : ENCODE_TABLE;</span>
+<span class="source-line-no">212</span><span id="line-212">    }</span>
+<span class="source-line-no">213</span><span id="line-213"></span>
+<span class="source-line-no">214</span><span id="line-214">    /**</span>
+<span class="source-line-no">215</span><span id="line-215">     * Decode table 
to use.</span>
+<span class="source-line-no">216</span><span id="line-216">     */</span>
+<span class="source-line-no">217</span><span id="line-217">    private final 
byte[] decodeTable;</span>
+<span class="source-line-no">218</span><span id="line-218"></span>
+<span class="source-line-no">219</span><span id="line-219">    /**</span>
+<span class="source-line-no">220</span><span id="line-220">     * Convenience 
variable to help us determine when our buffer is going to run out of room and 
needs resizing. {@code encodeSize = {@link</span>
+<span class="source-line-no">221</span><span id="line-221">     * 
#BYTES_PER_ENCODED_BLOCK} + lineSeparator.length;}</span>
+<span class="source-line-no">222</span><span id="line-222">     */</span>
+<span class="source-line-no">223</span><span id="line-223">    private final 
int encodeSize;</span>
+<span class="source-line-no">224</span><span id="line-224"></span>
+<span class="source-line-no">225</span><span id="line-225">    /**</span>
+<span class="source-line-no">226</span><span id="line-226">     * Encode table 
to use.</span>
+<span class="source-line-no">227</span><span id="line-227">     */</span>
+<span class="source-line-no">228</span><span id="line-228">    private final 
byte[] encodeTable;</span>
+<span class="source-line-no">229</span><span id="line-229"></span>
+<span class="source-line-no">230</span><span id="line-230">    /**</span>
+<span class="source-line-no">231</span><span id="line-231">     * Line 
separator for encoding. Not used when decoding. Only used if lineLength 
&amp;gt; 0.</span>
+<span class="source-line-no">232</span><span id="line-232">     */</span>
+<span class="source-line-no">233</span><span id="line-233">    private final 
byte[] lineSeparator;</span>
 <span class="source-line-no">234</span><span id="line-234"></span>
 <span class="source-line-no">235</span><span id="line-235">    /**</span>
 <span class="source-line-no">236</span><span id="line-236">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
 <span class="source-line-no">237</span><span id="line-237">     * 
&lt;p&gt;</span>
 <span class="source-line-no">238</span><span id="line-238">     * When 
encoding the line length is 0 (no chunking).</span>
 <span class="source-line-no">239</span><span id="line-239">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">240</span><span id="line-240">     *</span>
-<span class="source-line-no">241</span><span id="line-241">     * @param pad 
byte used as padding byte.</span>
-<span class="source-line-no">242</span><span id="line-242">     */</span>
-<span class="source-line-no">243</span><span id="line-243">    public 
Base32(final byte pad) {</span>
-<span class="source-line-no">244</span><span id="line-244">        this(false, 
pad);</span>
-<span class="source-line-no">245</span><span id="line-245">    }</span>
-<span class="source-line-no">246</span><span id="line-246"></span>
-<span class="source-line-no">247</span><span id="line-247">    /**</span>
-<span class="source-line-no">248</span><span id="line-248">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
-<span class="source-line-no">249</span><span id="line-249">     * 
&lt;p&gt;</span>
-<span class="source-line-no">250</span><span id="line-250">     * When 
encoding the line length is given in the constructor, the line separator is 
CRLF.</span>
-<span class="source-line-no">251</span><span id="line-251">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">252</span><span id="line-252">     *</span>
-<span class="source-line-no">253</span><span id="line-253">     * @param 
lineLength Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0, 
then</span>
-<span class="source-line-no">254</span><span id="line-254">     *              
     the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">255</span><span id="line-255">     */</span>
-<span class="source-line-no">256</span><span id="line-256">    public 
Base32(final int lineLength) {</span>
-<span class="source-line-no">257</span><span id="line-257">        
this(lineLength, CHUNK_SEPARATOR);</span>
-<span class="source-line-no">258</span><span id="line-258">    }</span>
-<span class="source-line-no">259</span><span id="line-259"></span>
-<span class="source-line-no">260</span><span id="line-260">    /**</span>
-<span class="source-line-no">261</span><span id="line-261">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
-<span class="source-line-no">262</span><span id="line-262">     * 
&lt;p&gt;</span>
-<span class="source-line-no">263</span><span id="line-263">     * When 
encoding the line length and line separator are given in the constructor.</span>
-<span class="source-line-no">264</span><span id="line-264">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">265</span><span id="line-265">     * 
&lt;p&gt;</span>
-<span class="source-line-no">266</span><span id="line-266">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
-<span class="source-line-no">267</span><span id="line-267">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">268</span><span id="line-268">     *</span>
-<span class="source-line-no">269</span><span id="line-269">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
-<span class="source-line-no">270</span><span id="line-270">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">271</span><span id="line-271">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
-<span class="source-line-no">272</span><span id="line-272">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters.</span>
-<span class="source-line-no">273</span><span id="line-273">     */</span>
-<span class="source-line-no">274</span><span id="line-274">    public 
Base32(final int lineLength, final byte[] lineSeparator) {</span>
-<span class="source-line-no">275</span><span id="line-275">        
this(lineLength, lineSeparator, false, PAD_DEFAULT);</span>
-<span class="source-line-no">276</span><span id="line-276">    }</span>
-<span class="source-line-no">277</span><span id="line-277"></span>
-<span class="source-line-no">278</span><span id="line-278">    /**</span>
-<span class="source-line-no">279</span><span id="line-279">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
-<span class="source-line-no">280</span><span id="line-280">     * 
&lt;p&gt;</span>
-<span class="source-line-no">281</span><span id="line-281">     * When 
encoding the line length and line separator are given in the constructor.</span>
-<span class="source-line-no">282</span><span id="line-282">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">283</span><span id="line-283">     * 
&lt;p&gt;</span>
-<span class="source-line-no">284</span><span id="line-284">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
-<span class="source-line-no">285</span><span id="line-285">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">286</span><span id="line-286">     *</span>
-<span class="source-line-no">287</span><span id="line-287">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
-<span class="source-line-no">288</span><span id="line-288">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">289</span><span id="line-289">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
-<span class="source-line-no">290</span><span id="line-290">     * @param 
useHex        if {@code true}, then use Base32 Hex alphabet, otherwise use 
Base32 alphabet</span>
-<span class="source-line-no">291</span><span id="line-291">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
-<span class="source-line-no">292</span><span id="line-292">     */</span>
-<span class="source-line-no">293</span><span id="line-293">    public 
Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex) 
{</span>
-<span class="source-line-no">294</span><span id="line-294">        
this(lineLength, lineSeparator, useHex, PAD_DEFAULT);</span>
-<span class="source-line-no">295</span><span id="line-295">    }</span>
-<span class="source-line-no">296</span><span id="line-296"></span>
-<span class="source-line-no">297</span><span id="line-297">    /**</span>
-<span class="source-line-no">298</span><span id="line-298">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
-<span class="source-line-no">299</span><span id="line-299">     * 
&lt;p&gt;</span>
-<span class="source-line-no">300</span><span id="line-300">     * When 
encoding the line length and line separator are given in the constructor.</span>
-<span class="source-line-no">301</span><span id="line-301">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">302</span><span id="line-302">     * 
&lt;p&gt;</span>
-<span class="source-line-no">303</span><span id="line-303">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
-<span class="source-line-no">304</span><span id="line-304">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">305</span><span id="line-305">     *</span>
-<span class="source-line-no">306</span><span id="line-306">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
-<span class="source-line-no">307</span><span id="line-307">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">308</span><span id="line-308">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
-<span class="source-line-no">309</span><span id="line-309">     * @param 
useHex        if {@code true}, then use Base32 Hex alphabet, otherwise use 
Base32 alphabet</span>
-<span class="source-line-no">310</span><span id="line-310">     * @param 
padding       padding byte.</span>
-<span class="source-line-no">311</span><span id="line-311">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
-<span class="source-line-no">312</span><span id="line-312">     */</span>
-<span class="source-line-no">313</span><span id="line-313">    public 
Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, 
final byte padding) {</span>
-<span class="source-line-no">314</span><span id="line-314">        
this(lineLength, lineSeparator, useHex, padding, 
DECODING_POLICY_DEFAULT);</span>
-<span class="source-line-no">315</span><span id="line-315">    }</span>
-<span class="source-line-no">316</span><span id="line-316"></span>
-<span class="source-line-no">317</span><span id="line-317">    /**</span>
-<span class="source-line-no">318</span><span id="line-318">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
-<span class="source-line-no">319</span><span id="line-319">     * 
&lt;p&gt;</span>
-<span class="source-line-no">320</span><span id="line-320">     * When 
encoding the line length and line separator are given in the constructor.</span>
-<span class="source-line-no">321</span><span id="line-321">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">322</span><span id="line-322">     * 
&lt;p&gt;</span>
-<span class="source-line-no">323</span><span id="line-323">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
-<span class="source-line-no">324</span><span id="line-324">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">325</span><span id="line-325">     *</span>
-<span class="source-line-no">326</span><span id="line-326">     * @param 
lineLength     Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
-<span class="source-line-no">327</span><span id="line-327">     *              
         then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">328</span><span id="line-328">     * @param 
lineSeparator  Each line of encoded data will end with this sequence of 
bytes.</span>
-<span class="source-line-no">329</span><span id="line-329">     * @param 
useHex         if {@code true}, then use Base32 Hex alphabet, otherwise use 
Base32 alphabet</span>
-<span class="source-line-no">330</span><span id="line-330">     * @param 
padding        padding byte.</span>
-<span class="source-line-no">331</span><span id="line-331">     * @param 
decodingPolicy The decoding policy.</span>
-<span class="source-line-no">332</span><span id="line-332">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
-<span class="source-line-no">333</span><span id="line-333">     * @since 
1.15</span>
-<span class="source-line-no">334</span><span id="line-334">     */</span>
-<span class="source-line-no">335</span><span id="line-335">    public 
Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, 
final byte padding, final CodecPolicy decodingPolicy) {</span>
-<span class="source-line-no">336</span><span id="line-336">        
this(lineLength, lineSeparator, useHex ? HEX_ENCODE_TABLE : ENCODE_TABLE, 
padding, decodingPolicy);</span>
-<span class="source-line-no">337</span><span id="line-337">    }</span>
-<span class="source-line-no">338</span><span id="line-338"></span>
-<span class="source-line-no">339</span><span id="line-339">    /**</span>
-<span class="source-line-no">340</span><span id="line-340">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
-<span class="source-line-no">341</span><span id="line-341">     * 
&lt;p&gt;</span>
-<span class="source-line-no">342</span><span id="line-342">     * When 
encoding the line length and line separator are given in the constructor.</span>
-<span class="source-line-no">343</span><span id="line-343">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">344</span><span id="line-344">     * 
&lt;p&gt;</span>
-<span class="source-line-no">345</span><span id="line-345">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
-<span class="source-line-no">346</span><span id="line-346">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">347</span><span id="line-347">     *</span>
-<span class="source-line-no">348</span><span id="line-348">     * @param 
lineLength     Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
-<span class="source-line-no">349</span><span id="line-349">     *              
         then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
-<span class="source-line-no">350</span><span id="line-350">     * @param 
lineSeparator  Each line of encoded data will end with this sequence of 
bytes.</span>
-<span class="source-line-no">351</span><span id="line-351">     * @param 
encodeTable    A Base32 alphabet.</span>
-<span class="source-line-no">352</span><span id="line-352">     * @param 
padding        padding byte.</span>
-<span class="source-line-no">353</span><span id="line-353">     * @param 
decodingPolicy The decoding policy.</span>
-<span class="source-line-no">354</span><span id="line-354">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
-<span class="source-line-no">355</span><span id="line-355">     */</span>
-<span class="source-line-no">356</span><span id="line-356">    private 
Base32(final int lineLength, final byte[] lineSeparator, final byte[] 
encodeTable, final byte padding, final CodecPolicy decodingPolicy) {</span>
-<span class="source-line-no">357</span><span id="line-357">        
super(BYTES_PER_UNENCODED_BLOCK, BYTES_PER_ENCODED_BLOCK, lineLength, 
toLength(lineSeparator), padding, decodingPolicy);</span>
-<span class="source-line-no">358</span><span id="line-358">        
Objects.requireNonNull(encodeTable, "encodeTable");</span>
-<span class="source-line-no">359</span><span id="line-359">        
this.encodeTable = encodeTable;</span>
-<span class="source-line-no">360</span><span id="line-360">        
this.decodeTable = encodeTable == HEX_ENCODE_TABLE ? HEX_DECODE_TABLE : 
DECODE_TABLE;</span>
-<span class="source-line-no">361</span><span id="line-361">        if 
(lineLength &gt; 0) {</span>
-<span class="source-line-no">362</span><span id="line-362">            if 
(lineSeparator == null) {</span>
-<span class="source-line-no">363</span><span id="line-363">                
throw new IllegalArgumentException("lineLength " + lineLength + " &gt; 0, but 
lineSeparator is null");</span>
-<span class="source-line-no">364</span><span id="line-364">            }</span>
-<span class="source-line-no">365</span><span id="line-365">            final 
byte[] lineSeparatorCopy = lineSeparator.clone();</span>
-<span class="source-line-no">366</span><span id="line-366">            // Must 
be done after initializing the tables</span>
-<span class="source-line-no">367</span><span id="line-367">            if 
(containsAlphabetOrPad(lineSeparatorCopy)) {</span>
-<span class="source-line-no">368</span><span id="line-368">                
final String sep = StringUtils.newStringUtf8(lineSeparatorCopy);</span>
-<span class="source-line-no">369</span><span id="line-369">                
throw new IllegalArgumentException("lineSeparator must not contain Base32 
characters: [" + sep + "]");</span>
-<span class="source-line-no">370</span><span id="line-370">            }</span>
-<span class="source-line-no">371</span><span id="line-371">            
this.encodeSize = BYTES_PER_ENCODED_BLOCK + lineSeparatorCopy.length;</span>
-<span class="source-line-no">372</span><span id="line-372">            
this.lineSeparator = lineSeparatorCopy;</span>
-<span class="source-line-no">373</span><span id="line-373">        } else 
{</span>
-<span class="source-line-no">374</span><span id="line-374">            
this.encodeSize = BYTES_PER_ENCODED_BLOCK;</span>
-<span class="source-line-no">375</span><span id="line-375">            
this.lineSeparator = null;</span>
-<span class="source-line-no">376</span><span id="line-376">        }</span>
-<span class="source-line-no">377</span><span id="line-377">        if 
(isInAlphabet(padding) || Character.isWhitespace(padding)) {</span>
-<span class="source-line-no">378</span><span id="line-378">            throw 
new IllegalArgumentException("pad must not be in alphabet or 
whitespace");</span>
-<span class="source-line-no">379</span><span id="line-379">        }</span>
-<span class="source-line-no">380</span><span id="line-380">    }</span>
-<span class="source-line-no">381</span><span id="line-381"></span>
-<span class="source-line-no">382</span><span id="line-382">    /**</span>
-<span class="source-line-no">383</span><span id="line-383">     * 
&lt;p&gt;</span>
-<span class="source-line-no">384</span><span id="line-384">     * Decodes all 
of the provided data, starting at inPos, for inAvail bytes. Should be called at 
least twice: once with the data to decode, and once with</span>
-<span class="source-line-no">385</span><span id="line-385">     * inAvail set 
to "-1" to alert decoder that EOF has been reached. The "-1" call is not 
necessary when decoding, but it doesn't hurt, either.</span>
-<span class="source-line-no">386</span><span id="line-386">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">387</span><span id="line-387">     * 
&lt;p&gt;</span>
-<span class="source-line-no">388</span><span id="line-388">     * Ignores all 
non-Base32 characters. This is how chunked (e.g. 76 character) data is handled, 
since CR and LF are silently ignored, but has implications</span>
-<span class="source-line-no">389</span><span id="line-389">     * for other 
bytes, too. This method subscribes to the garbage-in, garbage-out philosophy: 
it will not check the provided data for validity.</span>
-<span class="source-line-no">390</span><span id="line-390">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">391</span><span id="line-391">     * 
&lt;p&gt;</span>
-<span class="source-line-no">392</span><span id="line-392">     * Output is 
written to {@link org.apache.commons.codec.binary.BaseNCodec.Context#buffer 
Context#buffer} as 8-bit octets, using</span>
-<span class="source-line-no">393</span><span id="line-393">     * {@link 
org.apache.commons.codec.binary.BaseNCodec.Context#pos Context#pos} as the 
buffer position</span>
-<span class="source-line-no">394</span><span id="line-394">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">395</span><span id="line-395">     *</span>
-<span class="source-line-no">396</span><span id="line-396">     * @param input 
  byte[] array of ASCII data to Base32 decode.</span>
-<span class="source-line-no">397</span><span id="line-397">     * @param inPos 
  Position to start reading data from.</span>
-<span class="source-line-no">398</span><span id="line-398">     * @param 
inAvail Amount of bytes available from input for decoding.</span>
-<span class="source-line-no">399</span><span id="line-399">     * @param 
context the context to be used</span>
-<span class="source-line-no">400</span><span id="line-400">     */</span>
-<span class="source-line-no">401</span><span id="line-401">    @Override</span>
-<span class="source-line-no">402</span><span id="line-402">    void 
decode(final byte[] input, int inPos, final int inAvail, final Context context) 
{</span>
-<span class="source-line-no">403</span><span id="line-403">        // package 
protected for access from I/O streams</span>
-<span class="source-line-no">404</span><span id="line-404">        if 
(context.eof) {</span>
-<span class="source-line-no">405</span><span id="line-405">            
return;</span>
-<span class="source-line-no">406</span><span id="line-406">        }</span>
-<span class="source-line-no">407</span><span id="line-407">        if (inAvail 
&lt; 0) {</span>
-<span class="source-line-no">408</span><span id="line-408">            
context.eof = true;</span>
-<span class="source-line-no">409</span><span id="line-409">        }</span>
-<span class="source-line-no">410</span><span id="line-410">        final int 
decodeSize = this.encodeSize - 1;</span>
-<span class="source-line-no">411</span><span id="line-411">        for (int i 
= 0; i &lt; inAvail; i++) {</span>
-<span class="source-line-no">412</span><span id="line-412">            final 
byte b = input[inPos++];</span>
-<span class="source-line-no">413</span><span id="line-413">            if (b 
== pad) {</span>
-<span class="source-line-no">414</span><span id="line-414">                // 
We're done.</span>
-<span class="source-line-no">415</span><span id="line-415">                
context.eof = true;</span>
-<span class="source-line-no">416</span><span id="line-416">                
break;</span>
-<span class="source-line-no">417</span><span id="line-417">            }</span>
-<span class="source-line-no">418</span><span id="line-418">            final 
byte[] buffer = ensureBufferSize(decodeSize, context);</span>
-<span class="source-line-no">419</span><span id="line-419">            if (b 
&gt;= 0 &amp;&amp; b &lt; this.decodeTable.length) {</span>
-<span class="source-line-no">420</span><span id="line-420">                
final int result = this.decodeTable[b];</span>
-<span class="source-line-no">421</span><span id="line-421">                if 
(result &gt;= 0) {</span>
-<span class="source-line-no">422</span><span id="line-422">                    
context.modulus = (context.modulus + 1) % BYTES_PER_ENCODED_BLOCK;</span>
-<span class="source-line-no">423</span><span id="line-423">                    
// collect decoded bytes</span>
-<span class="source-line-no">424</span><span id="line-424">                    
context.lbitWorkArea = (context.lbitWorkArea &lt;&lt; BITS_PER_ENCODED_BYTE) + 
result;</span>
-<span class="source-line-no">425</span><span id="line-425">                    
if (context.modulus == 0) { // we can output the 5 bytes</span>
-<span class="source-line-no">426</span><span id="line-426">                    
    buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 32 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">427</span><span id="line-427">                    
    buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 24 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">428</span><span id="line-428">                    
    buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 16 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">429</span><span id="line-429">                    
    buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 8 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">430</span><span id="line-430">                    
    buffer[context.pos++] = (byte) (context.lbitWorkArea &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">431</span><span id="line-431">                    
}</span>
-<span class="source-line-no">432</span><span id="line-432">                
}</span>
-<span class="source-line-no">433</span><span id="line-433">            }</span>
-<span class="source-line-no">434</span><span id="line-434">        }</span>
-<span class="source-line-no">435</span><span id="line-435">        // Two 
forms of EOF as far as Base32 decoder is concerned: actual</span>
-<span class="source-line-no">436</span><span id="line-436">        // EOF (-1) 
and first time '=' character is encountered in stream.</span>
-<span class="source-line-no">437</span><span id="line-437">        // This 
approach makes the '=' padding characters completely optional.</span>
-<span class="source-line-no">438</span><span id="line-438">        if 
(context.eof &amp;&amp; context.modulus &gt; 0) { // if modulus == 0, nothing 
to do</span>
-<span class="source-line-no">439</span><span id="line-439">            final 
byte[] buffer = ensureBufferSize(decodeSize, context);</span>
-<span class="source-line-no">440</span><span id="line-440">            // We 
ignore partial bytes, i.e. only multiples of 8 count.</span>
-<span class="source-line-no">441</span><span id="line-441">            // Any 
combination not part of a valid encoding is either partially decoded</span>
-<span class="source-line-no">442</span><span id="line-442">            // or 
will raise an exception. Possible trailing characters are 2, 4, 5, 7.</span>
-<span class="source-line-no">443</span><span id="line-443">            // It 
is not possible to encode with 1, 3, 6 trailing characters.</span>
-<span class="source-line-no">444</span><span id="line-444">            // For 
backwards compatibility 3 &amp; 6 chars are decoded anyway rather than 
discarded.</span>
-<span class="source-line-no">445</span><span id="line-445">            // See 
the encode(byte[]) method EOF section.</span>
-<span class="source-line-no">446</span><span id="line-446">            switch 
(context.modulus) {</span>
-<span class="source-line-no">447</span><span id="line-447">//              
case 0 : // impossible, as excluded above</span>
-<span class="source-line-no">448</span><span id="line-448">            case 1: 
// 5 bits - either ignore entirely, or raise an exception</span>
-<span class="source-line-no">449</span><span id="line-449">                
validateTrailingCharacters();</span>
-<span class="source-line-no">450</span><span id="line-450">            case 2: 
// 10 bits, drop 2 and output one byte</span>
-<span class="source-line-no">451</span><span id="line-451">                
validateCharacter(MASK_2BITS, context);</span>
-<span class="source-line-no">452</span><span id="line-452">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 2 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">453</span><span id="line-453">                
break;</span>
-<span class="source-line-no">454</span><span id="line-454">            case 3: 
// 15 bits, drop 7 and output 1 byte, or raise an exception</span>
-<span class="source-line-no">455</span><span id="line-455">                
validateTrailingCharacters();</span>
-<span class="source-line-no">456</span><span id="line-456">                // 
Not possible from a valid encoding but decode anyway</span>
-<span class="source-line-no">457</span><span id="line-457">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 7 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">458</span><span id="line-458">                
break;</span>
-<span class="source-line-no">459</span><span id="line-459">            case 4: 
// 20 bits = 2*8 + 4</span>
-<span class="source-line-no">460</span><span id="line-460">                
validateCharacter(MASK_4BITS, context);</span>
-<span class="source-line-no">461</span><span id="line-461">                
context.lbitWorkArea = context.lbitWorkArea &gt;&gt; 4; // drop 4 bits</span>
-<span class="source-line-no">462</span><span id="line-462">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 8 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">463</span><span id="line-463">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &amp; MASK_8BITS);</span>
-<span class="source-line-no">464</span><span id="line-464">                
break;</span>
-<span class="source-line-no">465</span><span id="line-465">            case 5: 
// 25 bits = 3*8 + 1</span>
-<span class="source-line-no">466</span><span id="line-466">                
validateCharacter(MASK_1BITS, context);</span>
-<span class="source-line-no">467</span><span id="line-467">                
context.lbitWorkArea = context.lbitWorkArea &gt;&gt; 1;</span>
-<span class="source-line-no">468</span><span id="line-468">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 16 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">469</span><span id="line-469">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 8 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">470</span><span id="line-470">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &amp; MASK_8BITS);</span>
-<span class="source-line-no">471</span><span id="line-471">                
break;</span>
-<span class="source-line-no">472</span><span id="line-472">            case 6: 
// 30 bits = 3*8 + 6, or raise an exception</span>
-<span class="source-line-no">473</span><span id="line-473">                
validateTrailingCharacters();</span>
-<span class="source-line-no">474</span><span id="line-474">                // 
Not possible from a valid encoding but decode anyway</span>
-<span class="source-line-no">475</span><span id="line-475">                
context.lbitWorkArea = context.lbitWorkArea &gt;&gt; 6;</span>
-<span class="source-line-no">476</span><span id="line-476">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 16 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">477</span><span id="line-477">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 8 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">478</span><span id="line-478">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &amp; MASK_8BITS);</span>
-<span class="source-line-no">479</span><span id="line-479">                
break;</span>
-<span class="source-line-no">480</span><span id="line-480">            case 7: 
// 35 bits = 4*8 +3</span>
-<span class="source-line-no">481</span><span id="line-481">                
validateCharacter(MASK_3BITS, context);</span>
-<span class="source-line-no">482</span><span id="line-482">                
context.lbitWorkArea = context.lbitWorkArea &gt;&gt; 3;</span>
-<span class="source-line-no">483</span><span id="line-483">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 24 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">484</span><span id="line-484">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 16 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">485</span><span id="line-485">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &gt;&gt; 8 &amp; 
MASK_8BITS);</span>
-<span class="source-line-no">486</span><span id="line-486">                
buffer[context.pos++] = (byte) (context.lbitWorkArea &amp; MASK_8BITS);</span>
-<span class="source-line-no">487</span><span id="line-487">                
break;</span>
-<span class="source-line-no">488</span><span id="line-488">            
default:</span>
-<span class="source-line-no">489</span><span id="line-489">                // 
modulus can be 0-7, and we excluded 0,1 already</span>
-<span class="source-line-no">490</span><span id="line-490">                
throw new IllegalStateException("Impossible modulus " + context.modulus);</span>
-<span class="source-line-no">491</span><span id="line-491">            }</span>
-<span class="source-line-no">492</span><span id="line-492">        }</span>
-<span class="source-line-no">493</span><span id="line-493">    }</span>
-<span class="source-line-no">494</span><span id="line-494"></span>
-<span class="source-line-no">495</span><span id="line-495">    /**</span>
-<span class="source-line-no">496</span><span id="line-496">     * 
&lt;p&gt;</span>
-<span class="source-line-no">497</span><span id="line-497">     * Encodes all 
of the provided data, starting at inPos, for inAvail bytes. Must be called at 
least twice: once with the data to encode, and once with</span>
-<span class="source-line-no">498</span><span id="line-498">     * inAvail set 
to "-1" to alert encoder that EOF has been reached, so flush last remaining 
bytes (if not multiple of 5).</span>
-<span class="source-line-no">499</span><span id="line-499">     * 
&lt;/p&gt;</span>
-<span class="source-line-no">500</span><span id="line-500">     *</span>
-<span class="source-line-no">501</span><span id="line-501">     * @param input 
  byte[] array of binary data to Base32 encode.</span>
-<span class="source-line-no">502</span><span id="line-502">     * @param inPos 
  Position to start reading data from.</span>
-<span class="source-line-no">503</span><span id="line-503">     * @param 
inAvail Amount of bytes available from input for encoding.</span>
-<span class="source-line-no">504</span><span id="line-504">     * @param 
context the context to be used</span>
-<span class="source-line-no">505</span><span id="line-505">     */</span>
-<span class="source-line-no">506</span><span id="line-506">    @Override</span>
-<span class="source-line-no">507</span><span id="line-507">    void 
encode(final byte[] input, int inPos, final int inAvail, final Context context) 
{</span>
-<span class="source-line-no">508</span><span id="line-508">        // package 
protected for access from I/O streams</span>
-<span class="source-line-no">509</span><span id="line-509">        if 
(context.eof) {</span>
-<span class="source-line-no">510</span><span id="line-510">            
return;</span>
-<span class="source-line-no">511</span><span id="line-511">        }</span>
-<span class="source-line-no">512</span><span id="line-512">        // inAvail 
&lt; 0 is how we're informed of EOF in the underlying data we're</span>
-<span class="source-line-no">513</span><span id="line-513">        // 
encoding.</span>
-<span class="source-line-no">514</span><span id="line-514">        if (inAvail 
&lt; 0) {</span>
-<span class="source-line-no">515</span><span id="line-515">            
context.eof = true;</span>
-<span class="source-line-no">516</span><span id="line-516">            if (0 
== context.modulus &amp;&amp; lineLength == 0) {</span>
-<span class="source-line-no">517</span><span id="line-517">                
return; // no leftovers to process and not using chunking</span>
-<span class="source-line-no">518</span><span id="line-518">            }</span>
-<span class="source-line-no">519</span><span id="line-519">            final 
byte[] buffer = ensureBufferSize(encodeSize, context);</span>
-<span class="source-line-no">520</span><span id="line-520">            final 
int savedPos = context.pos;</span>
-<span class="source-line-no">521</span><span id="line-521">            switch 
(context.modulus) { // % 5</span>
-<span class="source-line-no">522</span><span id="line-522">            case 
0:</span>
-<span class="source-line-no">523</span><span id="line-523">                
break;</span>
-<span class="source-line-no">524</span><span id="line-524">            case 1: 
// Only 1 octet; take top 5 bits then remainder</span>
-<span class="source-line-no">525</span><span id="line-525">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 3) 
&amp; MASK_5BITS]; // 8-1*5 = 3</span>
-<span class="source-line-no">526</span><span id="line-526">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &lt;&lt; 2) 
&amp; MASK_5BITS]; // 5-3=2</span>
-<span class="source-line-no">527</span><span id="line-527">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">528</span><span id="line-528">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">529</span><span id="line-529">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">530</span><span id="line-530">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">531</span><span id="line-531">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">532</span><span id="line-532">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">533</span><span id="line-533">                
break;</span>
-<span class="source-line-no">534</span><span id="line-534">            case 2: 
// 2 octets = 16 bits to use</span>
-<span class="source-line-no">535</span><span id="line-535">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 11) 
&amp; MASK_5BITS]; // 16-1*5 = 11</span>
-<span class="source-line-no">536</span><span id="line-536">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 6) 
&amp; MASK_5BITS]; // 16-2*5 = 6</span>
-<span class="source-line-no">537</span><span id="line-537">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 1) 
&amp; MASK_5BITS]; // 16-3*5 = 1</span>
-<span class="source-line-no">538</span><span id="line-538">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &lt;&lt; 4) 
&amp; MASK_5BITS]; // 5-1 = 4</span>
-<span class="source-line-no">539</span><span id="line-539">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">540</span><span id="line-540">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">541</span><span id="line-541">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">542</span><span id="line-542">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">543</span><span id="line-543">                
break;</span>
-<span class="source-line-no">544</span><span id="line-544">            case 3: 
// 3 octets = 24 bits to use</span>
-<span class="source-line-no">545</span><span id="line-545">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 19) 
&amp; MASK_5BITS]; // 24-1*5 = 19</span>
-<span class="source-line-no">546</span><span id="line-546">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 14) 
&amp; MASK_5BITS]; // 24-2*5 = 14</span>
-<span class="source-line-no">547</span><span id="line-547">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 9) 
&amp; MASK_5BITS]; // 24-3*5 = 9</span>
-<span class="source-line-no">548</span><span id="line-548">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 4) 
&amp; MASK_5BITS]; // 24-4*5 = 4</span>
-<span class="source-line-no">549</span><span id="line-549">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &lt;&lt; 1) 
&amp; MASK_5BITS]; // 5-4 = 1</span>
-<span class="source-line-no">550</span><span id="line-550">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">551</span><span id="line-551">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">552</span><span id="line-552">                
buffer[context.pos++] = pad;</span>
-<span class="source-line-no">553</span><span id="line-553">                
break;</span>
-<span class="source-line-no">554</span><span id="line-554">            case 4: 
// 4 octets = 32 bits to use</span>
-<span class="source-line-no">555</span><span id="line-555">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 27) 
&amp; MASK_5BITS]; // 32-1*5 = 27</span>
-<span class="source-line-no">556</span><span id="line-556">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 22) 
&amp; MASK_5BITS]; // 32-2*5 = 22</span>
-<span class="source-line-no">557</span><span id="line-557">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 17) 
&amp; MASK_5BITS]; // 32-3*5 = 17</span>
-<span class="source-line-no">558</span><span id="line-558">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 12) 
&amp; MASK_5BITS]; // 32-4*5 = 12</span>
-<span class="source-line-no">559</span><span id="line-559">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 7) 
&amp; MASK_5BITS]; // 32-5*5 = 7</span>
-<span class="source-line-no">560</span><span id="line-560">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &gt;&gt; 2) 
&amp; MASK_5BITS]; // 32-6*5 = 2</span>
-<span class="source-line-no">561</span><span id="line-561">                
buffer[context.pos++] = encodeTable[(int) (context.lbitWorkArea &lt;&lt; 3) 
&amp; MASK_5BITS]; // 5-2 = 3</span>
+<span class="source-line-no">240</span><span id="line-240">     */</span>
+<span class="source-line-no">241</span><span id="line-241">    public Base32() 
{</span>
+<span class="source-line-no">242</span><span id="line-242">        
this(false);</span>
+<span class="source-line-no">243</span><span id="line-243">    }</span>
+<span class="source-line-no">244</span><span id="line-244"></span>
+<span class="source-line-no">245</span><span id="line-245">    /**</span>
+<span class="source-line-no">246</span><span id="line-246">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
+<span class="source-line-no">247</span><span id="line-247">     * 
&lt;p&gt;</span>
+<span class="source-line-no">248</span><span id="line-248">     * When 
encoding the line length is 0 (no chunking).</span>
+<span class="source-line-no">249</span><span id="line-249">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">250</span><span id="line-250">     *</span>
+<span class="source-line-no">251</span><span id="line-251">     * @param 
useHex if {@code true} then use Base32 Hex alphabet</span>
+<span class="source-line-no">252</span><span id="line-252">     */</span>
+<span class="source-line-no">253</span><span id="line-253">    public 
Base32(final boolean useHex) {</span>
+<span class="source-line-no">254</span><span id="line-254">        this(0, 
null, useHex, PAD_DEFAULT);</span>
+<span class="source-line-no">255</span><span id="line-255">    }</span>
+<span class="source-line-no">256</span><span id="line-256"></span>
+<span class="source-line-no">257</span><span id="line-257">    /**</span>
+<span class="source-line-no">258</span><span id="line-258">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
+<span class="source-line-no">259</span><span id="line-259">     * 
&lt;p&gt;</span>
+<span class="source-line-no">260</span><span id="line-260">     * When 
encoding the line length is 0 (no chunking).</span>
+<span class="source-line-no">261</span><span id="line-261">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">262</span><span id="line-262">     *</span>
+<span class="source-line-no">263</span><span id="line-263">     * @param 
useHex  if {@code true} then use Base32 Hex alphabet</span>
+<span class="source-line-no">264</span><span id="line-264">     * @param 
padding byte used as padding byte.</span>
+<span class="source-line-no">265</span><span id="line-265">     */</span>
+<span class="source-line-no">266</span><span id="line-266">    public 
Base32(final boolean useHex, final byte padding) {</span>
+<span class="source-line-no">267</span><span id="line-267">        this(0, 
null, useHex, padding);</span>
+<span class="source-line-no">268</span><span id="line-268">    }</span>
+<span class="source-line-no">269</span><span id="line-269"></span>
+<span class="source-line-no">270</span><span id="line-270">    /**</span>
+<span class="source-line-no">271</span><span id="line-271">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
+<span class="source-line-no">272</span><span id="line-272">     * 
&lt;p&gt;</span>
+<span class="source-line-no">273</span><span id="line-273">     * When 
encoding the line length is 0 (no chunking).</span>
+<span class="source-line-no">274</span><span id="line-274">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">275</span><span id="line-275">     *</span>
+<span class="source-line-no">276</span><span id="line-276">     * @param pad 
byte used as padding byte.</span>
+<span class="source-line-no">277</span><span id="line-277">     */</span>
+<span class="source-line-no">278</span><span id="line-278">    public 
Base32(final byte pad) {</span>
+<span class="source-line-no">279</span><span id="line-279">        this(false, 
pad);</span>
+<span class="source-line-no">280</span><span id="line-280">    }</span>
+<span class="source-line-no">281</span><span id="line-281"></span>
+<span class="source-line-no">282</span><span id="line-282">    /**</span>
+<span class="source-line-no">283</span><span id="line-283">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
+<span class="source-line-no">284</span><span id="line-284">     * 
&lt;p&gt;</span>
+<span class="source-line-no">285</span><span id="line-285">     * When 
encoding the line length is given in the constructor, the line separator is 
CRLF.</span>
+<span class="source-line-no">286</span><span id="line-286">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">287</span><span id="line-287">     *</span>
+<span class="source-line-no">288</span><span id="line-288">     * @param 
lineLength Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0, 
then</span>
+<span class="source-line-no">289</span><span id="line-289">     *              
     the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
+<span class="source-line-no">290</span><span id="line-290">     */</span>
+<span class="source-line-no">291</span><span id="line-291">    public 
Base32(final int lineLength) {</span>
+<span class="source-line-no">292</span><span id="line-292">        
this(lineLength, CHUNK_SEPARATOR);</span>
+<span class="source-line-no">293</span><span id="line-293">    }</span>
+<span class="source-line-no">294</span><span id="line-294"></span>
+<span class="source-line-no">295</span><span id="line-295">    /**</span>
+<span class="source-line-no">296</span><span id="line-296">     * Constructs a 
Base32 codec used for decoding and encoding.</span>
+<span class="source-line-no">297</span><span id="line-297">     * 
&lt;p&gt;</span>
+<span class="source-line-no">298</span><span id="line-298">     * When 
encoding the line length and line separator are given in the constructor.</span>
+<span class="source-line-no">299</span><span id="line-299">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">300</span><span id="line-300">     * 
&lt;p&gt;</span>
+<span class="source-line-no">301</span><span id="line-301">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
+<span class="source-line-no">302</span><span id="line-302">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">303</span><span id="line-303">     *</span>
+<span class="source-line-no">304</span><span id="line-304">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
+<span class="source-line-no">305</span><span id="line-305">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
+<span class="source-line-no">306</span><span id="line-306">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
+<span class="source-line-no">307</span><span id="line-307">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters.</span>
+<span class="source-line-no">308</span><span id="line-308">     */</span>
+<span class="source-line-no">309</span><span id="line-309">    public 
Base32(final int lineLength, final byte[] lineSeparator) {</span>
+<span class="source-line-no">310</span><span id="line-310">        
this(lineLength, lineSeparator, false, PAD_DEFAULT);</span>
+<span class="source-line-no">311</span><span id="line-311">    }</span>
+<span class="source-line-no">312</span><span id="line-312"></span>
+<span class="source-line-no">313</span><span id="line-313">    /**</span>
+<span class="source-line-no">314</span><span id="line-314">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
+<span class="source-line-no">315</span><span id="line-315">     * 
&lt;p&gt;</span>
+<span class="source-line-no">316</span><span id="line-316">     * When 
encoding the line length and line separator are given in the constructor.</span>
+<span class="source-line-no">317</span><span id="line-317">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">318</span><span id="line-318">     * 
&lt;p&gt;</span>
+<span class="source-line-no">319</span><span id="line-319">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
+<span class="source-line-no">320</span><span id="line-320">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">321</span><span id="line-321">     *</span>
+<span class="source-line-no">322</span><span id="line-322">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
+<span class="source-line-no">323</span><span id="line-323">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
+<span class="source-line-no">324</span><span id="line-324">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
+<span class="source-line-no">325</span><span id="line-325">     * @param 
useHex        if {@code true}, then use Base32 Hex alphabet, otherwise use 
Base32 alphabet</span>
+<span class="source-line-no">326</span><span id="line-326">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
+<span class="source-line-no">327</span><span id="line-327">     */</span>
+<span class="source-line-no">328</span><span id="line-328">    public 
Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex) 
{</span>
+<span class="source-line-no">329</span><span id="line-329">        
this(lineLength, lineSeparator, useHex, PAD_DEFAULT);</span>
+<span class="source-line-no">330</span><span id="line-330">    }</span>
+<span class="source-line-no">331</span><span id="line-331"></span>
+<span class="source-line-no">332</span><span id="line-332">    /**</span>
+<span class="source-line-no">333</span><span id="line-333">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
+<span class="source-line-no">334</span><span id="line-334">     * 
&lt;p&gt;</span>
+<span class="source-line-no">335</span><span id="line-335">     * When 
encoding the line length and line separator are given in the constructor.</span>
+<span class="source-line-no">336</span><span id="line-336">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">337</span><span id="line-337">     * 
&lt;p&gt;</span>
+<span class="source-line-no">338</span><span id="line-338">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
+<span class="source-line-no">339</span><span id="line-339">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">340</span><span id="line-340">     *</span>
+<span class="source-line-no">341</span><span id="line-341">     * @param 
lineLength    Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>
+<span class="source-line-no">342</span><span id="line-342">     *              
        then the output will not be divided into lines (chunks). Ignored when 
decoding.</span>
+<span class="source-line-no">343</span><span id="line-343">     * @param 
lineSeparator Each line of encoded data will end with this sequence of 
bytes.</span>
+<span class="source-line-no">344</span><span id="line-344">     * @param 
useHex        if {@code true}, then use Base32 Hex alphabet, otherwise use 
Base32 alphabet</span>
+<span class="source-line-no">345</span><span id="line-345">     * @param 
padding       padding byte.</span>
+<span class="source-line-no">346</span><span id="line-346">     * @throws 
IllegalArgumentException Thrown when the {@code lineSeparator} contains Base32 
characters. Or the lineLength &amp;gt; 0 and lineSeparator is null.</span>
+<span class="source-line-no">347</span><span id="line-347">     */</span>
+<span class="source-line-no">348</span><span id="line-348">    public 
Base32(final int lineLength, final byte[] lineSeparator, final boolean useHex, 
final byte padding) {</span>
+<span class="source-line-no">349</span><span id="line-349">        
this(lineLength, lineSeparator, useHex, padding, 
DECODING_POLICY_DEFAULT);</span>
+<span class="source-line-no">350</span><span id="line-350">    }</span>
+<span class="source-line-no">351</span><span id="line-351"></span>
+<span class="source-line-no">352</span><span id="line-352">    /**</span>
+<span class="source-line-no">353</span><span id="line-353">     * Constructs a 
Base32 / Base32 Hex codec used for decoding and encoding.</span>
+<span class="source-line-no">354</span><span id="line-354">     * 
&lt;p&gt;</span>
+<span class="source-line-no">355</span><span id="line-355">     * When 
encoding the line length and line separator are given in the constructor.</span>
+<span class="source-line-no">356</span><span id="line-356">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">357</span><span id="line-357">     * 
&lt;p&gt;</span>
+<span class="source-line-no">358</span><span id="line-358">     * Line lengths 
that aren't multiples of 8 will still essentially end up being multiples of 8 
in the encoded data.</span>
+<span class="source-line-no">359</span><span id="line-359">     * 
&lt;/p&gt;</span>
+<span class="source-line-no">360</span><span id="line-360">     *</span>
+<span class="source-line-no">361</span><span id="line-361">     * @param 
lineLength     Each line of encoded data will be at most of the given length 
(rounded down to the nearest multiple of 8). If lineLength &amp;lt;= 0,</span>

[... 420 lines stripped ...]