src/com/beetstra/jutf7/UTF7StyleCharsetEncoder.java - platform/packages/apps/Email - Git at Google

 /* ====================================================================
  * Copyright (c) 2006 J.T. Beetstra
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sublicense, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  * ====================================================================
  */

 package com.beetstra.jutf7;

 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.charset.CharsetEncoder;
 import java.nio.charset.CoderResult;

 /**
  * <p>
  * The CharsetEncoder used to encode both variants of the UTF-7 charset and the
  * modified-UTF-7 charset.
  * </p>
  * <p>
  * <strong>Please note this class does not behave strictly according to the
  * specification in Sun Java VMs before 1.6.</strong> This is done to get around
  * a bug in the implementation of
  * {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)}. Unfortunately,
  * that method cannot be overridden.
  * </p>
  *
  * @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">JDK
  *      bug 6221056< /a>
  * @author Jaap Beetstra
  */
 class UTF7StyleCharsetEncoder extends CharsetEncoder {
     private static final float AVG_BYTES_PER_CHAR = 1.5f;
     private static final float MAX_BYTES_PER_CHAR = 5.0f;
     private final UTF7StyleCharset cs;
     private final Base64Util base64;
     private final byte shift;
     private final byte unshift;
     private final boolean strict;
     private boolean base64mode;
     private int bitsToOutput;
     private int sextet;
     static boolean useUglyHackToForceCallToFlushInJava5;
     static {
         String version = System.getProperty("java.specification.version");
         String vendor = System.getProperty("java.vm.vendor");
         useUglyHackToForceCallToFlushInJava5 = "1.4".equals(version) || "1.5".equals(version);
         useUglyHackToForceCallToFlushInJava5 &= "Sun Microsystems Inc.".equals(vendor);
     }

     UTF7StyleCharsetEncoder(UTF7StyleCharset cs, Base64Util base64, boolean strict) {
         super(cs, AVG_BYTES_PER_CHAR, MAX_BYTES_PER_CHAR);
         this.cs = cs;
         this.base64 = base64;
         this.strict = strict;
         this.shift = cs.shift();
         this.unshift = cs.unshift();
     }

     /*
      * (non-Javadoc)
      * @see java.nio.charset.CharsetEncoder#implReset()
      */
     protected void implReset() {
         base64mode = false;
         sextet = 0;
         bitsToOutput = 0;
     }

     /**
      * {@inheritDoc}
      * <p>
      * Note that this method might return <code>CoderResult.OVERFLOW</code> (as
      * is required by the specification) if insufficient space is available in
      * the output buffer. However, calling it again on JDKs before Java 6
      * triggers a bug in
      * {@link java.nio.charset.CharsetEncoder#flush(ByteBuffer)} causing it to
      * throw an IllegalStateException (the buggy method is <code>final</code>,
      * thus cannot be overridden).
      * </p>
      *
      * @see <a
      *      href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6227608">
      *      JDK bug 6227608< /a>
      * @param out The output byte buffer
      * @return A coder-result object describing the reason for termination
      */
     protected CoderResult implFlush(ByteBuffer out) {
         if (base64mode) {
             if (out.remaining() < 2)
                 return CoderResult.OVERFLOW;
             if (bitsToOutput != 0)
                 out.put(base64.getChar(sextet));
             out.put(unshift);
         }
         return CoderResult.UNDERFLOW;
     }

     /**
      * {@inheritDoc}
      * <p>
      * Note that this method might return <code>CoderResult.OVERFLOW</code>,
      * even though there is sufficient space available in the output buffer.
      * This is done to force the broken implementation of
      * {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)} to call flush
      * (the buggy method is <code>final</code>, thus cannot be overridden).
      * </p>
      * <p>
      * However, String.getBytes() fails if CoderResult.OVERFLOW is returned,
      * since this assumes it always allocates sufficient bytes (maxBytesPerChar
      * * nr_of_chars). Thus, as an extra check, the size of the input buffer is
      * compared against the size of the output buffer. A static variable is used
      * to indicate if a broken java version is used.
      * </p>
      * <p>
      * It is not possible to directly write the last few bytes, since more bytes
      * might be waiting to be encoded then those available in the input buffer.
      * </p>
      *
      * @see <a
      *      href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">
      *      JDK bug 6221056< /a>
      * @param in The input character buffer
      * @param out The output byte buffer
      * @return A coder-result object describing the reason for termination
      */
     protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
         while (in.hasRemaining()) {
             if (out.remaining() < 4)
                 return CoderResult.OVERFLOW;
             char ch = in.get();
             if (cs.canEncodeDirectly(ch)) {
                 unshift(out, ch);
                 out.put((byte)ch);
             } else if (!base64mode && ch == shift) {
                 out.put(shift);
                 out.put(unshift);
             } else
                 encodeBase64(ch, out);
         }
         /*
          * <HACK type="ugly"> These lines are required to trick JDK 1.5 and
          * earlier into flushing when using Charset.encode(String),
          * Charset.encode(CharBuffer) or CharsetEncoder.encode(CharBuffer)
          * Without them, the last few bytes may be missing.
          */
         if (base64mode && useUglyHackToForceCallToFlushInJava5
                 && out.limit() != MAX_BYTES_PER_CHAR * in.limit())
             return CoderResult.OVERFLOW;
         /* </HACK> */
         return CoderResult.UNDERFLOW;
     }

     /**
      * <p>
      * Writes the bytes necessary to leave <i>base 64 mode</i>. This might
      * include an unshift character.
      * </p>
      *
      * @param out
      * @param ch
      */
     private void unshift(ByteBuffer out, char ch) {
         if (!base64mode)
             return;
         if (bitsToOutput != 0)
             out.put(base64.getChar(sextet));
         if (base64.contains(ch) || ch == unshift || strict)
             out.put(unshift);
         base64mode = false;
         sextet = 0;
         bitsToOutput = 0;
     }

     /**
      * <p>
      * Writes the bytes necessary to encode a character in <i>base 64 mode</i>.
      * All bytes which are fully determined will be written. The fields
      * <code>bitsToOutput</code> and <code>sextet</code> are used to remember
      * the bytes not yet fully determined.
      * </p>
      *
      * @param out
      * @param ch
      */
     private void encodeBase64(char ch, ByteBuffer out) {
         if (!base64mode)
             out.put(shift);
         base64mode = true;
         bitsToOutput += 16;
         while (bitsToOutput >= 6) {
             bitsToOutput -= 6;
             sextet += (ch >> bitsToOutput);
             sextet &= 0x3F;
             out.put(base64.getChar(sextet));
             sextet = 0;
         }
         sextet = (ch << (6 - bitsToOutput)) & 0x3F;
     }
 }
	/* ====================================================================
	* Copyright (c) 2006 J.T. Beetstra
	*
	* Permission is hereby granted, free of charge, to any person obtaining
	* a copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sublicense, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice shall be
	* included in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	* ====================================================================
	*/

	package com.beetstra.jutf7;

	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.charset.CharsetEncoder;
	import java.nio.charset.CoderResult;

	/**
	* <p>
	* The CharsetEncoder used to encode both variants of the UTF-7 charset and the
	* modified-UTF-7 charset.
	* </p>
	* <p>
	* <strong>Please note this class does not behave strictly according to the
	* specification in Sun Java VMs before 1.6.</strong> This is done to get around
	* a bug in the implementation of
	* {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)}. Unfortunately,
	* that method cannot be overridden.
	* </p>
	*
	* @see <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">JDK
	* bug 6221056< /a>
	* @author Jaap Beetstra
	*/
	class UTF7StyleCharsetEncoder extends CharsetEncoder {
	private static final float AVG_BYTES_PER_CHAR = 1.5f;
	private static final float MAX_BYTES_PER_CHAR = 5.0f;
	private final UTF7StyleCharset cs;
	private final Base64Util base64;
	private final byte shift;
	private final byte unshift;
	private final boolean strict;
	private boolean base64mode;
	private int bitsToOutput;
	private int sextet;
	static boolean useUglyHackToForceCallToFlushInJava5;
	static {
	String version = System.getProperty("java.specification.version");
	String vendor = System.getProperty("java.vm.vendor");
	useUglyHackToForceCallToFlushInJava5 = "1.4".equals(version) \|\| "1.5".equals(version);
	useUglyHackToForceCallToFlushInJava5 &= "Sun Microsystems Inc.".equals(vendor);
	}

	UTF7StyleCharsetEncoder(UTF7StyleCharset cs, Base64Util base64, boolean strict) {
	super(cs, AVG_BYTES_PER_CHAR, MAX_BYTES_PER_CHAR);
	this.cs = cs;
	this.base64 = base64;
	this.strict = strict;
	this.shift = cs.shift();
	this.unshift = cs.unshift();
	}

	/*
	* (non-Javadoc)
	* @see java.nio.charset.CharsetEncoder#implReset()
	*/
	protected void implReset() {
	base64mode = false;
	sextet = 0;
	bitsToOutput = 0;
	}

	/**
	* {@inheritDoc}
	* <p>
	* Note that this method might return <code>CoderResult.OVERFLOW</code> (as
	* is required by the specification) if insufficient space is available in
	* the output buffer. However, calling it again on JDKs before Java 6
	* triggers a bug in
	* {@link java.nio.charset.CharsetEncoder#flush(ByteBuffer)} causing it to
	* throw an IllegalStateException (the buggy method is <code>final</code>,
	* thus cannot be overridden).
	* </p>
	*
	* @see <a
	* href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6227608">
	* JDK bug 6227608< /a>
	* @param out The output byte buffer
	* @return A coder-result object describing the reason for termination
	*/
	protected CoderResult implFlush(ByteBuffer out) {
	if (base64mode) {
	if (out.remaining() < 2)
	return CoderResult.OVERFLOW;
	if (bitsToOutput != 0)
	out.put(base64.getChar(sextet));
	out.put(unshift);
	}
	return CoderResult.UNDERFLOW;
	}

	/**
	* {@inheritDoc}
	* <p>
	* Note that this method might return <code>CoderResult.OVERFLOW</code>,
	* even though there is sufficient space available in the output buffer.
	* This is done to force the broken implementation of
	* {@link java.nio.charset.CharsetEncoder#encode(CharBuffer)} to call flush
	* (the buggy method is <code>final</code>, thus cannot be overridden).
	* </p>
	* <p>
	* However, String.getBytes() fails if CoderResult.OVERFLOW is returned,
	* since this assumes it always allocates sufficient bytes (maxBytesPerChar
	* * nr_of_chars). Thus, as an extra check, the size of the input buffer is
	* compared against the size of the output buffer. A static variable is used
	* to indicate if a broken java version is used.
	* </p>
	* <p>
	* It is not possible to directly write the last few bytes, since more bytes
	* might be waiting to be encoded then those available in the input buffer.
	* </p>
	*
	* @see <a
	* href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6221056">
	* JDK bug 6221056< /a>
	* @param in The input character buffer
	* @param out The output byte buffer
	* @return A coder-result object describing the reason for termination
	*/
	protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
	while (in.hasRemaining()) {
	if (out.remaining() < 4)
	return CoderResult.OVERFLOW;
	char ch = in.get();
	if (cs.canEncodeDirectly(ch)) {
	unshift(out, ch);
	out.put((byte)ch);
	} else if (!base64mode && ch == shift) {
	out.put(shift);
	out.put(unshift);
	} else
	encodeBase64(ch, out);
	}
	/*
	* <HACK type="ugly"> These lines are required to trick JDK 1.5 and
	* earlier into flushing when using Charset.encode(String),
	* Charset.encode(CharBuffer) or CharsetEncoder.encode(CharBuffer)
	* Without them, the last few bytes may be missing.
	*/
	if (base64mode && useUglyHackToForceCallToFlushInJava5
	&& out.limit() != MAX_BYTES_PER_CHAR * in.limit())
	return CoderResult.OVERFLOW;
	/* </HACK> */
	return CoderResult.UNDERFLOW;
	}

	/**
	* <p>
	* Writes the bytes necessary to leave <i>base 64 mode</i>. This might
	* include an unshift character.
	* </p>
	*
	* @param out
	* @param ch
	*/
	private void unshift(ByteBuffer out, char ch) {
	if (!base64mode)
	return;
	if (bitsToOutput != 0)
	out.put(base64.getChar(sextet));
	if (base64.contains(ch) \|\| ch == unshift \|\| strict)
	out.put(unshift);
	base64mode = false;
	sextet = 0;
	bitsToOutput = 0;
	}

	/**
	* <p>
	* Writes the bytes necessary to encode a character in <i>base 64 mode</i>.
	* All bytes which are fully determined will be written. The fields
	* <code>bitsToOutput</code> and <code>sextet</code> are used to remember
	* the bytes not yet fully determined.
	* </p>
	*
	* @param out
	* @param ch
	*/
	private void encodeBase64(char ch, ByteBuffer out) {
	if (!base64mode)
	out.put(shift);
	base64mode = true;
	bitsToOutput += 16;
	while (bitsToOutput >= 6) {
	bitsToOutput -= 6;
	sextet += (ch >> bitsToOutput);
	sextet &= 0x3F;
	out.put(base64.getChar(sextet));
	sextet = 0;
	}
	sextet = (ch << (6 - bitsToOutput)) & 0x3F;
	}
	}