true if compression was successful or
* false otherwise.
*/
public static boolean compress(final ByteSequence input,
final ByteStringBuilder output)
{
final byte[] inputBytes = input.toByteArray();
final byte[] outputBytes = new byte[inputBytes.length];
final int compressedSize = compress(inputBytes, 0, inputBytes.length,
outputBytes, 0, outputBytes.length);
if (compressedSize != -1)
{
if (StaticUtils.DEBUG_LOG.isLoggable(Level.FINE))
{
StaticUtils.DEBUG_LOG.fine(String.format("Compression %d/%d%n",
compressedSize, inputBytes.length));
}
output.append(outputBytes, 0, compressedSize);
return true;
}
return false;
}
/**
* Returns a string containing provided date formatted using the generalized
* time syntax.
*
* @param date
* The date to be formated.
* @return The string containing provided date formatted using the generalized
* time syntax.
* @throws NullPointerException
* If {@code date} was {@code null}.
*/
public static String formatAsGeneralizedTime(final Date date)
throws NullPointerException
{
return formatAsGeneralizedTime(date.getTime());
}
/**
* Returns a string containing provided date formatted using the generalized
* time syntax.
*
* @param date
* The date to be formated.
* @return The string containing provided date formatted using the generalized
* time syntax.
* @throws IllegalArgumentException
* If {@code date} was invalid.
*/
public static String formatAsGeneralizedTime(final long date)
throws IllegalArgumentException
{
// Generalized time has the format yyyyMMddHHmmss.SSS'Z'
// Do this in a thread-safe non-synchronized fashion.
// (Simple)DateFormat is neither fast nor thread-safe.
final StringBuilder sb = new StringBuilder(19);
final GregorianCalendar calendar = new GregorianCalendar(TIME_ZONE_UTC_OBJ);
calendar.setLenient(false);
calendar.setTimeInMillis(date);
// Format the year yyyy.
int n = calendar.get(Calendar.YEAR);
if (n < 0)
{
final IllegalArgumentException e = new IllegalArgumentException(
"Year cannot be < 0:" + n);
StaticUtils.DEBUG_LOG.throwing("GeneralizedTimeSyntax", "format", e);
throw e;
}
else if (n < 10)
{
sb.append("000");
}
else if (n < 100)
{
sb.append("00");
}
else if (n < 1000)
{
sb.append("0");
}
sb.append(n);
// Format the month MM.
n = calendar.get(Calendar.MONTH) + 1;
if (n < 10)
{
sb.append("0");
}
sb.append(n);
// Format the day dd.
n = calendar.get(Calendar.DAY_OF_MONTH);
if (n < 10)
{
sb.append("0");
}
sb.append(n);
// Format the hour HH.
n = calendar.get(Calendar.HOUR_OF_DAY);
if (n < 10)
{
sb.append("0");
}
sb.append(n);
// Format the minute mm.
n = calendar.get(Calendar.MINUTE);
if (n < 10)
{
sb.append("0");
}
sb.append(n);
// Format the seconds ss.
n = calendar.get(Calendar.SECOND);
if (n < 10)
{
sb.append("0");
}
sb.append(n);
// Format the milli-seconds.
sb.append('.');
n = calendar.get(Calendar.MILLISECOND);
if (n < 10)
{
sb.append("00");
}
else if (n < 100)
{
sb.append("0");
}
sb.append(n);
// Format the timezone (always Z).
sb.append('Z');
return sb.toString();
}
/**
* Construct a byte array containing the UTF-8 encoding of the provided
* string. This is significantly faster than calling
* {@link String#getBytes(String)} for ASCII strings.
*
* @param s
* The string to convert to a UTF-8 byte array.
* @return Returns a byte array containing the UTF-8 encoding of the provided
* string.
*/
public static byte[] getBytes(final String s)
{
if (s == null)
{
return null;
}
try
{
char c;
final int length = s.length();
final byte[] returnArray = new byte[length];
for (int i = 0; i < length; i++)
{
c = s.charAt(i);
returnArray[i] = (byte) (c & 0x0000007F);
if (c != returnArray[i])
{
return s.getBytes("UTF-8");
}
}
return returnArray;
}
catch (final Exception e)
{
DEBUG_LOG.warning("Unable to encode UTF-8 string " + s);
return s.getBytes();
}
}
/**
* Returns the default scheduler which should be used by the SDK.
*
* @return The default scheduler.
*/
public static ScheduledExecutorService getDefaultScheduler()
{
synchronized (DEFAULT_SCHEDULER_LOCK)
{
if (defaultScheduler == null)
{
final ThreadFactory factory = newThreadFactory(null,
"OpenDS SDK Default Scheduler", true);
defaultScheduler = Executors.newSingleThreadScheduledExecutor(factory);
}
}
return defaultScheduler;
}
/**
* Retrieves the best human-readable message for the provided exception. For
* exceptions defined in the OpenDS project, it will attempt to use the
* message (combining it with the message ID if available). For some
* exceptions that use encapsulation (e.g., InvocationTargetException), it
* will be unwrapped and the cause will be treated. For all others, the
*
* @param t
* The {@code Throwable} object for which to retrieve the message.
* @return The human-readable message generated for the provided exception.
*/
public static LocalizableMessage getExceptionMessage(final Throwable t)
{
if (t instanceof LocalizableException)
{
final LocalizableException ie = (LocalizableException) t;
return ie.getMessageObject();
}
else if (t instanceof NullPointerException)
{
final StackTraceElement[] stackElements = t.getStackTrace();
final LocalizableMessageBuilder message = new LocalizableMessageBuilder();
message.append("NullPointerException(");
message.append(stackElements[0].getFileName());
message.append(":");
message.append(stackElements[0].getLineNumber());
message.append(")");
return message.toMessage();
}
else if (t instanceof InvocationTargetException && t.getCause() != null)
{
return getExceptionMessage(t.getCause());
}
else
{
final StringBuilder message = new StringBuilder();
final String className = t.getClass().getName();
final int periodPos = className.lastIndexOf('.');
if (periodPos > 0)
{
message.append(className.substring(periodPos + 1));
}
else
{
message.append(className);
}
message.append("(");
if (t.getMessage() == null)
{
final StackTraceElement[] stackElements = t.getStackTrace();
message.append(stackElements[0].getFileName());
message.append(":");
message.append(stackElements[0].getLineNumber());
// FIXME Temporary to debug issue 2256.
if (t instanceof IllegalStateException)
{
for (int i = 1; i < stackElements.length; i++)
{
message.append(' ');
message.append(stackElements[i].getFileName());
message.append(":");
message.append(stackElements[i].getLineNumber());
}
}
}
else
{
message.append(t.getMessage());
}
message.append(")");
return LocalizableMessage.raw(message.toString());
}
}
/**
* Converts the provided hexadecimal string to a byte array.
*
* @param hexString
* The hexadecimal string to convert to a byte array.
* @return The byte array containing the binary representation of the provided
* hex string.
* @throws java.text.ParseException
* If the provided string contains invalid hexadecimal digits or
* does not contain an even number of digits.
*/
public static byte[] hexStringToByteArray(final String hexString)
throws ParseException
{
int length;
if (hexString == null || (length = hexString.length()) == 0)
{
return new byte[0];
}
if (length % 2 != 0)
{
final LocalizableMessage message = ERR_HEX_DECODE_INVALID_LENGTH
.get(hexString);
throw new ParseException(message.toString(), 0);
}
final int arrayLength = length / 2;
final byte[] returnArray = new byte[arrayLength];
for (int i = 0; i < arrayLength; i++)
{
returnArray[i] = hexToByte(hexString.charAt(i * 2), hexString
.charAt(i * 2 + 1));
}
return returnArray;
}
/**
* Converts the provided pair of characters to a byte.
*
* @param c1
* The first hexadecimal character.
* @param c2
* The second hexadecimal character.
* @return The byte containing the binary representation of the provided hex
* characters.
* @throws ParseException
* If the provided string contains invalid hexadecimal digits or
* does not contain an even number of digits.
*/
public static byte hexToByte(final char c1, final char c2)
throws ParseException
{
byte b;
switch (c1)
{
case '0':
b = 0x00;
break;
case '1':
b = 0x10;
break;
case '2':
b = 0x20;
break;
case '3':
b = 0x30;
break;
case '4':
b = 0x40;
break;
case '5':
b = 0x50;
break;
case '6':
b = 0x60;
break;
case '7':
b = 0x70;
break;
case '8':
b = (byte) 0x80;
break;
case '9':
b = (byte) 0x90;
break;
case 'A':
case 'a':
b = (byte) 0xA0;
break;
case 'B':
case 'b':
b = (byte) 0xB0;
break;
case 'C':
case 'c':
b = (byte) 0xC0;
break;
case 'D':
case 'd':
b = (byte) 0xD0;
break;
case 'E':
case 'e':
b = (byte) 0xE0;
break;
case 'F':
case 'f':
b = (byte) 0xF0;
break;
default:
final LocalizableMessage message = ERR_HEX_DECODE_INVALID_CHARACTER.get(
new String(new char[] { c1, c2 }), c1);
throw new ParseException(message.toString(), 0);
}
switch (c2)
{
case '0':
// No action required.
break;
case '1':
b |= 0x01;
break;
case '2':
b |= 0x02;
break;
case '3':
b |= 0x03;
break;
case '4':
b |= 0x04;
break;
case '5':
b |= 0x05;
break;
case '6':
b |= 0x06;
break;
case '7':
b |= 0x07;
break;
case '8':
b |= 0x08;
break;
case '9':
b |= 0x09;
break;
case 'A':
case 'a':
b |= 0x0A;
break;
case 'B':
case 'b':
b |= 0x0B;
break;
case 'C':
case 'c':
b |= 0x0C;
break;
case 'D':
case 'd':
b |= 0x0D;
break;
case 'E':
case 'e':
b |= 0x0E;
break;
case 'F':
case 'f':
b |= 0x0F;
break;
default:
final LocalizableMessage message = ERR_HEX_DECODE_INVALID_CHARACTER.get(
new String(new char[] { c1, c2 }), c1);
throw new ParseException(message.toString(), 0);
}
return b;
}
/**
* Indicates whether the provided character is an ASCII alphabetic character.
*
* @param c
* The character for which to make the determination.
* @return true if the provided value is an uppercase or
* lowercase ASCII alphabetic character, or false if it
* is not.
*/
public static boolean isAlpha(final char c)
{
final ASCIICharProp cp = ASCIICharProp.valueOf(c);
return cp != null ? cp.isLetter() : false;
}
/**
* Indicates whether the provided character is a numeric digit.
*
* @param c
* The character for which to make the determination.
* @return true if the provided character represents a numeric
* digit, or false if not.
*/
public static boolean isDigit(final char c)
{
final ASCIICharProp cp = ASCIICharProp.valueOf(c);
return cp != null ? cp.isDigit() : false;
}
/**
* Indicates whether the provided character is a hexadecimal digit.
*
* @param c
* The character for which to make the determination.
* @return true if the provided character represents a
* hexadecimal digit, or false if not.
*/
public static boolean isHexDigit(final char c)
{
final ASCIICharProp cp = ASCIICharProp.valueOf(c);
return cp != null ? cp.isHexDigit() : false;
}
/**
* Returns a string whose content is the string representation of the objects
* contained in the provided collection concatenated together using the
* provided separator.
*
* @param c
* The collection whose elements are to be joined.
* @param separator
* The separator string.
* @return A string whose content is the string representation of the objects
* contained in the provided collection concatenated together using
* the provided separator.
* @throws NullPointerException
* If {@code c} or {@code separator} were {@code null}.
*/
public static String joinCollection(Collection c, String separator)
throws NullPointerException
{
Validator.ensureNotNull(c, separator);
switch (c.size())
{
case 0:
return "";
case 1:
return String.valueOf(c.iterator().next());
default:
StringBuilder builder = new StringBuilder();
Iterator i = c.iterator();
builder.append(i.next());
while (i.hasNext())
{
builder.append(separator);
builder.append(i.next());
}
String s = builder.toString();
return s;
}
}
/**
* Creates a new thread factory which will create threads using the specified
* thread group, naming template, and daemon status.
*
* @param group
* The thread group, which may be {@code null}.
* @param nameTemplate
* The thread name format string which may contain a "%d" format
* option which will be substituted with the thread count.
* @param isDaemon
* Indicates whether or not threads should be daemon threads.
* @return The new thread factory.
*/
public static ThreadFactory newThreadFactory(final ThreadGroup group,
final String nameTemplate, final boolean isDaemon)
{
return new ThreadFactory()
{
private final AtomicInteger count = new AtomicInteger();
public Thread newThread(Runnable r)
{
final String name = String
.format(nameTemplate, count.getAndIncrement());
final Thread t = new Thread(group, r, name);
t.setDaemon(isDaemon);
return t;
}
};
}
/**
* Returns a string representation of the contents of the provided byte
* sequence using hexadecimal characters and a space between each byte.
*
* @param bytes
* The byte sequence.
* @return A string representation of the contents of the provided byte
* sequence using hexadecimal characters.
*/
public static String toHex(final ByteSequence bytes)
{
return toHex(bytes, new StringBuilder((bytes.length() - 1) * 3 + 2))
.toString();
}
/**
* Appends the string representation of the contents of the provided byte
* sequence to a string builder using hexadecimal characters and a space
* between each byte.
*
* @param bytes
* The byte sequence.
* @param builder
* The string builder to which the hexadecimal representation of
* {@code bytes} should be appended.
* @return The string builder.
*/
public static StringBuilder toHex(final ByteSequence bytes,
final StringBuilder builder)
{
final int length = bytes.length();
builder.ensureCapacity(builder.length() + (length - 1) * 3 + 2);
builder.append(StaticUtils.byteToHex(bytes.byteAt(0)));
for (int i = 1; i < length; i++)
{
builder.append(" ");
builder.append(StaticUtils.byteToHex(bytes.byteAt(i)));
}
return builder;
}
/**
* Appends a string representation of the data in the provided byte sequence
* to the given string builder using the specified indent.
*
* The data will be formatted with sixteen hex bytes in a row followed by the
* ASCII representation, then wrapping to a new line as necessary. The state
* of the byte buffer is not changed.
*
* @param bytes
* The byte sequence.
* @param builder
* The string builder to which the information is to be appended.
* @param indent
* The number of spaces to indent the output.
* @return The string builder.
*/
public static StringBuilder toHexPlusAscii(final ByteSequence bytes,
final StringBuilder builder, final int indent)
{
final StringBuilder indentBuf = new StringBuilder(indent);
for (int i = 0; i < indent; i++)
{
indentBuf.append(' ');
}
final int length = bytes.length();
int pos = 0;
while (length - pos >= 16)
{
final StringBuilder asciiBuf = new StringBuilder(17);
byte currentByte = bytes.byteAt(pos);
builder.append(indentBuf);
builder.append(StaticUtils.byteToHex(currentByte));
asciiBuf.append(byteToASCII(currentByte));
pos++;
for (int i = 1; i < 16; i++, pos++)
{
currentByte = bytes.byteAt(pos);
builder.append(' ');
builder.append(StaticUtils.byteToHex(currentByte));
asciiBuf.append(byteToASCII(currentByte));
if (i == 7)
{
builder.append(" ");
asciiBuf.append(' ');
}
}
builder.append(" ");
builder.append(asciiBuf);
builder.append(EOL);
}
final int remaining = length - pos;
if (remaining > 0)
{
final StringBuilder asciiBuf = new StringBuilder(remaining + 1);
byte currentByte = bytes.byteAt(pos);
builder.append(indentBuf);
builder.append(StaticUtils.byteToHex(currentByte));
asciiBuf.append(byteToASCII(currentByte));
pos++;
for (int i = 1; i < 16; i++, pos++)
{
builder.append(' ');
if (i < remaining)
{
currentByte = bytes.byteAt(pos);
builder.append(StaticUtils.byteToHex(currentByte));
asciiBuf.append(byteToASCII(currentByte));
}
else
{
builder.append(" ");
}
if (i == 7)
{
builder.append(" ");
if (i < remaining)
{
asciiBuf.append(' ');
}
}
}
builder.append(" ");
builder.append(asciiBuf);
builder.append(EOL);
}
return builder;
}
/**
* Appends a lowercase string representation of the contents of the given byte
* array to the provided buffer. This implementation presumes that the
* provided string will contain only ASCII characters and is optimized for
* that case. However, if a non-ASCII character is encountered it will fall
* back on a more expensive algorithm that will work properly for non-ASCII
* characters.
*
* @param b
* The byte array for which to obtain the lowercase string
* representation.
* @param builder
* The buffer to which the lowercase form of the string should be
* appended.
* @return The updated {@code StringBuilder}.
*/
public static StringBuilder toLowerCase(final ByteSequence b,
final StringBuilder builder)
{
Validator.ensureNotNull(b, builder);
// FIXME: What locale should we use for non-ASCII characters? I
// think we should use default to the Unicode StringPrep.
final int origBufferLen = builder.length();
final int length = b.length();
for (int i = 0; i < length; i++)
{
final int c = b.byteAt(i);
if (c < 0)
{
builder.replace(origBufferLen, builder.length(), b.toString()
.toLowerCase(Locale.ENGLISH));
return builder;
}
// At this point 0 <= 'c' <= 128.
final ASCIICharProp cp = ASCIICharProp.valueOf(c);
builder.append(cp.toLowerCase());
}
return builder;
}
/**
* Retrieves a lower-case representation of the given string. This
* implementation presumes that the provided string will contain only ASCII
* characters and is optimized for that case. However, if a non-ASCII
* character is encountered it will fall back on a more expensive algorithm
* that will work properly for non-ASCII characters.
*
* @param s
* The string for which to obtain the lower-case representation.
* @return The lower-case representation of the given string.
*/
public static String toLowerCase(final String s)
{
Validator.ensureNotNull(s);
// FIXME: What locale should we use for non-ASCII characters? I
// think we should use default to the Unicode StringPrep.
// This code is optimized for the case where the input string 's'
// has already been converted to lowercase.
final int length = s.length();
int i = 0;
ASCIICharProp cp = null;
// Scan for non lowercase ASCII.
while (i < length)
{
cp = ASCIICharProp.valueOf(s.charAt(i));
if (cp == null || cp.isUpperCase())
{
break;
}
i++;
}
if (i == length)
{
// String was already lowercase ASCII.
return s;
}
// Found non lowercase ASCII.
final StringBuilder builder = new StringBuilder(length);
builder.append(s, 0, i);
if (cp != null)
{
// Upper-case ASCII.
builder.append(cp.toLowerCase());
i++;
while (i < length)
{
cp = ASCIICharProp.valueOf(s.charAt(i));
if (cp == null)
{
break;
}
builder.append(cp.toLowerCase());
i++;
}
}
if (i < length)
{
builder.append(s.substring(i).toLowerCase(Locale.ENGLISH));
}
return builder.toString();
}
/**
* Appends a lower-case representation of the given string to the provided
* buffer. This implementation presumes that the provided string will contain
* only ASCII characters and is optimized for that case. However, if a
* non-ASCII character is encountered it will fall back on a more expensive
* algorithm that will work properly for non-ASCII characters.
*
* @param s
* The string for which to obtain the lower-case representation.
* @param builder
* The {@code StringBuilder} to which the lower-case form of the
* string should be appended.
* @return The updated {@code StringBuilder}.
*/
public static StringBuilder toLowerCase(final String s,
final StringBuilder builder)
{
Validator.ensureNotNull(s, builder);
// FIXME: What locale should we use for non-ASCII characters? I
// think we should use default to the Unicode StringPrep.
final int length = s.length();
builder.ensureCapacity(builder.length() + length);
for (int i = 0; i < length; i++)
{
final ASCIICharProp cp = ASCIICharProp.valueOf(s.charAt(i));
if (cp != null)
{
builder.append(cp.toLowerCase());
}
else
{
// Non-ASCII.
builder.append(s.substring(i).toLowerCase(Locale.ENGLISH));
return builder;
}
}
return builder;
}
/**
* Attempts to uncompress the data in the provided source array into the given
* destination array. If the uncompressed data will fit into the given
* destination array, then this method will return the number of bytes of
* uncompressed data written into the destination buffer. Otherwise, it will
* return a negative value to indicate that the destination buffer was not
* large enough. The absolute value of that negative return value will
* indicate the buffer size required to fully decompress the data. Note that
* if a negative value is returned, then the data in the destination array
* should be considered invalid.
*
* @param src
* The array containing the raw data to compress.
* @param srcOff
* The start offset of the source data.
* @param srcLen
* The maximum number of source data bytes to compress.
* @param dst
* The array into which the compressed data should be written.
* @param dstOff
* The start offset of the compressed data.
* @param dstLen
* The maximum number of bytes of compressed data.
* @return A positive value containing the number of bytes of uncompressed
* data written into the destination buffer, or a negative value whose
* absolute value is the size of the destination buffer required to
* fully decompress the provided data.
* @throws java.util.zip.DataFormatException
* If a problem occurs while attempting to uncompress the data.
*/
public static int uncompress(final byte[] src, final int srcOff,
final int srcLen, final byte[] dst, final int dstOff, final int dstLen)
throws DataFormatException
{
final Inflater inflater = new Inflater();
try
{
inflater.setInput(src, srcOff, srcLen);
final int decompressedLength = inflater.inflate(dst, dstOff, dstLen);
if (inflater.finished())
{
return decompressedLength;
}
else
{
int totalLength = decompressedLength;
while (!inflater.finished())
{
totalLength += inflater.inflate(dst, dstOff, dstLen);
}
return -totalLength;
}
}
finally
{
inflater.end();
}
}
/**
* Attempts to uncompress the data in the provided byte sequence into the
* provided byte string builder. Note that if uncompression was not
* successful, then the data in the destination buffer should be considered
* invalid.
*
* @param input
* The source data to be uncompressed.
* @param output
* The destination buffer to which the uncompressed data will be
* appended.
* @param uncompressedSize
* The uncompressed size of the data if known or 0 otherwise.
* @return true if decompression was successful or
* false otherwise.
* @throws java.util.zip.DataFormatException
* If a problem occurs while attempting to uncompress the data.
*/
public static boolean uncompress(final ByteSequence input,
final ByteStringBuilder output, final int uncompressedSize)
throws DataFormatException
{
final byte[] inputBytes = input.toByteArray();
byte[] outputBytes = new byte[uncompressedSize > 0 ? uncompressedSize : 0];
int decompressResult = uncompress(inputBytes, 0, inputBytes.length,
outputBytes, 0, outputBytes.length);
if (decompressResult < 0)
{
// The destination buffer wasn't big enough. Resize and retry.
outputBytes = new byte[-decompressResult];
decompressResult = uncompress(inputBytes, 0, inputBytes.length,
outputBytes, 0, outputBytes.length);
}
if (decompressResult >= 0)
{
// It was successful.
output.append(outputBytes, 0, decompressResult);
return true;
}
// Still unsuccessful. Give up.
return false;
}
/**
* Retrieves the printable ASCII representation of the provided byte.
*
* @param b
* The byte for which to retrieve the printable ASCII representation.
* @return The printable ASCII representation of the provided byte, or a space
* if the provided byte does not have printable ASCII representation.
*/
private static char byteToASCII(final byte b)
{
if (b >= 32 && b <= 126)
{
return (char) b;
}
return ' ';
}
// Prevent instantiation.
private StaticUtils()
{
// No implementation required.
}
}