0 <= usedCharacters <= 50).
* @return the specified text if encoding is not necessary or an encoded
* word or a sequence of encoded words otherwise.
*/
public static String encodeIfNecessary(String text, Usage usage,
int usedCharacters) {
if (hasToBeEncoded(text, usedCharacters))
return encodeEncodedWord(text, usage, usedCharacters);
else
return text;
}
/**
* Determines if the specified string has to encoded into an encoded-word.
* Returns true if the text contains characters that don't
* fall into the printable ASCII character set or if the text contains a
* 'word' (sequence of non-whitespace characters) longer than 77 characters
* (including characters already used up in the line).
*
* @param text
* text to analyze.
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @return true if the specified text has to be encoded into
* an encoded-word, false otherwise.
*/
public static boolean hasToBeEncoded(String text, int usedCharacters) {
if (text == null)
throw new IllegalArgumentException();
if (usedCharacters < 0 || usedCharacters > MAX_USED_CHARACTERS)
throw new IllegalArgumentException();
int nonWhiteSpaceCount = usedCharacters;
for (int idx = 0; idx < text.length(); idx++) {
char ch = text.charAt(idx);
if (ch == '\t' || ch == ' ') {
nonWhiteSpaceCount = 0;
} else {
nonWhiteSpaceCount++;
if (nonWhiteSpaceCount > 77) {
// Line cannot be folded into multiple lines with no more
// than 78 characters each. Encoding as encoded-words makes
// that possible. One character has to be reserved for
// folding white space; that leaves 77 characters.
return true;
}
if (ch < 32 || ch >= 127) {
// non-printable ascii character has to be encoded
return true;
}
}
}
return false;
}
/**
* Encodes the specified text into an encoded word or a sequence of encoded
* words separated by space. The text is separated into a sequence of
* encoded words if it does not fit in a single one.
* * The charset to encode the specified text into a byte array and the * encoding to use for the encoded-word are detected automatically. *
* This method assumes that zero characters have already been used up in the * current line. * * @param text * text to encode. * @param usage * whether the encoded-word is to be used to replace a text token * or a word entity (see RFC 822). * @return the encoded word (or sequence of encoded words if the given text * does not fit in a single encoded word). * @see #hasToBeEncoded(String, int) */ public static String encodeEncodedWord(String text, Usage usage) { return encodeEncodedWord(text, usage, 0, null, null); } /** * Encodes the specified text into an encoded word or a sequence of encoded * words separated by space. The text is separated into a sequence of * encoded words if it does not fit in a single one. *
* The charset to encode the specified text into a byte array and the
* encoding to use for the encoded-word are detected automatically.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @return the encoded word (or sequence of encoded words if the given text
* does not fit in a single encoded word).
* @see #hasToBeEncoded(String, int)
*/
public static String encodeEncodedWord(String text, Usage usage,
int usedCharacters) {
return encodeEncodedWord(text, usage, usedCharacters, null, null);
}
/**
* Encodes the specified text into an encoded word or a sequence of encoded
* words separated by space. The text is separated into a sequence of
* encoded words if it does not fit in a single one.
*
* @param text
* text to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @param usedCharacters
* number of characters already used up (0 <= usedCharacters <= 50).
* @param charset
* the Java charset that should be used to encode the specified
* string into a byte array. A suitable charset is detected
* automatically if this parameter is null.
* @param encoding
* the encoding to use for the encoded-word (either B or Q). A
* suitable encoding is automatically chosen if this parameter is
* null.
* @return the encoded word (or sequence of encoded words if the given text
* does not fit in a single encoded word).
* @see #hasToBeEncoded(String, int)
*/
public static String encodeEncodedWord(String text, Usage usage,
int usedCharacters, Charset charset, Encoding encoding) {
if (text == null)
throw new IllegalArgumentException();
if (usedCharacters < 0 || usedCharacters > MAX_USED_CHARACTERS)
throw new IllegalArgumentException();
if (charset == null)
charset = determineCharset(text);
String mimeCharset = CharsetUtil.toMimeCharset(charset.name());
if (mimeCharset == null) {
// cannot happen if charset was originally null
throw new IllegalArgumentException("Unsupported charset");
}
byte[] bytes = encode(text, charset);
if (encoding == null)
encoding = determineEncoding(bytes, usage);
if (encoding == Encoding.B) {
String prefix = ENC_WORD_PREFIX + mimeCharset + "?B?";
return encodeB(prefix, text, usedCharacters, charset, bytes);
} else {
String prefix = ENC_WORD_PREFIX + mimeCharset + "?Q?";
return encodeQ(prefix, text, usage, usedCharacters, charset, bytes);
}
}
/**
* Encodes the specified byte array using the B encoding defined in RFC
* 2047.
*
* @param bytes
* byte array to encode.
* @return encoded string.
*/
public static String encodeB(byte[] bytes) {
StringBuilder sb = new StringBuilder();
int idx = 0;
final int end = bytes.length;
for (; idx < end - 2; idx += 3) {
int data = (bytes[idx] & 0xff) << 16 | (bytes[idx + 1] & 0xff) << 8
| bytes[idx + 2] & 0xff;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 6 & 0x3f]);
sb.append((char) BASE64_TABLE[data & 0x3f]);
}
if (idx == end - 2) {
int data = (bytes[idx] & 0xff) << 16 | (bytes[idx + 1] & 0xff) << 8;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 6 & 0x3f]);
sb.append((char) BASE64_PAD);
} else if (idx == end - 1) {
int data = (bytes[idx] & 0xff) << 16;
sb.append((char) BASE64_TABLE[data >> 18 & 0x3f]);
sb.append((char) BASE64_TABLE[data >> 12 & 0x3f]);
sb.append((char) BASE64_PAD);
sb.append((char) BASE64_PAD);
}
return sb.toString();
}
/**
* Encodes the specified byte array using the Q encoding defined in RFC
* 2047.
*
* @param bytes
* byte array to encode.
* @param usage
* whether the encoded-word is to be used to replace a text token
* or a word entity (see RFC 822).
* @return encoded string.
*/
public static String encodeQ(byte[] bytes, Usage usage) {
BitSet qChars = usage == Usage.TEXT_TOKEN ? Q_REGULAR_CHARS
: Q_RESTRICTED_CHARS;
StringBuilder sb = new StringBuilder();
final int end = bytes.length;
for (int idx = 0; idx < end; idx++) {
int v = bytes[idx] & 0xff;
if (v == 32) {
sb.append('_');
} else if (!qChars.get(v)) {
sb.append('=');
sb.append(hexDigit(v >>> 4));
sb.append(hexDigit(v & 0xf));
} else {
sb.append((char) v);
}
}
return sb.toString();
}
/**
* Tests whether the specified string is a token as defined in RFC 2045
* section 5.1.
*
* @param str
* string to test.
* @return true if the specified string is a RFC 2045 token,
* false otherwise.
*/
public static boolean isToken(String str) {
// token := 1*