commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ggreg...@apache.org
Subject svn commit: r795284 - in /commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary: Base64.java Base64InputStream.java Base64OutputStream.java
Date Sat, 18 Jul 2009 00:36:44 GMT
Author: ggregory
Date: Sat Jul 18 00:36:43 2009
New Revision: 795284

URL: http://svn.apache.org/viewvc?rev=795284&view=rev
Log:
[CODEC-58] Character set used by Base64 not documented. Apply modified patch. Better Javadocs.
Changes to private field "buf" rename to "buffer". Rename private method "resizeBuf" to "resizeBuffer"

Modified:
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64.java
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64InputStream.java
    commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64OutputStream.java

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64.java?rev=795284&r1=795283&r2=795284&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64.java (original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64.java Sat Jul
18 00:36:43 2009
@@ -32,6 +32,19 @@
  * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite>
from RFC 2045 <cite>Multipurpose
  * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite>
by Freed and Borenstein.
  * </p>
+ * <p>
+ * The class can be parameterized in the following manner with various constructors:
+ * <ul>
+ * <li>URL-safe mode: Default off.</li>
+ * <li>Line length: Default 76. Line length that aren't multiples of 4 will still essentially
end up being multiples of 4 in the
+ * encoded data. 
+ * <li>Line separator: Default is CRLF ("\r\n")</li>
+ * </ul>
+ * </p>
+ * <p>
+ * Since this class operates directly on byte streams, and not character streams, it is hard-coded
to only encode/decode
+ * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252,
UTF-8, etc).
+ * </p>
  * 
  * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>
  * @author Apache Software Foundation
@@ -39,6 +52,10 @@
  * @version $Id$
  */
 public class Base64 implements BinaryEncoder, BinaryDecoder {
+    private static final int DEFAULT_BUFFER_RESIZE_FACTOR = 2;
+
+    private static final int DEFAULT_BUFFER_SIZE = 8192;
+
     /**
      * Chunk size per RFC 2045 section 6.8.
      * 
@@ -56,7 +73,7 @@
      * 
      * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a>
      */
-    static final byte[] CHUNK_SEPARATOR = {'\r','\n'};
+    static final byte[] CHUNK_SEPARATOR = {'\r', '\n'};
 
     /**
      * This array is a lookup table that translates 6-bit positive integer
@@ -127,39 +144,39 @@
     // some state be preserved between calls of encode() and decode().
 
     /**
-     * Encode table to use:  either STANDARD or URL_SAFE.  Note:  the DECODE_TABLE above
remains static
-     * because it is able to decode both STANDARD and URL_SAFE streams, but the encodeTable
must be a member
-     * variable so we can switch between the two modes.
+     * Encode table to use: either STANDARD or URL_SAFE. Note: the DECODE_TABLE above remains
static because it is able
+     * to decode both STANDARD and URL_SAFE streams, but the encodeTable must be a member
variable so we can switch
+     * between the two modes.
      */
     private final byte[] encodeTable;
 
     /**
-     * Line length for encoding.  Not used when decoding.  A value of zero or less implies
-     * no chunking of the base64 encoded data.
+     * Line length for encoding. Not used when decoding. A value of zero or less implies
no chunking of the base64
+     * encoded data.
      */
     private final int lineLength;
 
     /**
-     * Line separator for encoding.  Not used when decoding.  Only used if lineLength >
0.
+     * Line separator for encoding. Not used when decoding. Only used if lineLength >
0.
      */
     private final byte[] lineSeparator;
 
     /**
-     * Convenience variable to help us determine when our buffer is going to run out of
-     * room and needs resizing.  <code>decodeSize = 3 + lineSeparator.length;</code>
+     * Convenience variable to help us determine when our buffer is going to run out of room
and needs resizing.
+     * <code>decodeSize = 3 + lineSeparator.length;</code>
      */
     private final int decodeSize;
 
     /**
-     * Convenience variable to help us determine when our buffer is going to run out of
-     * room and needs resizing.  <code>encodeSize = 4 + lineSeparator.length;</code>
+     * Convenience variable to help us determine when our buffer is going to run out of room
and needs resizing.
+     * <code>encodeSize = 4 + lineSeparator.length;</code>
      */
     private final int encodeSize;
 
     /**
-     * Buffer for streaming. 
+     * Buffer for streaming.
      */
-    private byte[] buf;
+    private byte[] buffer;
 
     /**
      * Position where next character should be written in the buffer.
@@ -172,39 +189,37 @@
     private int readPos;
 
     /**
-     * Variable tracks how many characters have been written to the current line.
-     * Only used when encoding.  We use it to make sure each encoded line never
-     * goes beyond lineLength (if lineLength > 0).
+     * Variable tracks how many characters have been written to the current line. Only used
when encoding. We use it to
+     * make sure each encoded line never goes beyond lineLength (if lineLength > 0).
      */
     private int currentLinePos;
 
     /**
-     * Writes to the buffer only occur after every 3 reads when encoding, an
-     * every 4 reads when decoding.  This variable helps track that.
+     * Writes to the buffer only occur after every 3 reads when encoding, an every 4 reads
when decoding. This variable
+     * helps track that.
      */
     private int modulus;
 
     /**
-     * Boolean flag to indicate the EOF has been reached.  Once EOF has been
-     * reached, this Base64 object becomes useless, and must be thrown away.
+     * Boolean flag to indicate the EOF has been reached. Once EOF has been reached, this
Base64 object becomes useless,
+     * and must be thrown away.
      */
     private boolean eof;
 
     /**
-     * Place holder for the 3 bytes we're dealing with for our base64 logic.
-     * Bitwise operations store and extract the base64 encoding or decoding from
-     * this variable.
+     * Place holder for the 3 bytes we're dealing with for our base64 logic. Bitwise operations
store and extract the
+     * base64 encoding or decoding from this variable.
      */
     private int x;
 
     /**
-     * Sets state for decoding and encoding.
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
      * <p>
-     * When encoding the line length is 76, the line separator is CRLF, and we use the STANDARD_ENCODE_TABLE.
+     * When encoding the line length is 76, the line separator is CRLF, and the encoding
table is STANDARD_ENCODE_TABLE.
      * </p>
      * 
      * <p>
-     * When decoding all variants can be decoded.
+     * When decoding all variants are supported.
      * </p>
      */
     public Base64() {
@@ -212,13 +227,17 @@
     }
 
     /**
-     * Same as default constructor (line length is 76, line separator is CRLF), but URL-SAFE
mode for encoding is
-     * supplied.
+     * Creates a Base64 codec used for decoding (all modes) and encoding in the given URL-safe
mode.
+     * <p>
+     * When encoding the line length is 76, the line separator is CRLF, and the encoding
table is STANDARD_ENCODE_TABLE.
+     * </p>
      * 
-     * When decoding: all variants can be decoded.
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
      * 
      * @param urlSafe
-     *            true if URL-SAFE encoding should be performed. In most situations this
should be set to false.
+     *            if <code>true</code>, URL-safe encoding is used. In most cases
this should be set to <code>false</code>.
      * @since 1.4
      */
     public Base64(boolean urlSafe) {
@@ -226,17 +245,21 @@
     }
 
     /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
+     * <p>
+     * When encoding the line length is given in the constructor, the line separator is CRLF,
and the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
      * <p>
-     * Sets the line length when encoding (line separator is still CRLF). All forms of data
can be decoded.
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples
of 4 in the encoded data.
      * </p>
      * <p>
-     * Note: line lengths that aren't multiples of 4 will still essentially end up being
multiples of 4 in the encoded
-     * data.
+     * When decoding all variants are supported.
      * </p>
      * 
      * @param lineLength
-     *            each line of encoded data will be at most this long (rounded up to nearest
multiple of 4). If
-     *            lineLength <= 0, then the output will not be divided into lines (chunks).
Ignored when decoding.
+     *            Each line of encoded data will be at most of the given length (rounded
up to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks).
Ignored when decoding.
      * @since 1.4
      */
     public Base64(int lineLength) {
@@ -244,21 +267,25 @@
     }
 
     /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
      * <p>
-     * Sets the line length and line separator when encoding. All forms of data can be decoded.
+     * When encoding the line length and line separator are given in the constructor, and
the encoding table is
+     * STANDARD_ENCODE_TABLE.
      * </p>
      * <p>
-     * Note: line lengths that aren't multiples of 4 will still essentially end up being
multiples of 4 in the encoded
-     * data.
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples
of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
      * </p>
      * 
      * @param lineLength
-     *            Each line of encoded data will be at most this long (rounded up to nearest
multiple of 4). Ignored
-     *            when decoding. If <= 0, then output will not be divided into lines (chunks).
+     *            Each line of encoded data will be at most of the given length (rounded
up to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks).
Ignored when decoding.
      * @param lineSeparator
      *            Each line of encoded data will end with this sequence of bytes.
      * @throws IllegalArgumentException
-     *             The provided lineSeparator included some base64 characters. That's not
going to work!
+     *             Thrown when the provided lineSeparator included some base64 characters.

      * @since 1.4
      */
     public Base64(int lineLength, byte[] lineSeparator) {
@@ -266,26 +293,28 @@
     }
 
     /**
+     * Creates a Base64 codec used for decoding (all modes) and encoding in URL-unsafe mode.
      * <p>
-     * Consumer can use this constructor to choose a different lineLength,
-     * lineSeparator, and whether to use URL-SAFE mode when encoding.
-     * All forms of data can be decoded.
-     * </p><p>
-     * Note:  lineLengths that aren't multiples of 4 will still essentially
-     * end up being multiples of 4 in the encoded data.
-     * </p>
-     * @param lineLength    Each line of encoded data will be at most this long
-     *                      (rounded up to nearest multiple of 4).  Ignored when decoding.
-     *                      If <= 0, then output will not be divided into lines (chunks).
-     * @param lineSeparator Each line of encoded data will end with this
-     *                      sequence of bytes.
-     *                      If lineLength <= 0, then the lineSeparator is not used.
-     * @param urlSafe       Instead of emitting '+' and '/' we emit '-' and '_' respectively.
-     *                      urlSafe is only applied to "encode" operations.  Decoding seamlessly
-     *                      handles both modes.
-     *
-     * @throws IllegalArgumentException The provided lineSeparator included
-     *                                  some base64 characters.  That's not going to work!
+     * When encoding the line length and line separator are given in the constructor, and
the encoding table is
+     * STANDARD_ENCODE_TABLE.
+     * </p>
+     * <p>
+     * Line lengths that aren't multiples of 4 will still essentially end up being multiples
of 4 in the encoded data.
+     * </p>
+     * <p>
+     * When decoding all variants are supported.
+     * </p>
+     * 
+     * @param lineLength
+     *            Each line of encoded data will be at most of the given length (rounded
up to nearest multiple of 4).
+     *            If lineLength <= 0, then the output will not be divided into lines (chunks).
Ignored when decoding.
+     * @param lineSeparator
+     *            Each line of encoded data will end with this sequence of bytes.
+     * @param urlSafe
+     *            Instead of emitting '+' and '/' we emit '-' and '_' respectively. urlSafe
is only applied to encode
+     *            operations. Decoding seamlessly handles both modes.
+     * @throws IllegalArgumentException
+     *             The provided lineSeparator included some base64 characters. That's not
going to work!
      * @since 1.4
      */
     public Base64(int lineLength, byte[] lineSeparator, boolean urlSafe) {
@@ -326,7 +355,7 @@
      * @return true if there is Base64 object still available for reading.
      */
     boolean hasData() {
-        return this.buf != null;
+        return this.buffer != null;
     }
 
     /**
@@ -335,47 +364,47 @@
      * @return The amount of buffered data available for reading.
      */
     int avail() {
-        return buf != null ? pos - readPos : 0;
+        return buffer != null ? pos - readPos : 0;
     }
 
     /** Doubles our buffer. */
-    private void resizeBuf() {
-        if (buf == null) {
-            buf = new byte[8192];
+    private void resizeBuffer() {
+        if (buffer == null) {
+            buffer = new byte[DEFAULT_BUFFER_SIZE];
             pos = 0;
             readPos = 0;
         } else {
-            byte[] b = new byte[buf.length * 2];
-            System.arraycopy(buf, 0, b, 0, buf.length);
-            buf = b;
+            byte[] b = new byte[buffer.length * DEFAULT_BUFFER_RESIZE_FACTOR];
+            System.arraycopy(buffer, 0, b, 0, buffer.length);
+            buffer = b;
         }
     }
 
     /**
-     * Extracts buffered data into the provided byte[] array, starting
-     * at position bPos, up to a maximum of bAvail bytes.  Returns how
-     * many bytes were actually extracted.
-     *
-     * @param b      byte[] array to extract the buffered data into.
-     * @param bPos   position in byte[] array to start extraction at.
-     * @param bAvail amount of bytes we're allowed to extract.  We may extract
-     *               fewer (if fewer are available).
-     * @return The number of bytes successfully extracted into the provided
-     *         byte[] array.
+     * Extracts buffered data into the provided byte[] array, starting at position bPos,
up to a maximum of bAvail
+     * bytes. Returns how many bytes were actually extracted.
+     * 
+     * @param b
+     *            byte[] array to extract the buffered data into.
+     * @param bPos
+     *            position in byte[] array to start extraction at.
+     * @param bAvail
+     *            amount of bytes we're allowed to extract. We may extract fewer (if fewer
are available).
+     * @return The number of bytes successfully extracted into the provided byte[] array.
      */
     int readResults(byte[] b, int bPos, int bAvail) {
-        if (buf != null) {
+        if (buffer != null) {
             int len = Math.min(avail(), bAvail);
-            if (buf != b) {
-                System.arraycopy(buf, readPos, b, bPos, len);
+            if (buffer != b) {
+                System.arraycopy(buffer, readPos, b, bPos, len);
                 readPos += len;
                 if (readPos >= pos) {
-                    buf = null;
+                    buffer = null;
                 }
             } else {
                 // Re-using the original consumer's output array is only
                 // allowed for one round.
-                buf = null;
+                buffer = null;
             }
             return len;
         }
@@ -386,15 +415,18 @@
      * Sets the streaming buffer. This is a small optimization where we try to buffer directly
to the consumer's output
      * array for one round (if the consumer calls this method first) instead of starting
our own buffer.
      * 
-     * @param out byte[] array to buffer directly to.
-     * @param outPos Position to start buffering into.
-     * @param outAvail Amount of bytes available for direct buffering.
+     * @param out
+     *            byte[] array to buffer directly to.
+     * @param outPos
+     *            Position to start buffering into.
+     * @param outAvail
+     *            Amount of bytes available for direct buffering.
      */
     void setInitialBuffer(byte[] out, int outPos, int outAvail) {
         // We can re-use consumer's original output array under
         // special circumstances, saving on some System.arraycopy().
         if (out != null && out.length == outAvail) {
-            buf = out;
+            buffer = out;
             pos = outPos;
             readPos = outPos;
         }
@@ -402,19 +434,21 @@
 
     /**
      * <p>
-     * 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 inAvail set to "-1" to alert encoder that EOF has been reached,
-     * so flush last remaining bytes (if not multiple of 3).
-     * </p><p>
-     * Thanks to "commons" project in ws.apache.org for the bitwise operations,
-     * and general approach.
+     * 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 inAvail set to "-1" to alert encoder that EOF has
been reached, so flush last
+     * remaining bytes (if not multiple of 3).
+     * </p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general
approach.
      * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
      * </p>
-     *
-     * @param in byte[] array of binary data to base64 encode.
-     * @param inPos Position to start reading data from.
-     * @param inAvail Amount of bytes available from input for encoding.
+     * 
+     * @param in
+     *            byte[] array of binary data to base64 encode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
      */
     void encode(byte[] in, int inPos, int inAvail) {
         if (eof) {
@@ -424,51 +458,53 @@
         // encoding.
         if (inAvail < 0) {
             eof = true;
-            if (buf == null || buf.length - pos < encodeSize) {
-                resizeBuf();
+            if (buffer == null || buffer.length - pos < encodeSize) {
+                resizeBuffer();
             }
             switch (modulus) {
-                case 1:
-                    buf[pos++] = encodeTable[(x >> 2) & MASK_6BITS];
-                    buf[pos++] = encodeTable[(x << 4) & MASK_6BITS];
+                case 1 :
+                    buffer[pos++] = encodeTable[(x >> 2) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x << 4) & MASK_6BITS];
                     // URL-SAFE skips the padding to further reduce size.
                     if (encodeTable == STANDARD_ENCODE_TABLE) {
-                        buf[pos++] = PAD;
-                        buf[pos++] = PAD;
+                        buffer[pos++] = PAD;
+                        buffer[pos++] = PAD;
                     }
                     break;
 
-                case 2:
-                    buf[pos++] = encodeTable[(x >> 10) & MASK_6BITS];
-                    buf[pos++] = encodeTable[(x >> 4) & MASK_6BITS];
-                    buf[pos++] = encodeTable[(x << 2) & MASK_6BITS];
+                case 2 :
+                    buffer[pos++] = encodeTable[(x >> 10) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 4) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x << 2) & MASK_6BITS];
                     // URL-SAFE skips the padding to further reduce size.
                     if (encodeTable == STANDARD_ENCODE_TABLE) {
-                        buf[pos++] = PAD;
+                        buffer[pos++] = PAD;
                     }
                     break;
             }
             if (lineLength > 0 && pos > 0) {
-                System.arraycopy(lineSeparator, 0, buf, pos, lineSeparator.length);
+                System.arraycopy(lineSeparator, 0, buffer, pos, lineSeparator.length);
                 pos += lineSeparator.length;
             }
         } else {
             for (int i = 0; i < inAvail; i++) {
-                if (buf == null || buf.length - pos < encodeSize) {
-                    resizeBuf();
+                if (buffer == null || buffer.length - pos < encodeSize) {
+                    resizeBuffer();
                 }
                 modulus = (++modulus) % 3;
                 int b = in[inPos++];
-                if (b < 0) { b += 256; }
+                if (b < 0) {
+                    b += 256;
+                }
                 x = (x << 8) + b;
                 if (0 == modulus) {
-                    buf[pos++] = encodeTable[(x >> 18) & MASK_6BITS];
-                    buf[pos++] = encodeTable[(x >> 12) & MASK_6BITS];
-                    buf[pos++] = encodeTable[(x >> 6) & MASK_6BITS];
-                    buf[pos++] = encodeTable[x & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 18) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 12) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[(x >> 6) & MASK_6BITS];
+                    buffer[pos++] = encodeTable[x & MASK_6BITS];
                     currentLinePos += 4;
                     if (lineLength > 0 && lineLength <= currentLinePos) {
-                        System.arraycopy(lineSeparator, 0, buf, pos, lineSeparator.length);
+                        System.arraycopy(lineSeparator, 0, buffer, pos, lineSeparator.length);
                         pos += lineSeparator.length;
                         currentLinePos = 0;
                     }
@@ -479,25 +515,27 @@
 
     /**
      * <p>
-     * 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 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.
-     * </p><p>
-     * Ignores all non-base64 characters.  This is how chunked (e.g. 76 character)
-     * data is handled, since CR and LF are silently ignored, but has implications
-     * for other bytes, too.  This method subscribes to the garbage-in, garbage-out
-     * philosophy:  it will not check the provided data for validity.
-     * </p><p>
-     * Thanks to "commons" project in ws.apache.org for the bitwise operations,
-     * and general approach.
+     * 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 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.
+     * </p>
+     * <p>
+     * Ignores all non-base64 characters. This is how chunked (e.g. 76 character) data is
handled, since CR and LF are
+     * silently ignored, but has implications for other bytes, too. This method subscribes
to the garbage-in,
+     * garbage-out philosophy: it will not check the provided data for validity.
+     * </p>
+     * <p>
+     * Thanks to "commons" project in ws.apache.org for the bitwise operations, and general
approach.
      * http://svn.apache.org/repos/asf/webservices/commons/trunk/modules/util/
      * </p>
-
-     * @param in byte[] array of ascii data to base64 decode.
-     * @param inPos Position to start reading data from.
-     * @param inAvail Amount of bytes available from input for encoding.
-     */    
+     * 
+     * @param in
+     *            byte[] array of ascii data to base64 decode.
+     * @param inPos
+     *            Position to start reading data from.
+     * @param inAvail
+     *            Amount of bytes available from input for encoding.
+     */
     void decode(byte[] in, int inPos, int inAvail) {
         if (eof) {
             return;
@@ -506,8 +544,8 @@
             eof = true;
         }
         for (int i = 0; i < inAvail; i++) {
-            if (buf == null || buf.length - pos < decodeSize) {
-                resizeBuf();
+            if (buffer == null || buffer.length - pos < decodeSize) {
+                resizeBuffer();
             }
             byte b = in[inPos++];
             if (b == PAD) {
@@ -521,28 +559,28 @@
                         modulus = (++modulus) % 4;
                         x = (x << 6) + result;
                         if (modulus == 0) {
-                            buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
-                            buf[pos++] = (byte) ((x >> 8) & MASK_8BITS);
-                            buf[pos++] = (byte) (x & MASK_8BITS);
+                            buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                            buffer[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+                            buffer[pos++] = (byte) (x & MASK_8BITS);
                         }
                     }
                 }
             }
         }
 
-        // Two forms of EOF as far as base64 decoder is concerned:  actual
+        // Two forms of EOF as far as base64 decoder is concerned: actual
         // EOF (-1) and first time '=' character is encountered in stream.
         // This approach makes the '=' padding characters completely optional.
         if (eof && modulus != 0) {
             x = x << 6;
             switch (modulus) {
-                case 2:
+                case 2 :
                     x = x << 6;
-                    buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                    buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
                     break;
-                case 3:
-                    buf[pos++] = (byte) ((x >> 16) & MASK_8BITS);
-                    buf[pos++] = (byte) ((x >> 8) & MASK_8BITS);
+                case 3 :
+                    buffer[pos++] = (byte) ((x >> 16) & MASK_8BITS);
+                    buffer[pos++] = (byte) ((x >> 8) & MASK_8BITS);
                     break;
             }
         }
@@ -561,13 +599,13 @@
     }
 
     /**
-     * Tests a given byte array to see if it contains only valid characters within the Base64
alphabet.
-     * Currently the method treats whitespace as valid.
+     * Tests a given byte array to see if it contains only valid characters within the Base64
alphabet. Currently the
+     * method treats whitespace as valid.
      * 
      * @param arrayOctet
      *            byte array to test
-     * @return <code>true</code> if all bytes are valid characters in the Base64
alphabet or if the byte array is
-     *         empty; false, otherwise
+     * @return <code>true</code> if all bytes are valid characters in the Base64
alphabet or if the byte array is empty;
+     *         false, otherwise
      */
     public static boolean isArrayByteBase64(byte[] arrayOctet) {
         for (int i = 0; i < arrayOctet.length; i++) {
@@ -606,9 +644,9 @@
     }
 
     /**
-     * Encodes binary data using a url-safe variation of the base64 algorithm but does not
chunk the output.
-     * The url-safe variation emits - and _ instead of + and / characters.
-     *
+     * Encodes binary data using a URL-safe variation of the base64 algorithm but does not
chunk the output. The
+     * url-safe variation emits - and _ instead of + and / characters.
+     * 
      * @param binaryData
      *            binary data to encode
      * @return Base64 characters
@@ -617,7 +655,6 @@
     public static byte[] encodeBase64URLSafe(byte[] binaryData) {
         return encodeBase64(binaryData, false, true);
     }
-    
 
     /**
      * Encodes binary data using the base64 algorithm and chunks the encoded output into
76 character blocks
@@ -675,7 +712,7 @@
 
     /**
      * Encodes binary data using the base64 algorithm, optionally chunking the output into
76 character blocks.
-     *
+     * 
      * @param binaryData
      *            Array containing binary data to encode.
      * @param isChunked
@@ -701,15 +738,15 @@
             len += (1 + (len / CHUNK_SIZE)) * CHUNK_SEPARATOR.length;
         }
         if (len > Integer.MAX_VALUE) {
-            throw new IllegalArgumentException(
-                    "Input array too big, output array would be bigger than Integer.MAX_VALUE="
+ Integer.MAX_VALUE);
+            throw new IllegalArgumentException("Input array too big, output array would be
bigger than Integer.MAX_VALUE="
+                + Integer.MAX_VALUE);
         }
         byte[] buf = new byte[(int) len];
         b64.setInitialBuffer(buf, 0, buf.length);
         b64.encode(binaryData, 0, binaryData.length);
         b64.encode(binaryData, 0, -1); // Notify encoder of EOF.
         // Encoder might have resized, even though it was unnecessary.
-        if (b64.buf != buf) {
+        if (b64.buffer != buf) {
             b64.readResults(buf, 0, buf.length);
         }
         // In URL-SAFE mode we skip the padding characters, so sometimes our
@@ -724,8 +761,9 @@
 
     /**
      * Decodes Base64 data into octets
-     *
-     * @param base64Data Byte array containing Base64 data
+     * 
+     * @param base64Data
+     *            Byte array containing Base64 data
      * @return Array containing decoded data.
      */
     public static byte[] decodeBase64(byte[] base64Data) {
@@ -772,7 +810,6 @@
         return packedData;
     }
 
-
     /**
      * Checks if a byte value is whitespace or not.
      * 
@@ -792,7 +829,6 @@
         }
     }
 
-
     // Implementation of the Encoder Interface
 
     /**
@@ -825,10 +861,10 @@
 
     // Implementation of integer encoding used for crypto
     /**
-     * Decodes a byte64-encoded integer according to crypto
-     * standards such as W3C's XML-Signature
+     * Decodes a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
      * 
-     * @param pArray a byte array containing base64 character data
+     * @param pArray
+     *            a byte array containing base64 character data
      * @return A BigInteger
      * @since 1.4
      */
@@ -837,36 +873,36 @@
     }
 
     /**
-     * Encodes to a byte64-encoded integer according to crypto
-     * standards such as W3C's XML-Signature
+     * Encodes to a byte64-encoded integer according to crypto standards such as W3C's XML-Signature
      * 
-     * @param bigInt a BigInteger
+     * @param bigInt
+     *            a BigInteger
      * @return A byte array containing base64 character data
-     * @throws NullPointerException if null is passed in
+     * @throws NullPointerException
+     *             if null is passed in
      * @since 1.4
      */
     public static byte[] encodeInteger(BigInteger bigInt) {
-        if(bigInt == null)  {
+        if (bigInt == null) {
             throw new NullPointerException("encodeInteger called with null parameter");
         }
         return encodeBase64(toIntegerBytes(bigInt), false);
     }
 
     /**
-     * Returns a byte-array representation of a <code>BigInteger</code>
-     * without sign bit.
-     *
-     * @param bigInt <code>BigInteger</code> to be converted
+     * Returns a byte-array representation of a <code>BigInteger</code> without
sign bit.
+     * 
+     * @param bigInt
+     *            <code>BigInteger</code> to be converted
      * @return a byte array representation of the BigInteger parameter
      */
-     static byte[] toIntegerBytes(BigInteger bigInt) {
+    static byte[] toIntegerBytes(BigInteger bigInt) {
         int bitlen = bigInt.bitLength();
         // round bitlen
         bitlen = ((bitlen + 7) >> 3) << 3;
         byte[] bigBytes = bigInt.toByteArray();
 
-        if(((bigInt.bitLength() % 8) != 0) &&
-            (((bigInt.bitLength() / 8) + 1) == (bitlen / 8))) {
+        if (((bigInt.bitLength() % 8) != 0) && (((bigInt.bitLength() / 8) + 1) ==
(bitlen / 8))) {
             return bigBytes;
         }
         // set up params for copying everything but sign bit
@@ -874,7 +910,7 @@
         int len = bigBytes.length;
 
         // if bigInt is exactly byte-aligned, just skip signbit in copy
-        if((bigInt.bitLength() % 8) == 0) {
+        if ((bigInt.bitLength() % 8) == 0) {
             startSrc = 1;
             len--;
         }

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64InputStream.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64InputStream.java?rev=795284&r1=795283&r2=795284&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64InputStream.java
(original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64InputStream.java
Sat Jul 18 00:36:43 2009
@@ -33,8 +33,10 @@
  * </p><p>
  * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite>
from RFC 2045 <cite>Multipurpose
  * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite>
by Freed and Borenstein.
+ * </p><p>
+ * Since this class operates directly on byte streams, and not character streams, it is hard-coded
to only encode/decode
+ * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252,
UTF-8, etc). 
  * </p>
- *
  * @author Apache Software Foundation
  * @version $Id $
  * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>

Modified: commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64OutputStream.java
URL: http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64OutputStream.java?rev=795284&r1=795283&r2=795284&view=diff
==============================================================================
--- commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64OutputStream.java
(original)
+++ commons/proper/codec/trunk/src/java/org/apache/commons/codec/binary/Base64OutputStream.java
Sat Jul 18 00:36:43 2009
@@ -33,8 +33,10 @@
  * </p><p>
  * This class implements section <cite>6.8. Base64 Content-Transfer-Encoding</cite>
from RFC 2045 <cite>Multipurpose
  * Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies</cite>
by Freed and Borenstein.
- * </p>
- *
+ * </p><p>
+ * Since this class operates directly on byte streams, and not character streams, it is hard-coded
to only encode/decode
+ * character encodings which are compatible with the lower 127 ASCII chart (ISO-8859-1, Windows-1252,
UTF-8, etc).
+ * </p> 
  * @author Apache Software Foundation
  * @version $Id $
  * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045</a>



Mime
View raw message