`hexdump -C', which is
*
* OFFSET SIXTEEN-BYTES-IN-HEX PRINTABLE-BYTES* *
The printable bytes show up as-is if they are printable and
* not a newline character, otherwise showing as '.'.
*
* @param buf The bytes to format.
* @param off The offset to start at.
* @param len The number of bytes to encode.
* @param prefix A string to prepend to every line.
* @return The formatted string.
*/
public static String hexDump(byte[] buf, int off, int len, String prefix)
{
String nl = getProperty("line.separator");
CPStringBuilder str = new CPStringBuilder();
int i = 0;
while (i < len)
{
if (prefix != null)
str.append(prefix);
str.append(Util.formatInt(i+off, 16, 8));
str.append(" ");
String s = Util.toHexString(buf, i+off, Math.min(16, len-i), ' ');
str.append(s);
for (int j = s.length(); j < 49; j++)
str.append(" ");
for (int j = 0; j < Math.min(16, len - i); j++)
{
if ((buf[i+off+j] & 0xFF) < 0x20 || (buf[i+off+j] & 0xFF) > 0x7E)
str.append('.');
else
str.append((char) (buf[i+off+j] & 0xFF));
}
str.append(nl);
i += 16;
}
return str.toString();
}
public static String hexDump (ByteBuffer buf)
{
return hexDump (buf, null);
}
public static String hexDump (ByteBuffer buf, String prefix)
{
buf = buf.duplicate();
StringWriter str = new StringWriter ();
PrintWriter out = new PrintWriter (str);
int i = 0;
int len = buf.remaining();
byte[] line = new byte[16];
while (i < len)
{
if (prefix != null)
out.print(prefix);
out.print(Util.formatInt (i, 16, 8));
out.print(" ");
int l = Math.min(16, len - i);
buf.get(line, 0, l);
String s = Util.toHexString(line, 0, l, ' ');
out.print(s);
for (int j = s.length(); j < 49; j++)
out.print(' ');
for (int j = 0; j < l; j++)
{
int c = line[j] & 0xFF;
if (c < 0x20 || c > 0x7E)
out.print('.');
else
out.print((char) c);
}
out.println();
i += 16;
}
return str.toString();
}
/**
* See {@link #hexDump(byte[],int,int,String)}.
*/
public static String hexDump(byte[] buf, int off, int len)
{
return hexDump(buf, off, len, "");
}
/**
* See {@link #hexDump(byte[],int,int,String)}.
*/
public static String hexDump(byte[] buf, String prefix)
{
return hexDump(buf, 0, buf.length, prefix);
}
/**
* See {@link #hexDump(byte[],int,int,String)}.
*/
public static String hexDump(byte[] buf)
{
return hexDump(buf, 0, buf.length);
}
/**
* Format an integer into the specified radix, zero-filled.
*
* @param i The integer to format.
* @param radix The radix to encode to.
* @param len The target length of the string. The string is
* zero-padded to this length, but may be longer.
* @return The formatted integer.
*/
public static String formatInt(int i, int radix, int len)
{
String s = Integer.toString(i, radix);
CPStringBuilder buf = new CPStringBuilder();
for (int j = 0; j < len - s.length(); j++)
buf.append("0");
buf.append(s);
return buf.toString();
}
/**
* Concatenate two byte arrays into one.
*
* @param b1 The first byte array.
* @param b2 The second byte array.
* @return The concatenation of b1 and b2.
*/
public static byte[] concat(byte[] b1, byte[] b2)
{
byte[] b3 = new byte[b1.length+b2.length];
System.arraycopy(b1, 0, b3, 0, b1.length);
System.arraycopy(b2, 0, b3, b1.length, b2.length);
return b3;
}
/**
* See {@link #trim(byte[],int,int)}.
*/
public static byte[] trim(byte[] buffer, int len)
{
return trim(buffer, 0, len);
}
/**
* Returns a portion of a byte array, possibly zero-filled.
*
* @param buffer The byte array to trim.
* @param off The offset to begin reading at.
* @param len The number of bytes to return. This value can be larger
* than buffer.length - off, in which case the rest of the
* returned byte array will be filled with zeros.
* @throws IndexOutOfBoundsException If off or len is
* negative, or if off is larger than the byte array's
* length.
* @return The trimmed byte array.
*/
public static byte[] trim(byte[] buffer, int off, int len)
{
if (off < 0 || len < 0 || off > buffer.length)
throw new IndexOutOfBoundsException("max=" + buffer.length +
" off=" + off + " len=" + len);
if (off == 0 && len == buffer.length)
return buffer;
byte[] b = new byte[len];
System.arraycopy(buffer, off, b, 0, Math.min(len, buffer.length - off));
return b;
}
/**
* Returns the byte array representation of the given big integer with
* the leading zero byte (if any) trimmed off.
*
* @param bi The integer to trim.
* @return The byte representation of the big integer, with any leading
* zero removed.
*/
public static byte[] trim(BigInteger bi)
{
byte[] buf = bi.toByteArray();
if (buf[0] == 0x00 && !bi.equals(BigInteger.ZERO))
{
return trim(buf, 1, buf.length - 1);
}
else
{
return buf;
}
}
/**
* Returns the integer value of {@link
* java.lang.System#currentTimeMillis()} / 1000.
*
* @return The current time, in seconds.
*/
public static int unixTime()
{
return (int) (System.currentTimeMillis() / 1000L);
}
/**
* Transform an Object array into another by calling the given method
* on each object. The returned object array will have the runtime
* type of returnType. For example, the following will transform
* array of objects into their String representations, returning a String
* array. For example:
*
*
* *
* String[] strings = (String[]) Util.transform(array, String.class, * "toString", null); *
If any element of the given array is null, then that * entry in the returned array will also be null. * * @param array The array to transform. It does not need to be of * uniform type. * @param returnType The desired return type of the returned array. * This must by the component type, not the array type. * @param method The name of the method to invoke from each object. * @param args The arguments to pass to the method, or null * if the method takes no arguments. * @throws InvocationTargetException If an exception occurs while * calling method of any object. * @throws NoSuchMethodException If method is not the name of * a valid method of any component of the array. * @throws ClassCastException If the returned object from the method * is not assignable to the return type. * @throws IllegalArgumentException If args is not appropriate * for method * @throws IllegalAccessException If method is not accessible. * @throws SecurityException If method is not accessible. * @return An array containing the output of method called on * each element of array with args. The return type * of the array will be an array of returnType. */ static Object[] transform(Object[] array, Class returnType, String method, Object[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException { if (args == null) args = new Object[0]; Object[] result = (Object[]) Array.newInstance(returnType, array.length); Class[] argsClasses = new Class[args.length]; for (int i = 0; i < args.length; i++) { argsClasses[i] = args[i].getClass(); } for (int i = 0; i < array.length; i++) { if (array[i] == null) { result[i] = null; continue; } Class objClass = array[i].getClass(); Method objMethod = objClass.getMethod(method, argsClasses); Object o = objMethod.invoke(array[i], args); if (!returnType.isAssignableFrom(o.getClass())) throw new ClassCastException(); result[i] = o; } return result; } /** * Get a system property as a privileged action. * * @param name The name of the property to get. * @return The property named name, or null if the property is * not set. * @throws SecurityException If the Jessie code still does not have * permission to read the property. */ @Deprecated static String getProperty(final String name) { return (String) AccessController.doPrivileged( new PrivilegedAction() { public Object run() { return System.getProperty(name); } } ); } /** * Get a security property as a privileged action. * * @param name The name of the property to get. * @return The property named name, or null if the property is * not set. * @throws SecurityException If the Jessie code still does not have * permission to read the property. */ @Deprecated static String getSecurityProperty(final String name) { return (String) AccessController.doPrivileged( new PrivilegedAction() { public Object run() { return Security.getProperty(name); } } ); } }