base64.java

google gdata API 很好用的API

/* Copyright (c) 2006 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.google.gdata.util.common.util;

// This code was converted from code at http://iharder.sourceforge.net/base64/
// Lots of extraneous features were removed.
/* The original code said:
 * <p>
 * I am placing this code in the Public Domain. Do with it as you will.
 * This software comes with no guarantees or warranties but with
 * plenty of well-wishing instead!
 * Please visit
 * <a href="http://iharder.net/xmlizable">http://iharder.net/xmlizable</a>
 * periodically to check for updates or to contribute improvements.
 * </p>
 *
 *
 *
 * @version 1.3
 */



/** Base64 convertor class. This code is not a full-blown MIME encoder;
 ** it simply converts binary data to base64 data and back.
 **/

public class Base64 extends Object {
  /** Specify encoding (value is <tt>true</tt>). */
  public final static boolean ENCODE = true;

  /** Specify decoding (value is <tt>false</tt>). */
  public final static boolean DECODE = false;

  /** Maximum line length of Base64 output. Set to Integer.MAX_VALUE */
  private final static int MAX_LINE_LENGTH = Integer.MAX_VALUE;

  /** The equals sign (=) as a byte. */
  private final static byte EQUALS_SIGN = (byte)'=';

  /** The new line character (\n) as a byte. */
  private final static byte NEW_LINE = (byte)'\n';

  /** The 64 valid Base64 values. */
  public final static byte[] ALPHABET = {
   (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
   (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
   (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
   (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
   (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
   (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
   (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
   (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
   (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
   (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/'
  };

  /** The 64 valid web safe Base64 values. */
  public final static byte[] WEBSAFE_ALPHABET = {
   (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
   (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
   (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
   (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
   (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
   (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
   (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
   (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
   (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
   (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'-', (byte)'_'
  };

  /**
   * Translates a Base64 value to either its 6-bit reconstruction value
   * or a negative number indicating some other meaning.
   **/
  private final static byte[] DECODABET = {
    -9,-9,-9,-9,-9,-9,-9,-9,-9,                 // Decimal  0 -  8
    -5,-5,                                      // Whitespace: Tab and Linefeed
    -9,-9,                                      // Decimal 11 - 12
    -5,                                         // Whitespace: Carriage Return
    -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 14 - 26
    -9,-9,-9,-9,-9,                             // Decimal 27 - 31
    -5,                                         // Whitespace: Space
    -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,              // Decimal 33 - 42
    62,                                         // Plus sign at decimal 43
    -9,-9,-9,                                   // Decimal 44 - 46
    63,                                         // Slash at decimal 47
    52,53,54,55,56,57,58,59,60,61,              // Numbers zero through nine
    -9,-9,-9,                                   // Decimal 58 - 60
    -1,                                         // Equals sign at decimal 61
    -9,-9,-9,                                      // Decimal 62 - 64
    0,1,2,3,4,5,6,7,8,9,10,11,12,13,            // Letters 'A' through 'N'
    14,15,16,17,18,19,20,21,22,23,24,25,        // Letters 'O' through 'Z'
    -9,-9,-9,-9,-9,-9,                          // Decimal 91 - 96
    26,27,28,29,30,31,32,33,34,35,36,37,38,     // Letters 'a' through 'm'
    39,40,41,42,43,44,45,46,47,48,49,50,51,     // Letters 'n' through 'z'
    -9,-9,-9,-9                                 // Decimal 123 - 126
    /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 127 - 139
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 140 - 152
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 153 - 165
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 166 - 178
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 179 - 191
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 192 - 204
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 205 - 217
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 218 - 230
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 231 - 243
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9         // Decimal 244 - 255 */
  };

  /** The web safe decodabet */
  private final static byte[] WEBSAFE_DECODABET = {
    -9,-9,-9,-9,-9,-9,-9,-9,-9,                 // Decimal  0 -  8
    -5,-5,                                      // Whitespace: Tab and Linefeed
    -9,-9,                                      // Decimal 11 - 12
    -5,                                         // Whitespace: Carriage Return
    -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 14 - 26
    -9,-9,-9,-9,-9,                             // Decimal 27 - 31
    -5,                                         // Whitespace: Space
    -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,        // Decimal 33 - 44
    62,                                         // Dash '-' sign at decimal 45
    -9,-9,                                      // Decimal 46-47
    52,53,54,55,56,57,58,59,60,61,              // Numbers zero through nine
    -9,-9,-9,                                   // Decimal 58 - 60
    -1,                                         // Equals sign at decimal 61
    -9,-9,-9,                                   // Decimal 62 - 64
    0,1,2,3,4,5,6,7,8,9,10,11,12,13,            // Letters 'A' through 'N'
    14,15,16,17,18,19,20,21,22,23,24,25,        // Letters 'O' through 'Z'
    -9,-9,-9,-9,                                // Decimal 91-94
    63,                                         // Underscore '_' at decimal 95
    -9,                                         // Decimal 96
    26,27,28,29,30,31,32,33,34,35,36,37,38,     // Letters 'a' through 'm'
    39,40,41,42,43,44,45,46,47,48,49,50,51,     // Letters 'n' through 'z'
    -9,-9,-9,-9                                 // Decimal 123 - 126
    /*,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 127 - 139
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 140 - 152
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 153 - 165
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 166 - 178
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 179 - 191
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 192 - 204
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 205 - 217
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 218 - 230
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,     // Decimal 231 - 243
      -9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9,-9         // Decimal 244 - 255 */
  };

  // Indicates error in encoding
  private final static byte BAD_ENCODING    = -9;
  // Indicates white space in encoding
  private final static byte WHITE_SPACE_ENC = -5;
  // Indicates equals sign in encoding
  private final static byte EQUALS_SIGN_ENC = -1;

  /** Defeats instantiation. */
  private Base64(){}

  /* ********  E N C O D I N G   M E T H O D S  ******** */

  /**
   * Encodes the first three bytes of array <var>threeBytes</var>
   * and returns a four-byte array in Base64 notation.
   *
   * @param threeBytes the array to convert
   * @param alphabet is the encoding alphabet
   * @return four byte array in Base64 notation.
   * @since 1.3
   */
  private static byte[] encode3to4( byte[] threeBytes,
                                    byte[] alphabet ) {
    return encode3to4( threeBytes, 3, alphabet );
  }

  /**
   * Encodes up to the first three bytes of array <var>threeBytes</var>
   * and returns a four-byte array in Base64 notation.
   * The actual number of significant bytes in your array is
   * given by <var>numSigBytes</var>.
   * The array <var>threeBytes</var> needs only be as big as
   * <var>numSigBytes</var>.
   *
   * @param threeBytes the array to convert
   * @param numSigBytes the number of significant bytes in your array
   * @param alphabet is the encoding alphabet
   * @return four byte array in Base64 notation.
   * @since 1.3
   */
  private static byte[] encode3to4( byte[] threeBytes, int numSigBytes,
                                    byte[] alphabet ) {
    byte[] dest = new byte[4];
    encode3to4( threeBytes, 0, numSigBytes, dest, 0, alphabet );
    return dest;
  }

  /**
   * Encodes up to three bytes of the array <var>source</var>
   * and writes the resulting four Base64 bytes to <var>destination</var>.
   * The source and destination arrays can be manipulated
   * anywhere along their length by specifying
   * <var>srcOffset</var> and <var>destOffset</var>.
   * This method does not check to make sure your arrays
   * are large enough to accomodate <var>srcOffset</var> + 3 for
   * the <var>source</var> array or <var>destOffset</var> + 4 for
   * the <var>destination</var> array.
   * The actual number of significant bytes in your array is
   * given by <var>numSigBytes</var>.
   *
   * @param source the array to convert
   * @param srcOffset the index where conversion begins
   * @param numSigBytes the number of significant bytes in your array
   * @param destination the array to hold the conversion
   * @param destOffset the index where output will be put
   * @param alphabet is the encoding alphabet
   * @return the <var>destination</var> array
   * @since 1.3
   */
  private static byte[] encode3to4(
    byte[] source, int srcOffset, int numSigBytes,
    byte[] destination, int destOffset,
    byte[] alphabet )
  {
    //           1         2         3
    // 01234567890123456789012345678901 Bit position
    // --------000000001111111122222222 Array position from threeBytes
    // --------|    ||    ||    ||    | Six bit groups to index alphabet
    //          >>18  >>12  >> 6  >> 0  Right shift necessary
    //                0x3f  0x3f  0x3f  Additional AND

    // Create buffer with zero-padding if there are only one or two
    // significant bytes passed in the array.
    // We have to shift left 24 in order to flush out the 1's that appear
    // when Java treats a value as negative that is cast from a byte to an int.
    int inBuff =   ( numSigBytes > 0 ? ((source[ srcOffset] << 24) >>> 8) : 0 )
      | ( numSigBytes > 1 ? ((source[ srcOffset + 1 ] << 24) >>> 16) : 0 )
      | ( numSigBytes > 2 ? ((source[ srcOffset + 2 ] << 24) >>> 24) : 0 );

    switch( numSigBytes ) {
      case 3:
        destination[ destOffset     ] = alphabet[ (inBuff >>> 18)        ];
        destination[ destOffset + 1 ] = alphabet[ (inBuff >>> 12) & 0x3f ];
        destination[ destOffset + 2 ] = alphabet[ (inBuff >>>  6) & 0x3f ];
        destination[ destOffset + 3 ] = alphabet[ (inBuff       ) & 0x3f ];
        return destination;
      case 2:
        destination[ destOffset     ] = alphabet[ (inBuff >>> 18)        ];
        destination[ destOffset + 1 ] = alphabet[ (inBuff >>> 12) & 0x3f ];
        destination[ destOffset + 2 ] = alphabet[ (inBuff >>>  6) & 0x3f ];
        destination[ destOffset + 3 ] = EQUALS_SIGN;
        return destination;
      case 1:
        destination[ destOffset     ] = alphabet[ (inBuff >>> 18)        ];
        destination[ destOffset + 1 ] = alphabet[ (inBuff >>> 12) & 0x3f ];
        destination[ destOffset + 2 ] = EQUALS_SIGN;
        destination[ destOffset + 3 ] = EQUALS_SIGN;
        return destination;
      default:
        return destination;
    }   // end switch
  }   // end encode3to4

  /**
   * Encodes a byte array into Base64 notation.
   * Equivalent to calling
   * <code>encodeBytes( source, 0, source.length )</code>
   *
   * @param source The data to convert
   * @since 1.4
   */
  public static String encode( byte[] source ) {
    return encode( source, 0, source.length, ALPHABET, true );
  }

  /**
   * Encodes a byte array into web safe Base64 notation.
   *
   * @param source The data to convert
   * @param doPadding is <code>true</code> to pad result with '=' chars
   *        if it does not fall on 3 byte boundaries
   */
  public static String encodeWebSafe( byte[] source, boolean doPadding ) {
    return encode( source, 0, source.length, WEBSAFE_ALPHABET, doPadding );
  }

  /**
   * Encodes a byte array into Base64 notation.
   *
   * @param source The data to convert
   * @param off Offset in array where conversion should begin
   * @param len Length of data to convert
   * @param alphabet is the encoding alphabet
   * @param doPadding is <code>true</code> to pad result with '=' chars
   *        if it does not fall on 3 byte boundaries
   * @since 1.4
   */
  public static String encode( byte[] source, int off, int len,
                               byte[] alphabet, boolean doPadding ) {
    byte[] outBuff = encode(source, off, len, alphabet,
                            Integer.MAX_VALUE);
    int outLen = outBuff.length;

    // If doPadding is false, set length to truncate '='
    // padding characters
    while (doPadding == false && outLen > 0) {
      if (outBuff[outLen - 1] != '=') {
        break;
      }
      outLen -= 1;
    }

    return new String(outBuff, 0, outLen);