net.freeutils.charset.UTF7Charset Maven / Gradle / Ivy
/*
* Copyright © 2005-2015 Amichai Rothman
*
* This file is part of JCharset - the Java Charset package.
*
* JCharset is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* JCharset is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with JCharset. If not, see A charset C is said to contain a charset D if,
* and only if, every character representable in D is also
* representable in C. If this relationship holds then it is
* guaranteed that every string that can be encoded in D can also be
* encoded in C without performing any replacements.
*
*
That C contains D does not imply that each character
* representable in C by a particular byte sequence is represented
* in D by the same byte sequence, although sometimes this is the
* case.
*
*
Every charset contains itself.
*
*
This method computes an approximation of the containment relation:
* If it returns true then the given charset is known to be
* contained by this charset; if it returns false, however, then
* it is not necessarily the case that the given charset is not contained
* in this charset.
*
* @return true if, and only if, the given charset
* is contained in this charset
*/
@Override
public boolean contains(Charset charset) {
return getClass().isInstance(charset) || Charset.forName("UTF-16").contains(charset);
}
/**
* Constructs a new decoder for this charset.
*
* @return a new decoder for this charset
*/
@Override
public CharsetDecoder newDecoder() {
return new Decoder(this);
}
/**
* Constructs a new encoder for this charset.
*
* @return a new encoder for this charset
*
* @throws UnsupportedOperationException
* if this charset does not support encoding
*/
@Override
public CharsetEncoder newEncoder() {
return new Encoder(this);
}
/**
* The Encoder inner class handles the encoding of the UTF7 charset.
*/
protected class Encoder extends CharsetEncoder {
boolean shifted; // flags whether we are currently in a shift sequence
char encodedChar; // holds the bits of previous partially encoded char
int requiredBits; // number of bits required to complete a 6-bit value
/**
* Constructs an Encoder.
*
* @param charset the charset to which this encoder belongs
*/
protected Encoder(Charset charset) {
super(charset, 1f, 5f);
}
/**
* Resets this decoder, clearing any charset-specific internal state.
*/
@Override
protected void implReset() {
shifted = false;
}
/**
* Flushes this encoder.
*
* @param out the output byte buffer
* @return a coder-result object, either {@link CoderResult#UNDERFLOW} or
* {@link CoderResult#OVERFLOW}
*/
@Override
protected CoderResult implFlush(ByteBuffer out) {
if (shifted) {
if (out.remaining() < 2)
return CoderResult.OVERFLOW;
flushBase64Char(out);
out.put((byte)'-'); // terminate shift sequence explicitly
}
return CoderResult.UNDERFLOW;
}
/**
* Encodes one or more characters into one or more bytes.
*
* @param in the input character buffer
* @param out the output byte buffer
* @return a coder-result object describing the reason for termination
*/
@Override
protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
int remaining = in.remaining();
while (remaining-- > 0) {
// make sure we have output space (the max we might need)
if (out.remaining() < 3)
return CoderResult.OVERFLOW;
// get next byte
char c = in.get();
// if not in shift sequence
if (!shifted) {
// if char is in set D, write it as byte directly
if (isDirect(c)) {
out.put((byte)c);
} else if (c == '+') { // specially encoded char
out.put((byte)'+').put((byte)'-');
} else { // start shift sequence
out.put((byte)'+');
shifted = true;
requiredBits = 6;
writeBase64Char(out, c);
}
} else { // shifted
if (isDirect(c)) { // direct char
// terminate shift sequence
shifted = false;
flushBase64Char(out);
if (isBSet(c) || c == '-') // requires explicit termination
out.put((byte)'-');
// write direct char
out.put((byte)c);
} else { // another encoded char
writeBase64Char(out, c);
}
}
}
return CoderResult.UNDERFLOW;
}
/**
* Writes the base64 bytes representing the given character
* to the given output ByteBuffer. Bits left over from
* previously written characters are written first, followed
* by this character's bits. Similarly, bits left over from
* this character are saved until the next call to this method.
*
* @param out the ByteBuffer to which the base64 bytes are written
* @param c the character to be written
*/
void writeBase64Char(ByteBuffer out, char c) {
int bits = requiredBits; // getfield bytecode optimization
byte b = (byte)(((encodedChar << bits) & 0x3F) | (c >>> (16 - bits)));
out.put(toBase64(b));
b = (byte)((c >>> (10 - bits)) & 0x3F);
out.put(toBase64(b));
if (bits != 6) {
b = (byte)((c >>> (4 - bits)) & 0x3F);
out.put(toBase64(b));
requiredBits += 2;
} else {
requiredBits = 2;
}
encodedChar = c;
}
/**
* Writes any left-over base64 bits.
*
* @param out the ByteBuffer to which the base64 bytes are written
*/
void flushBase64Char(ByteBuffer out) {
if (requiredBits != 6) { // dump last encoded byte, zero-bit padded
byte b = (byte)((encodedChar << requiredBits) & 0x3F);
out.put(toBase64(b));
}
}
} // Encoder class
/**
* The Decoder inner class handles the decoding of the UTF7 charset.
*/
protected class Decoder extends CharsetDecoder {
boolean shifted; // flags whether we are currently in a shift sequence
boolean emptyShift; // flags whether the current shift sequence is empty
char decodedChar; // holds the bits of previous partially decoded char
int requiredBits; // number of bits required to complete a 16-bit char
/**
* Constructs a Decoder.
*
* @param charset the charset to which this decoder belongs
*/
protected Decoder(Charset charset) {
super(charset, 1f, 1f);
}
/**
* Resets this decoder, clearing any charset-specific internal state.
*/
@Override
protected void implReset() {
shifted = false;
}
/**
* Decodes one or more bytes into one or more characters.
*
* @param in the input byte buffer
* @param out the output character buffer
* @return a coder-result object describing the reason for termination
*/
@Override
protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
int val;
int remaining = in.remaining();
while (remaining-- > 0) {
// make sure we have output space
if (out.remaining() < 1)
return CoderResult.OVERFLOW;
// get next byte
byte b = in.get();
// if not in shift sequence
if (!shifted) {
// if byte is in set D or O, write it as char
if (isDorOSet(b)) {
out.put((char)b);
} else if (b == '+') { // start shift sequence
shifted = true;
emptyShift = true;
requiredBits = 16;
} else { // invalid byte
in.position(in.position() - 1); // position input at error byte
return CoderResult.malformedForLength(1); // invalid byte
}
} else if ((val = fromBase64(b)) != -1) { // valid base64 byte
// get bits from shift sequence byte
emptyShift = false;
// 6 is the max number of bits we can get from a single input byte
int bits = requiredBits >= 6 ? 6 : requiredBits;
// add new bits to currently decoded char
decodedChar = (char)((decodedChar << bits) | (val >> (6 - bits)));
requiredBits -= bits;
// check if we're done decoding a full 16-bit char
if (requiredBits == 0) {
// output it
out.put(decodedChar);
// and start off next char with remaining bits
requiredBits = 10 + bits; // 16 - (6 - bits)
decodedChar = (char)val; // save the extra bits for later
}
} else { // terminating a shift sequence
shifted = false;
// any leftover bits when terminating the shift sequence
// are discarded if they are zero, or invalid if they are nonzero
if ((char)(decodedChar << requiredBits) != 0) {
in.position(in.position() - 1); // position input at error byte
return CoderResult.malformedForLength(1); // invalid byte
}
// process implicit or explicit shift sequence termination
if (b == '-') {
if (emptyShift) // a "+-" sequence outputs a '+'
out.put('+');
// otherwise shift ends, and '-' is absorbed
} else {
// process regular char that ended base64 sequence
if (isDorOSet(b)) { // output regular char
out.put((char)b);
} else {
in.position(in.position() - 1); // position input at error byte
return CoderResult.malformedForLength(1); // invalid byte
}
}
}
}
return CoderResult.UNDERFLOW;
}
} // Decoder class
}