Removed tons of unnecessary code

svn changeset:165/svn branch:toolkit

1 files changed, 0 insertions, 576 deletions

diff --git a/src/com/itmill/toolkit/service/License.java b/src/com/itmill/toolkit/service/License.java
index cdf6d9c068..09d92e5c08 100644
--- a/src/com/itmill/toolkit/service/License.java
+++ b/src/com/itmill/toolkit/service/License.java
@@ -57,8 +57,6 @@ import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.SAXException;
 
-import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
-
 public class License {
 
 	/** IT Mill License Manager certificate */
@@ -675,59 +673,12 @@ public class License {
 	}
 
 	/* ****** BASE64 implementation created by Robert Harder ****** */
-
-	/** Specify encoding. */
-	private final static int Base64_ENCODE = 1;
-
-	/** Specify decoding. */
-	private final static int Base64_DECODE = 0;
-
-	/** Don't break lines when encoding (violates strict Base64 specification) */
-	private final static int Base64_DONT_BREAK_LINES = 8;
-
-	/** Maximum line length (76) of Base64 output. */
-	private final static int Base64_MAX_LINE_LENGTH = 76;
-
 	/** The equals sign (=) as a byte. */
 	private final static byte Base64_EQUALS_SIGN = (byte) '=';
 
-	/** The new line character (\n) as a byte. */
-	private final static byte Base64_NEW_LINE = (byte) '\n';
-
 	/** Preferred encoding. */
 	private final static String Base64_PREFERRED_ENCODING = "UTF-8";
 
-	/** The 64 valid Base64 values. */
-	private final static byte[] Base64_ALPHABET;
-
-	private final static byte[] Base64_NATIVE_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) '/' };
-
-	/** Determine which ALPHABET to use. */
-	static {
-		byte[] __bytes;
-		try {
-			__bytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
-					.getBytes(Base64_PREFERRED_ENCODING);
-		} // end try
-		catch (java.io.UnsupportedEncodingException use) {
-			__bytes = Base64_NATIVE_ALPHABET; // Fall back to native encoding
-		} // end catch
-		Base64_ALPHABET = __bytes;
-	} // end static
-
 	/**
 	 * Translates a Base64 value to either its 6-bit reconstruction value or a
 	 * negative number indicating some other meaning.
@@ -771,98 +722,6 @@ public class License {
 	private final static byte Base64_EQUALS_SIGN_ENC = -1; // Indicates equals
 
 	// sign in encoding
-
-	/**
-	 * 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>.
-	 * Code can reuse a byte array by passing a four-byte array as <var>b4</var>.
-	 * 
-	 * @param b4
-	 *            A reusable byte array to reduce array instantiation
-	 * @param threeBytes
-	 *            the array to convert
-	 * @param numSigBytes
-	 *            the number of significant bytes in your array
-	 * @return four byte array in Base64 notation.
-	 * @since 1.5.1
-	 */
-	private static byte[] base64_encode3to4(byte[] b4, byte[] threeBytes,
-			int numSigBytes) {
-		base64_encode3to4(threeBytes, 0, numSigBytes, b4, 0);
-		return b4;
-	} // end encode3to4
-
-	/**
-	 * 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
-	 * @return the <var>destination</var> array
-	 * @since 1.3
-	 */
-	private static byte[] base64_encode3to4(byte[] source, int srcOffset,
-			int numSigBytes, byte[] destination, int destOffset) {
-		// 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] = Base64_ALPHABET[(inBuff >>> 18)];
-			destination[destOffset + 1] = Base64_ALPHABET[(inBuff >>> 12) & 0x3f];
-			destination[destOffset + 2] = Base64_ALPHABET[(inBuff >>> 6) & 0x3f];
-			destination[destOffset + 3] = Base64_ALPHABET[(inBuff) & 0x3f];
-			return destination;
-
-		case 2:
-			destination[destOffset] = Base64_ALPHABET[(inBuff >>> 18)];
-			destination[destOffset + 1] = Base64_ALPHABET[(inBuff >>> 12) & 0x3f];
-			destination[destOffset + 2] = Base64_ALPHABET[(inBuff >>> 6) & 0x3f];
-			destination[destOffset + 3] = Base64_EQUALS_SIGN;
-			return destination;
-
-		case 1:
-			destination[destOffset] = Base64_ALPHABET[(inBuff >>> 18)];
-			destination[destOffset + 1] = Base64_ALPHABET[(inBuff >>> 12) & 0x3f];
-			destination[destOffset + 2] = Base64_EQUALS_SIGN;
-			destination[destOffset + 3] = Base64_EQUALS_SIGN;
-			return destination;
-
-		default:
-			return destination;
-		} // end switch
-	} // end encode3to4
-
 	/**
 	 * Decodes four bytes from array <var>source</var> and writes the resulting
 	 * bytes (up to three of them) to <var>destination</var>. The source and
@@ -1080,439 +939,4 @@ public class License {
 		return bytes;
 	} // end decode
 
-	/* ******** I N N E R C L A S S I N P U T S T R E A M ******** */
-
-	/**
-	 * A {@link Base64_InputStream} will read data from another
-	 * <tt>java.io.InputStream</tt>, given in the constructor, and
-	 * encode/decode to/from Base64 notation on the fly.
-	 * 
-	 * @see Base64
-	 * @since 1.3
-	 */
-	private static class Base64_InputStream extends java.io.FilterInputStream {
-		private boolean encode; // Encoding or decoding
-
-		private int position; // Current position in the buffer
-
-		private byte[] buffer; // Small buffer holding converted data
-
-		private int bufferLength; // Length of buffer (3 or 4)
-
-		private int numSigBytes; // Number of meaningful bytes in the buffer
-
-		private int lineLength;
-
-		private boolean breakLines; // Break lines at less than 80 characters
-
-		/**
-		 * Constructs a {@link Base64_InputStream} in DECODE mode.
-		 * 
-		 * @param in
-		 *            the <tt>java.io.InputStream</tt> from which to read
-		 *            data.
-		 * @since 1.3
-		 */
-		public Base64_InputStream(java.io.InputStream in) {
-			this(in, Base64_DECODE);
-		} // end constructor
-
-		/**
-		 * Constructs a {@link Base64_InputStream} in either ENCODE or DECODE
-		 * mode.
-		 * <p>
-		 * Valid options:
-		 * 
-		 * <pre>
-		 *                                   ENCODE or DECODE: Encode or Decode as data is read.
-		 *                                   DONT_BREAK_LINES: don't break lines at 76 characters
-		 *                                     (only meaningful when encoding)
-		 *                                     &lt;i&gt;Note: Technically, this makes your encoding non-compliant.&lt;/i&gt;
-		 * </pre>
-		 * 
-		 * <p>
-		 * Example: <code>new Base64.InputStream( in, Base64.DECODE )</code>
-		 * 
-		 * 
-		 * @param in
-		 *            the <tt>java.io.InputStream</tt> from which to read
-		 *            data.
-		 * @param options
-		 *            Specified options
-		 * @see Base64#Base64_ENCODE
-		 * @see Base64#Base64_DECODE
-		 * @see Base64#Base64_DONT_BREAK_LINES
-		 * @since 2.0
-		 */
-		public Base64_InputStream(java.io.InputStream in, int options) {
-			super(in);
-			this.breakLines = (options & Base64_DONT_BREAK_LINES) != Base64_DONT_BREAK_LINES;
-			this.encode = (options & Base64_ENCODE) == Base64_ENCODE;
-			this.bufferLength = encode ? 4 : 3;
-			this.buffer = new byte[bufferLength];
-			this.position = -1;
-			this.lineLength = 0;
-		} // end constructor
-
-		/**
-		 * Reads enough of the input stream to convert to/from Base64 and
-		 * returns the next byte.
-		 * 
-		 * @return next byte
-		 * @since 1.3
-		 */
-		public int read() throws java.io.IOException {
-			// Do we need to get data?
-			if (position < 0) {
-				if (encode) {
-					byte[] b3 = new byte[3];
-					int numBinaryBytes = 0;
-					for (int i = 0; i < 3; i++) {
-						try {
-							int b = in.read();
-
-							// If end of stream, b is -1.
-							if (b >= 0) {
-								b3[i] = (byte) b;
-								numBinaryBytes++;
-							} // end if: not end of stream
-
-						} // end try: read
-						catch (java.io.IOException e) {
-							// Only a problem if we got no data at all.
-							if (i == 0)
-								throw e;
-
-						} // end catch
-					} // end for: each needed input byte
-
-					if (numBinaryBytes > 0) {
-						base64_encode3to4(b3, 0, numBinaryBytes, buffer, 0);
-						position = 0;
-						numSigBytes = 4;
-					} // end if: got data
-					else {
-						return -1;
-					} // end else
-				} // end if: encoding
-
-				// Else decoding
-				else {
-					byte[] b4 = new byte[4];
-					int i = 0;
-					for (i = 0; i < 4; i++) {
-						// Read four "meaningful" bytes:
-						int b = 0;
-						do {
-							b = in.read();
-						} while (b >= 0
-								&& Base64_DECODABET[b & 0x7f] <= Base64_WHITE_SPACE_ENC);
-
-						if (b < 0)
-							break; // Reads a -1 if end of stream
-
-						b4[i] = (byte) b;
-					} // end for: each needed input byte
-
-					if (i == 4) {
-						numSigBytes = base64_decode4to3(b4, 0, buffer, 0);
-						position = 0;
-					} // end if: got four characters
-					else if (i == 0) {
-						return -1;
-					} // end else if: also padded correctly
-					else {
-						// Must have broken out from above.
-						throw new java.io.IOException(
-								"Improperly padded Base64 input.");
-					} // end
-
-				} // end else: decode
-			} // end else: get data
-
-			// Got data?
-			if (position >= 0) {
-				// End of relevant data?
-				if ( /* !encode && */position >= numSigBytes)
-					return -1;
-
-				if (encode && breakLines
-						&& lineLength >= Base64_MAX_LINE_LENGTH) {
-					lineLength = 0;
-					return '\n';
-				} // end if
-				else {
-					lineLength++; // This isn't important when decoding
-					// but throwing an extra "if" seems
-					// just as wasteful.
-
-					int b = buffer[position++];
-
-					if (position >= bufferLength)
-						position = -1;
-
-					return b & 0xFF; // This is how you "cast" a byte that's
-					// intended to be unsigned.
-				} // end else
-			} // end if: position >= 0
-
-			// Else error
-			else {
-				// When JDK1.4 is more accepted, use an assertion here.
-				throw new java.io.IOException(
-						"Error in Base64 code reading stream.");
-			} // end else
-		} // end read
-
-		/**
-		 * Calls {@link #read()} repeatedly until the end of stream is reached
-		 * or <var>len</var> bytes are read. Returns number of bytes read into
-		 * array or -1 if end of stream is encountered.
-		 * 
-		 * @param dest
-		 *            array to hold values
-		 * @param off
-		 *            offset for array
-		 * @param len
-		 *            max number of bytes to read into array
-		 * @return bytes read into array or -1 if end of stream is encountered.
-		 * @since 1.3
-		 */
-		public int read(byte[] dest, int off, int len)
-				throws java.io.IOException {
-			int i;
-			int b;
-			for (i = 0; i < len; i++) {
-				b = read();
-
-				// if( b < 0 && i == 0 )
-				// return -1;
-
-				if (b >= 0)
-					dest[off + i] = (byte) b;
-				else if (i == 0)
-					return -1;
-				else
-					break; // Out of 'for' loop
-			} // end for: each byte read
-			return i;
-		} // end read
-
-	} // end inner class InputStream
-
-	/* ******** I N N E R C L A S S O U T P U T S T R E A M ******** */
-
-	/**
-	 * A {@link Base64_OutputStream} will write data to another
-	 * <tt>java.io.OutputStream</tt>, given in the constructor, and
-	 * encode/decode to/from Base64 notation on the fly.
-	 * 
-	 * @see Base64
-	 * @since 1.3
-	 */
-	private static class Base64_OutputStream extends java.io.FilterOutputStream {
-		private boolean encode;
-
-		private int position;
-
-		private byte[] buffer;
-
-		private int bufferLength;
-
-		private int lineLength;
-
-		private boolean breakLines;
-
-		private byte[] b4; // Scratch used in a few places
-
-		private boolean suspendEncoding;
-
-		/**
-		 * Constructs a {@link Base64_OutputStream} in ENCODE mode.
-		 * 
-		 * @param out
-		 *            the <tt>java.io.OutputStream</tt> to which data will be
-		 *            written.
-		 * @since 1.3
-		 */
-		public Base64_OutputStream(java.io.OutputStream out) {
-			this(out, Base64_ENCODE);
-		} // end constructor
-
-		/**
-		 * Constructs a {@link Base64_OutputStream} in either ENCODE or DECODE
-		 * mode.
-		 * <p>
-		 * Valid options:
-		 * 
-		 * <pre>
-		 *                                   ENCODE or DECODE: Encode or Decode as data is read.
-		 *                                   DONT_BREAK_LINES: don't break lines at 76 characters
-		 *                                     (only meaningful when encoding)
-		 *                                     &lt;i&gt;Note: Technically, this makes your encoding non-compliant.&lt;/i&gt;
-		 * </pre>
-		 * 
-		 * <p>
-		 * Example: <code>new Base64.OutputStream( out, Base64.ENCODE )</code>
-		 * 
-		 * @param out
-		 *            the <tt>java.io.OutputStream</tt> to which data will be
-		 *            written.
-		 * @param options
-		 *            Specified options.
-		 * @see Base64#Base64_ENCODE
-		 * @see Base64#Base64_DECODE
-		 * @see Base64#Base64_DONT_BREAK_LINES
-		 * @since 1.3
-		 */
-		public Base64_OutputStream(java.io.OutputStream out, int options) {
-			super(out);
-			this.breakLines = (options & Base64_DONT_BREAK_LINES) != Base64_DONT_BREAK_LINES;
-			this.encode = (options & Base64_ENCODE) == Base64_ENCODE;
-			this.bufferLength = encode ? 3 : 4;
-			this.buffer = new byte[bufferLength];
-			this.position = 0;
-			this.lineLength = 0;
-			this.suspendEncoding = false;
-			this.b4 = new byte[4];
-		} // end constructor
-
-		/**
-		 * Writes the byte to the output stream after converting to/from Base64
-		 * notation. When encoding, bytes are buffered three at a time before
-		 * the output stream actually gets a write() call. When decoding, bytes
-		 * are buffered four at a time.
-		 * 
-		 * @param theByte
-		 *            the byte to write
-		 * @since 1.3
-		 */
-		public void write(int theByte) throws java.io.IOException {
-			// Encoding suspended?
-			if (suspendEncoding) {
-				super.out.write(theByte);
-				return;
-			} // end if: supsended
-
-			// Encode?
-			if (encode) {
-				buffer[position++] = (byte) theByte;
-				if (position >= bufferLength) // Enough to encode.
-				{
-					out.write(base64_encode3to4(b4, buffer, bufferLength));
-
-					lineLength += 4;
-					if (breakLines && lineLength >= Base64_MAX_LINE_LENGTH) {
-						out.write(Base64_NEW_LINE);
-						lineLength = 0;
-					} // end if: end of line
-
-					position = 0;
-				} // end if: enough to output
-			} // end if: encoding
-
-			// Else, Decoding
-			else {
-				// Meaningful Base64 character?
-				if (Base64_DECODABET[theByte & 0x7f] > Base64_WHITE_SPACE_ENC) {
-					buffer[position++] = (byte) theByte;
-					if (position >= bufferLength) // Enough to output.
-					{
-						int len = base64_decode4to3(buffer, 0, b4, 0);
-						out.write(b4, 0, len);
-						// out.write( Base64.decode4to3( buffer ) );
-						position = 0;
-					} // end if: enough to output
-				} // end if: meaningful base64 character
-				else if (Base64_DECODABET[theByte & 0x7f] != Base64_WHITE_SPACE_ENC) {
-					throw new java.io.IOException(
-							"Invalid character in Base64 data.");
-				} // end else: not white space either
-			} // end else: decoding
-		} // end write
-
-		/**
-		 * Calls {@link #write(int)} repeatedly until <var>len</var> bytes are
-		 * written.
-		 * 
-		 * @param theBytes
-		 *            array from which to read bytes
-		 * @param off
-		 *            offset for array
-		 * @param len
-		 *            max number of bytes to read into array
-		 * @since 1.3
-		 */
-		public void write(byte[] theBytes, int off, int len)
-				throws java.io.IOException {
-			// Encoding suspended?
-			if (suspendEncoding) {
-				super.out.write(theBytes, off, len);
-				return;
-			} // end if: supsended
-
-			for (int i = 0; i < len; i++) {
-				write(theBytes[off + i]);
-			} // end for: each byte written
-
-		} // end write
-
-		/**
-		 * Method added by PHIL. [Thanks, PHIL. -Rob] This pads the buffer
-		 * without closing the stream.
-		 */
-		public void flushBase64() throws java.io.IOException {
-			if (position > 0) {
-				if (encode) {
-					out.write(base64_encode3to4(b4, buffer, position));
-					position = 0;
-				} // end if: encoding
-				else {
-					throw new java.io.IOException(
-							"Base64 input not properly padded.");
-				} // end else: decoding
-			} // end if: buffer partially full
-
-		} // end flush
-
-		/**
-		 * Flushes and closes (I think, in the superclass) the stream.
-		 * 
-		 * @since 1.3
-		 */
-		public void close() throws java.io.IOException {
-			// 1. Ensure that pending characters are written
-			flushBase64();
-
-			// 2. Actually close the stream
-			// Base class both flushes and closes.
-			super.close();
-
-			buffer = null;
-			out = null;
-		} // end close
-
-		/**
-		 * Suspends encoding of the stream. May be helpful if you need to embed
-		 * a piece of base640-encoded data in a stream.
-		 * 
-		 * @since 1.5.1
-		 */
-		public void suspendEncoding() throws java.io.IOException {
-			flushBase64();
-			this.suspendEncoding = true;
-		} // end suspendEncoding
-
-		/**
-		 * Resumes encoding of the stream. May be helpful if you need to embed a
-		 * piece of base640-encoded data in a stream.
-		 * 
-		 * @since 1.5.1
-		 */
-		public void resumeEncoding() {
-			this.suspendEncoding = false;
-		} // end resumeEncoding
-
-	} // end inner class OutputStream
-
 }