src/main/org/codehaus/groovy/runtime/EncodingGroovyMethods.java - groovy - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you 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 org.codehaus.groovy.runtime;

 import groovy.lang.StringWriterIOException;
 import groovy.lang.Writable;
 import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;

 import java.io.IOException;
 import java.io.StringWriter;
 import java.io.UnsupportedEncodingException;
 import java.io.Writer;

 /**
  * This class defines all the encoding/decoding groovy methods which enhance
  * the normal JDK classes when inside the Groovy environment.
  * Static methods are used with the first parameter the destination class.
  */
 public class EncodingGroovyMethods {

     private static final char[] T_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();

     private static final String CHUNK_SEPARATOR = "\r\n";

     /**
      * Produce a Writable object which writes the Base64 encoding of the byte array.
      * Calling toString() on the result returns the encoding as a String. For more
      * information on Base64 encoding and chunking see <code>RFC 4648</code>.
      *
      * @param data Byte array to be encoded
      * @param chunked whether or not the Base64 encoded data should be MIME chunked
      * @return object which will write the Base64 encoding of the byte array
      * @since 1.5.1
      */
     public static Writable encodeBase64(Byte[] data, final boolean chunked) {
         return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), chunked);
     }

     /**
      * Produce a Writable object which writes the Base64 encoding of the byte array.
      * Calling toString() on the result returns the encoding as a String. For more
      * information on Base64 encoding and chunking see <code>RFC 4648</code>.
      *
      * @param data Byte array to be encoded
      * @return object which will write the Base64 encoding of the byte array
      * @since 1.0
      */
     public static Writable encodeBase64(Byte[] data) {
         return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), false);
     }

     /**
      * Produce a Writable object which writes the Base64 encoding of the byte array.
      * Calling toString() on the result returns the encoding as a String. For more
      * information on Base64 encoding and chunking see <code>RFC 4648</code>.
      *
      * @param data byte array to be encoded
      * @param chunked whether or not the Base64 encoded data should be MIME chunked
      * @return object which will write the Base64 encoding of the byte array
      * @since 1.5.7
      */
     public static Writable encodeBase64(final byte[] data, final boolean chunked) {
         return new Writable() {
             public Writer writeTo(final Writer writer) throws IOException {
                 int charCount = 0;
                 final int dLimit = (data.length / 3) * 3;

                 for (int dIndex = 0; dIndex != dLimit; dIndex += 3) {
                     int d = ((data[dIndex] & 0XFF) << 16) | ((data[dIndex + 1] & 0XFF) << 8) | (data[dIndex + 2] & 0XFF);

                     writer.write(T_TABLE[d >> 18]);
                     writer.write(T_TABLE[(d >> 12) & 0X3F]);
                     writer.write(T_TABLE[(d >> 6) & 0X3F]);
                     writer.write(T_TABLE[d & 0X3F]);

                     if (chunked && ++charCount == 19) {
                         writer.write(CHUNK_SEPARATOR);
                         charCount = 0;
                     }
                 }

                 if (dLimit != data.length) {
                     int d = (data[dLimit] & 0XFF) << 16;

                     if (dLimit + 1 != data.length) {
                         d |= (data[dLimit + 1] & 0XFF) << 8;
                     }

                     writer.write(T_TABLE[d >> 18]);
                     writer.write(T_TABLE[(d >> 12) & 0X3F]);
                     writer.write((dLimit + 1 < data.length) ? T_TABLE[(d >> 6) & 0X3F] : '=');
                     writer.write('=');
                     if (chunked && charCount != 0) {
                         writer.write(CHUNK_SEPARATOR);
                     }
                 }

                 return writer;
             }

             public String toString() {
                 StringWriter buffer = new StringWriter();

                 try {
                     writeTo(buffer);
                 } catch (IOException e) {
                     throw new StringWriterIOException(e);
                 }

                 return buffer.toString();
             }
         };
     }

     /**
      * Produce a Writable object which writes the Base64 encoding of the byte array.
      * Calling toString() on the result returns the encoding as a String. For more
      * information on Base64 encoding and chunking see <code>RFC 4648</code>.
      *
      * @param data byte array to be encoded
      * @return object which will write the Base64 encoding of the byte array
      * @since 1.0
      */
     public static Writable encodeBase64(final byte[] data) {
         return encodeBase64(data, false);
     }

     /**
      * Decode the String from Base64 into a byte array.
      *
      * @param value the string to be decoded
      * @return the decoded bytes as an array
      * @since 1.0
      */
     public static byte[] decodeBase64(String value) {
         int byteShift = 4;
         int tmp = 0;
         boolean done = false;
         final StringBuilder buffer = new StringBuilder();

         for (int i = 0; i != value.length(); i++) {
             final char c = value.charAt(i);
             final int sixBit = (c < 123) ? EncodingGroovyMethodsSupport.TRANSLATE_TABLE[c] : 66;

             if (sixBit < 64) {
                 if (done)
                     throw new RuntimeException("= character not at end of base64 value"); // TODO: change this exception type

                 tmp = (tmp << 6) | sixBit;

                 if (byteShift-- != 4) {
                     buffer.append((char) ((tmp >> (byteShift * 2)) & 0XFF));
                 }

             } else if (sixBit == 64) {

                 byteShift--;
                 done = true;

             } else if (sixBit == 66) {
                 // RFC 2045 says that I'm allowed to take the presence of
                 // these characters as evidence of data corruption
                 // So I will
                 throw new RuntimeException("bad character in base64 value"); // TODO: change this exception type
             }

             if (byteShift == 0) byteShift = 4;
         }

         try {
             return buffer.toString().getBytes("ISO-8859-1");
         } catch (UnsupportedEncodingException e) {
             throw new RuntimeException("Base 64 decode produced byte values > 255"); // TODO: change this exception type
         }
     }

     /**
      * Produces a Writable that writes the hex encoding of the Byte[]. Calling
      * toString() on this Writable returns the hex encoding as a String. The hex
      * encoding includes two characters for each byte and all letters are lower case.
      *
      * @param data byte array to be encoded
      * @return object which will write the hex encoding of the byte array
      * @see Integer#toHexString(int)
      */
     public static Writable encodeHex(final Byte[] data) {
         return encodeHex(DefaultTypeTransformation.convertToByteArray(data));
     }

     /**
      * Produces a Writable that writes the hex encoding of the byte[]. Calling
      * toString() on this Writable returns the hex encoding as a String. The hex
      * encoding includes two characters for each byte and all letters are lower case.
      *
      * @param data byte array to be encoded
      * @return object which will write the hex encoding of the byte array
      * @see Integer#toHexString(int)
      */
     public static Writable encodeHex(final byte[] data) {
         return new Writable() {
             public Writer writeTo(Writer out) throws IOException {
                 for (int i = 0; i < data.length; i++) {
                     // convert byte into unsigned hex string
                     String hexString = Integer.toHexString(data[i] & 0xFF);

                     // add leading zero if the length of the string is one
                     if (hexString.length() < 2) {
                         out.write("0");
                     }

                     // write hex string to writer
                     out.write(hexString);
                 }
                 return out;
             }

             public String toString() {
                 StringWriter buffer = new StringWriter();

                 try {
                     writeTo(buffer);
                 } catch (IOException e) {
                     throw new StringWriterIOException(e);
                 }

                 return buffer.toString();
             }
         };
     }

     /**
      * Decodes a hex string to a byte array. The hex string can contain either upper
      * case or lower case letters.
      *
      * @param value string to be decoded
      * @return decoded byte array
      * @throws NumberFormatException If the string contains an odd number of characters
      *                               or if the characters are not valid hexadecimal values.
      */
     public static byte[] decodeHex(final String value) {
         // if string length is odd then throw exception
         if (value.length() % 2 != 0) {
             throw new NumberFormatException("odd number of characters in hex string");
         }

         byte[] bytes = new byte[value.length() / 2];
         for (int i = 0; i < value.length(); i += 2) {
             bytes[i / 2] = (byte) Integer.parseInt(value.substring(i, i + 2), 16);
         }

         return bytes;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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 org.codehaus.groovy.runtime;

	import groovy.lang.StringWriterIOException;
	import groovy.lang.Writable;
	import org.codehaus.groovy.runtime.typehandling.DefaultTypeTransformation;

	import java.io.IOException;
	import java.io.StringWriter;
	import java.io.UnsupportedEncodingException;
	import java.io.Writer;

	/**
	* This class defines all the encoding/decoding groovy methods which enhance
	* the normal JDK classes when inside the Groovy environment.
	* Static methods are used with the first parameter the destination class.
	*/
	public class EncodingGroovyMethods {

	private static final char[] T_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();

	private static final String CHUNK_SEPARATOR = "\r\n";

	/**
	* Produce a Writable object which writes the Base64 encoding of the byte array.
	* Calling toString() on the result returns the encoding as a String. For more
	* information on Base64 encoding and chunking see <code>RFC 4648</code>.
	*
	* @param data Byte array to be encoded
	* @param chunked whether or not the Base64 encoded data should be MIME chunked
	* @return object which will write the Base64 encoding of the byte array
	* @since 1.5.1
	*/
	public static Writable encodeBase64(Byte[] data, final boolean chunked) {
	return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), chunked);
	}

	/**
	* Produce a Writable object which writes the Base64 encoding of the byte array.
	* Calling toString() on the result returns the encoding as a String. For more
	* information on Base64 encoding and chunking see <code>RFC 4648</code>.
	*
	* @param data Byte array to be encoded
	* @return object which will write the Base64 encoding of the byte array
	* @since 1.0
	*/
	public static Writable encodeBase64(Byte[] data) {
	return encodeBase64(DefaultTypeTransformation.convertToByteArray(data), false);
	}

	/**
	* Produce a Writable object which writes the Base64 encoding of the byte array.
	* Calling toString() on the result returns the encoding as a String. For more
	* information on Base64 encoding and chunking see <code>RFC 4648</code>.
	*
	* @param data byte array to be encoded
	* @param chunked whether or not the Base64 encoded data should be MIME chunked
	* @return object which will write the Base64 encoding of the byte array
	* @since 1.5.7
	*/
	public static Writable encodeBase64(final byte[] data, final boolean chunked) {
	return new Writable() {
	public Writer writeTo(final Writer writer) throws IOException {
	int charCount = 0;
	final int dLimit = (data.length / 3) * 3;

	for (int dIndex = 0; dIndex != dLimit; dIndex += 3) {
	int d = ((data[dIndex] & 0XFF) << 16) \| ((data[dIndex + 1] & 0XFF) << 8) \| (data[dIndex + 2] & 0XFF);

	writer.write(T_TABLE[d >> 18]);
	writer.write(T_TABLE[(d >> 12) & 0X3F]);
	writer.write(T_TABLE[(d >> 6) & 0X3F]);
	writer.write(T_TABLE[d & 0X3F]);

	if (chunked && ++charCount == 19) {
	writer.write(CHUNK_SEPARATOR);
	charCount = 0;
	}
	}

	if (dLimit != data.length) {
	int d = (data[dLimit] & 0XFF) << 16;

	if (dLimit + 1 != data.length) {
	d \|= (data[dLimit + 1] & 0XFF) << 8;
	}

	writer.write(T_TABLE[d >> 18]);
	writer.write(T_TABLE[(d >> 12) & 0X3F]);
	writer.write((dLimit + 1 < data.length) ? T_TABLE[(d >> 6) & 0X3F] : '=');
	writer.write('=');
	if (chunked && charCount != 0) {
	writer.write(CHUNK_SEPARATOR);
	}
	}

	return writer;
	}

	public String toString() {
	StringWriter buffer = new StringWriter();

	try {
	writeTo(buffer);
	} catch (IOException e) {
	throw new StringWriterIOException(e);
	}

	return buffer.toString();
	}
	};
	}

	/**
	* Produce a Writable object which writes the Base64 encoding of the byte array.
	* Calling toString() on the result returns the encoding as a String. For more
	* information on Base64 encoding and chunking see <code>RFC 4648</code>.
	*
	* @param data byte array to be encoded
	* @return object which will write the Base64 encoding of the byte array
	* @since 1.0
	*/
	public static Writable encodeBase64(final byte[] data) {
	return encodeBase64(data, false);
	}

	/**
	* Decode the String from Base64 into a byte array.
	*
	* @param value the string to be decoded
	* @return the decoded bytes as an array
	* @since 1.0
	*/
	public static byte[] decodeBase64(String value) {
	int byteShift = 4;
	int tmp = 0;
	boolean done = false;
	final StringBuilder buffer = new StringBuilder();

	for (int i = 0; i != value.length(); i++) {
	final char c = value.charAt(i);
	final int sixBit = (c < 123) ? EncodingGroovyMethodsSupport.TRANSLATE_TABLE[c] : 66;

	if (sixBit < 64) {
	if (done)
	throw new RuntimeException("= character not at end of base64 value"); // TODO: change this exception type

	tmp = (tmp << 6) \| sixBit;

	if (byteShift-- != 4) {
	buffer.append((char) ((tmp >> (byteShift * 2)) & 0XFF));
	}

	} else if (sixBit == 64) {

	byteShift--;
	done = true;

	} else if (sixBit == 66) {
	// RFC 2045 says that I'm allowed to take the presence of
	// these characters as evidence of data corruption
	// So I will
	throw new RuntimeException("bad character in base64 value"); // TODO: change this exception type
	}

	if (byteShift == 0) byteShift = 4;
	}

	try {
	return buffer.toString().getBytes("ISO-8859-1");
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException("Base 64 decode produced byte values > 255"); // TODO: change this exception type
	}
	}

	/**
	* Produces a Writable that writes the hex encoding of the Byte[]. Calling
	* toString() on this Writable returns the hex encoding as a String. The hex
	* encoding includes two characters for each byte and all letters are lower case.
	*
	* @param data byte array to be encoded
	* @return object which will write the hex encoding of the byte array
	* @see Integer#toHexString(int)
	*/
	public static Writable encodeHex(final Byte[] data) {
	return encodeHex(DefaultTypeTransformation.convertToByteArray(data));
	}

	/**
	* Produces a Writable that writes the hex encoding of the byte[]. Calling
	* toString() on this Writable returns the hex encoding as a String. The hex
	* encoding includes two characters for each byte and all letters are lower case.
	*
	* @param data byte array to be encoded
	* @return object which will write the hex encoding of the byte array
	* @see Integer#toHexString(int)
	*/
	public static Writable encodeHex(final byte[] data) {
	return new Writable() {
	public Writer writeTo(Writer out) throws IOException {
	for (int i = 0; i < data.length; i++) {
	// convert byte into unsigned hex string
	String hexString = Integer.toHexString(data[i] & 0xFF);

	// add leading zero if the length of the string is one
	if (hexString.length() < 2) {
	out.write("0");
	}

	// write hex string to writer
	out.write(hexString);
	}
	return out;
	}

	public String toString() {
	StringWriter buffer = new StringWriter();

	try {
	writeTo(buffer);
	} catch (IOException e) {
	throw new StringWriterIOException(e);
	}

	return buffer.toString();
	}
	};
	}

	/**
	* Decodes a hex string to a byte array. The hex string can contain either upper
	* case or lower case letters.
	*
	* @param value string to be decoded
	* @return decoded byte array
	* @throws NumberFormatException If the string contains an odd number of characters
	* or if the characters are not valid hexadecimal values.
	*/
	public static byte[] decodeHex(final String value) {
	// if string length is odd then throw exception
	if (value.length() % 2 != 0) {
	throw new NumberFormatException("odd number of characters in hex string");
	}

	byte[] bytes = new byte[value.length() / 2];
	for (int i = 0; i < value.length(); i += 2) {
	bytes[i / 2] = (byte) Integer.parseInt(value.substring(i, i + 2), 16);
	}

	return bytes;
	}
	}