* Example: <code>encodeObject( myObj, Base64.GZIP )</code> or     * <p>     * Example: <code>encodeObject( myObj, Base64.GZIP | Base64.DO_BREAK_LINES )</code>     *     * @param serializableObject The object to encode     * @param options Specified options     * @return The Base64-encoded object     * @see Base64#GZIP     * @see Base64#DO_BREAK_LINES     * @throws java.io.IOException if there is an error     * @since 2.0     */    public static String encodeObject( java.io.Serializable serializableObject, int options )    throws java.io.IOException {        if( serializableObject == null ){            throw new NullPointerException( "Cannot serialize a null object." );        }   // end if: null                // Streams        java.io.ByteArrayOutputStream  baos  = null;         java.io.OutputStream           b64os = null;         java.io.ObjectOutputStream     oos   = null;                         try {            // ObjectOutputStream -> (GZIP) -> Base64 -> ByteArrayOutputStream            // Note that the optional GZIPping is handled by Base64.OutputStream.            baos  = new java.io.ByteArrayOutputStream();            b64os = new Base64.OutputStream( baos, ENCODE | options );            oos   = new java.io.ObjectOutputStream( b64os );            oos.writeObject( serializableObject );        }   // end try        catch( java.io.IOException e ) {            // Catch it and then throw it immediately so that            // the finally{} block is called for cleanup.            throw e;        }   // end catch        finally {            try{ oos.close();   } catch( Exception e ){}            try{ b64os.close(); } catch( Exception e ){}            try{ baos.close();  } catch( Exception e ){}        }   // end finally                // Return value according to relevant encoding.        try {            return new String( baos.toByteArray(), PREFERRED_ENCODING );        }   // end try        catch (java.io.UnsupportedEncodingException uue){            // Fall back to some Java default            return new String( baos.toByteArray() );        }   // end catch            }   // end encode            /**     * Encodes a byte array into Base64 notation.     * Does not GZip-compress data.     *       * @param source The data to convert     * @return The data in Base64-encoded form     * @throws NullPointerException if source array is null     * @since 1.4     */    public static String encodeBytes( byte[] source ) {        // Since we're not going to have the GZIP encoding turned on,        // we're not going to have an java.io.IOException thrown, so        // we should not force the user to have to catch it.        String encoded = null;        try {            encoded = encodeBytes(source, 0, source.length, NO_OPTIONS);        } catch (java.io.IOException ex) {            assert false : ex.getMessage();        }   // end catch        assert encoded != null;        return encoded;    }   // end encodeBytes        /**     * Encodes a byte array into Base64 notation.     * <p>     * Example options:<pre>     *   GZIP: gzip-compresses object before encoding it.     *   DO_BREAK_LINES: break lines at 76 characters     *     <i>Note: Technically, this makes your encoding non-compliant.</i>     * </pre>     * <p>     * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or     * <p>     * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DO_BREAK_LINES )</code>     *     *       * <p>As of v 2.3, if there is an error with the GZIP stream,     * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>     * In earlier versions, it just returned a null value, but     * in retrospect that's a pretty poor way to handle it.</p>     *      *     * @param source The data to convert     * @param options Specified options     * @return The Base64-encoded data as a String     * @see Base64#GZIP     * @see Base64#DO_BREAK_LINES     * @throws java.io.IOException if there is an error     * @throws NullPointerException if source array is null     * @since 2.0     */    public static String encodeBytes( byte[] source, int options ) throws java.io.IOException {        return encodeBytes( source, 0, source.length, options );    }   // end encodeBytes            /**     * Encodes a byte array into Base64 notation.     * Does not GZip-compress data.     *       * <p>As of v 2.3, if there is an error,     * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>     * In earlier versions, it just returned a null value, but     * in retrospect that's a pretty poor way to handle it.</p>     *      *     * @param source The data to convert     * @param off Offset in array where conversion should begin     * @param len Length of data to convert     * @return The Base64-encoded data as a String     * @throws NullPointerException if source array is null     * @throws IllegalArgumentException if source array, offset, or length are invalid     * @since 1.4     */    public static String encodeBytes( byte[] source, int off, int len ) {        // Since we're not going to have the GZIP encoding turned on,        // we're not going to have an java.io.IOException thrown, so        // we should not force the user to have to catch it.        String encoded = null;        try {            encoded = encodeBytes( source, off, len, NO_OPTIONS );        } catch (java.io.IOException ex) {            assert false : ex.getMessage();        }   // end catch        assert encoded != null;        return encoded;    }   // end encodeBytes            /**     * Encodes a byte array into Base64 notation.     * <p>     * Example options:<pre>     *   GZIP: gzip-compresses object before encoding it.     *   DO_BREAK_LINES: break lines at 76 characters     *     <i>Note: Technically, this makes your encoding non-compliant.</i>     * </pre>     * <p>     * Example: <code>encodeBytes( myData, Base64.GZIP )</code> or     * <p>     * Example: <code>encodeBytes( myData, Base64.GZIP | Base64.DO_BREAK_LINES )</code>     *     *       * <p>As of v 2.3, if there is an error with the GZIP stream,     * the method will throw an java.io.IOException. <b>This is new to v2.3!</b>     * In earlier versions, it just returned a null value, but     * in retrospect that's a pretty poor way to handle it.</p>     *      *     * @param source The data to convert     * @param off Offset in array where conversion should begin     * @param len Length of data to convert     * @param options Specified options     * @return The Base64-encoded data as a String     * @see Base64#GZIP     * @see Base64#DO_BREAK_LINES     * @throws java.io.IOException if there is an error     * @throws NullPointerException if source array is null     * @throws IllegalArgumentException if source array, offset, or length are invalid     * @since 2.0     */    public static String encodeBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {        byte[] encoded = encodeBytesToBytes( source, off, len, options );        // Return value according to relevant encoding.        try {            return new String( encoded, PREFERRED_ENCODING );        }   // end try        catch (java.io.UnsupportedEncodingException uue) {            return new String( encoded );        }   // end catch            }   // end encodeBytes    /**     * Similar to {@link #encodeBytes(byte[])} but returns     * a byte array instead of instantiating a String. This is more efficient     * if you're working with I/O streams and have large data sets to encode.     *     *     * @param source The data to convert     * @return The Base64-encoded data as a byte[] (of ASCII characters)     * @throws NullPointerException if source array is null     * @since 2.3.1     */    public static byte[] encodeBytesToBytes( byte[] source ) {        byte[] encoded = null;        try {            encoded = encodeBytesToBytes( source, 0, source.length, Base64.NO_OPTIONS );        } catch( IOException ex ) {            assert false : "IOExceptions only come from GZipping, which is turned off: " + ex.getMessage();        }        return encoded;    }    /**     * Similar to {@link #encodeBytes(byte[], int, int, int)} but returns     * a byte array instead of instantiating a String. This is more efficient     * if you're working with I/O streams and have large data sets to encode.     *     *     * @param source The data to convert     * @param off Offset in array where conversion should begin     * @param len Length of data to convert     * @param options Specified options     * @return The Base64-encoded data as a String     * @see Base64#GZIP     * @see Base64#DO_BREAK_LINES     * @throws java.io.IOException if there is an error     * @throws NullPointerException if source array is null     * @throws IllegalArgumentException if source array, offset, or length are invalid     * @since 2.3.1     */    public static byte[] encodeBytesToBytes( byte[] source, int off, int len, int options ) throws java.io.IOException {        if( source == null ){            throw new NullPointerException( "Cannot serialize a null array." );        }   // end if: null        if( off < 0 ){            throw new IllegalArgumentException( "Cannot have negative offset: " + off );        }   // end if: off < 0        if( len < 0 ){            throw new IllegalArgumentException( "Cannot have length offset: " + len );        }   // end if: len < 0        if( off + len > source.length  ){            throw new IllegalArgumentException(            String.format( "Cannot have offset of %d and length of %d with array of length %d", off,len,source.length));        }   // end if: off < 0        // Compress?        if( (options & GZIP) > 0 ) {            java.io.ByteArrayOutputStream  baos  = null;            java.util.zip.GZIPOutputStream gzos  = null;            Base64.OutputStream            b64os = null;            try {                // GZip -> Base64 -> ByteArray                baos = new java.io.ByteArrayOutputStream();                b64os = new Base64.OutputStream( baos, ENCODE | options );                gzos  = new java.util.zip.GZIPOutputStream( b64os );                gzos.write( source, off, len );                gzos.close();            }   // end try            catch( java.io.IOException e ) {                // Catch it and then throw it immediately so that                // the finally{} block is called for cleanup.                throw e;            }   // end catch            finally {                try{ gzos.close();  } catch( Exception e ){}                try{ b64os.close(); } catch( Exception e ){}                try{ baos.close();  } catch( Exception e ){}            }   // end finally            return baos.toByteArray();        }   // end if: compress        // Else, don't compress. Better not to use streams at all then.        else {            boolean breakLines = (options & DO_BREAK_LINES) > 0;            int    len43   = len * 4 / 3;            byte[] outBuff = new byte[   ( len43 )                      // Main 4:3                                       + ( (len % 3) > 0 ? 4 : 0 )      // Account for padding                                       + (breakLines ? ( len43 / MAX_LINE_LENGTH ) : 0) ]; // New lines            int d = 0;            int e = 0;            int len2 = len - 2;            int lineLength = 0;            for( ; d < len2; d+=3, e+=4 ) {                encode3to4( source, d+off, 3, outBuff, e, options );                lineLength += 4;                if( breakLines && lineLength == MAX_LINE_LENGTH )                {                    outBuff[e+4] = NEW_LINE;