/* ====================================================================
* 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.CharsetDecoder;
import java.nio.charset.CoderResult;
/**
* <p>
* The CharsetDecoder used to decode both variants of the UTF-7 charset and the
* modified-UTF-7 charset.
* </p>
*
* @author Jaap Beetstra
*/
class UTF7StyleCharsetDecoder extends CharsetDecoder {
private final Base64Util base64;
private final byte shift;
private final byte unshift;
private final boolean strict;
private boolean base64mode;
private int bitsRead;
private int tempChar;
private boolean justShifted;
private boolean justUnshifted;
UTF7StyleCharsetDecoder(UTF7StyleCharset cs, Base64Util base64, boolean strict) {
super(cs, 0.6f, 1.0f);
this.base64 = base64;
this.strict = strict;
this.shift = cs.shift();
this.unshift = cs.unshift();
}
/*
* (non-Javadoc)
* @see java.nio.charset.CharsetDecoder#decodeLoop(java.nio.ByteBuffer,
* java.nio.CharBuffer)
*/
protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
while (in.hasRemaining()) {
byte b = in.get();
if (base64mode) {
if (b == unshift) {
if (base64bitsWaiting())
return malformed(in);
if (justShifted) {
if (!out.hasRemaining())
return overflow(in);
out.put((char)shift);
} else
justUnshifted = true;
setUnshifted();
} else {
if (!out.hasRemaining())
return overflow(in);
CoderResult result = handleBase64(in, out, b);
if (result != null)
return result;
}
justShifted = false;
} else {
if (b == shift) {
base64mode = true;
if (justUnshifted && strict)
return malformed(in);
justShifted = true;
continue;
}
if (!out.hasRemaining())
return overflow(in);
out.put((char)b);
justUnshifted = false;
}
}
return CoderResult.UNDERFLOW;
}
private CoderResult overflow(ByteBuffer in) {
in.position(in.position() - 1);
return CoderResult.OVERFLOW;
}
/**
* <p>
* Decodes a byte in <i>base 64 mode</i>. Will directly write a character to
* the output buffer if completed.
* </p>
*
* @param in The input buffer
* @param out The output buffer
* @param lastRead Last byte read from the input buffer
* @return CoderResult.malformed if a non-base 64 character was encountered
* in strict mode, null otherwise
*/
private CoderResult handleBase64(ByteBuffer in, CharBuffer out, byte lastRead) {
CoderResult result = null;
int sextet = base64.getSextet(lastRead);
if (sextet >= 0) {
bitsRead += 6;
if (bitsRead < 16) {
tempChar += sextet << (16 - bitsRead);
} else {
bitsRead -= 16;
tempChar += sextet >> (bitsRead);
out.put((char)tempChar);
tempChar = (sextet << (16 - bitsRead)) & 0xFFFF;
}
} else {
if (strict)
return malformed(in);
out.put((char)lastRead);
if (base64bitsWaiting())
result = malformed(in);
setUnshifted();
}
return result;
}
/*
* (non-Javadoc)
* @see java.nio.charset.CharsetDecoder#implFlush(java.nio.CharBuffer)
*/
protected CoderResult implFlush(CharBuffer out) {
if ((base64mode && strict) || base64bitsWaiting())
return CoderResult.malformedForLength(1);
return CoderResult.UNDERFLOW;
}
/*
* (non-Javadoc)
* @see java.nio.charset.CharsetDecoder#implReset()
*/
protected void implReset() {
setUnshifted();
justUnshifted = false;
}
/**
* <p>
* Resets the input buffer position to just before the last byte read, and
* returns a result indicating to skip the last byte.
* </p>
*
* @param in The input buffer
* @return CoderResult.malformedForLength(1);
*/
private CoderResult malformed(ByteBuffer in) {
in.position(in.position() - 1);
return CoderResult.malformedForLength(1);
}
/**
* @return True if there are base64 encoded characters waiting to be written
*/
private boolean base64bitsWaiting() {
return tempChar != 0 || bitsRead >= 6;
}
/**
* <p>
* Updates internal state to reflect the decoder is no longer in <i>base 64
* mode</i>
* </p>
*/
private void setUnshifted() {
base64mode = false;
bitsRead = 0;
tempChar = 0;
}
}