FileDocCategorySizeDatePackage
HexDump.javaAPI DocApache Poi 3.0.112947Mon Jan 01 12:39:42 GMT 2007org.apache.poi.util

HexDump

public class HexDump extends Object
dump data in hexadecimal format; derived from a HexDump utility I wrote in June 2001.
author
Marc Johnson
author
Glen Stampoultzis (glens at apache.org)

Fields Summary
public static final String
EOL
private static final char[]
_hexcodes
private static final int[]
_shifts
Constructors Summary
private HexDump()



    // all static methods, so no need for a public constructor
Methods Summary
public static voiddump(java.io.InputStream in, java.io.PrintStream out, int start, int bytesToDump)
Dumps bytesToDump bytes to an output stream.

param
in The stream to read from
param
out The output stream
param
start The index to use as the starting position for the left hand side label
param
bytesToDump The number of bytes to output. Use -1 to read until the end of file.

        ByteArrayOutputStream buf = new ByteArrayOutputStream();
        if (bytesToDump == -1)
        {
            int c = in.read();
            while (c != -1)
            {
                buf.write(c);
                c = in.read();
            }
        }
        else
        {
            int bytesRemaining = bytesToDump;
            while (bytesRemaining-- > 0)
            {
                int c = in.read();
                if (c == -1)
                    break;
                else
                    buf.write(c);
            }
        }

        byte[] data = buf.toByteArray();
        dump(data, 0, out, start, data.length);
public static synchronized voiddump(byte[] data, long offset, java.io.OutputStream stream, int index, int length)
dump an array of bytes to an OutputStream

param
data the byte array to be dumped
param
offset its offset, whatever that might mean
param
stream the OutputStream to which the data is to be written
param
index initial index into the byte array
param
length number of characters to output
exception
IOException is thrown if anything goes wrong writing the data to stream
exception
ArrayIndexOutOfBoundsException if the index is outside the data array's bounds
exception
IllegalArgumentException if the output stream is null

        if (data.length == 0)
        {
            stream.write( ("No Data" + System.getProperty( "line.separator")).getBytes() );
            stream.flush();
            return;
        }
        if ((index < 0) || (index >= data.length))
        {
            throw new ArrayIndexOutOfBoundsException(
                "illegal index: " + index + " into array of length "
                + data.length);
        }
        if (stream == null)
        {
            throw new IllegalArgumentException("cannot write to nullstream");
        }

        long         display_offset = offset + index;
        StringBuffer buffer         = new StringBuffer(74);


        int data_length = Math.min(data.length,index+length);
        for (int j = index; j < data_length; j += 16)
        {
            int chars_read = data_length - j;

            if (chars_read > 16)
            {
                chars_read = 16;
            }
            buffer.append(
                        dump(display_offset)
                         ).append(' ");
            for (int k = 0; k < 16; k++)
            {
                if (k < chars_read)
                {
                    buffer.append(dump(data[ k + j ]));
                }
                else
                {
                    buffer.append("  ");
                }
                buffer.append(' ");
            }
            for (int k = 0; k < chars_read; k++)
            {
                if ((data[ k + j ] >= ' ") && (data[ k + j ] < 127))
                {
                    buffer.append(( char ) data[ k + j ]);
                }
                else
                {
                    buffer.append('.");
                }
            }
            buffer.append(EOL);
            stream.write(buffer.toString().getBytes());
            stream.flush();
            buffer.setLength(0);
            display_offset += chars_read;
        }
public static synchronized voiddump(byte[] data, long offset, java.io.OutputStream stream, int index)
dump an array of bytes to an OutputStream

param
data the byte array to be dumped
param
offset its offset, whatever that might mean
param
stream the OutputStream to which the data is to be written
param
index initial index into the byte array
exception
IOException is thrown if anything goes wrong writing the data to stream
exception
ArrayIndexOutOfBoundsException if the index is outside the data array's bounds
exception
IllegalArgumentException if the output stream is null

        dump(data, offset, stream, index, data.length-index);
public static java.lang.Stringdump(byte[] data, long offset, int index)
dump an array of bytes to a String

param
data the byte array to be dumped
param
offset its offset, whatever that might mean
param
index initial index into the byte array
exception
ArrayIndexOutOfBoundsException if the index is outside the data array's bounds
return
output string

        StringBuffer buffer;
        if ((index < 0) || (index >= data.length))
        {
            throw new ArrayIndexOutOfBoundsException(
                "illegal index: " + index + " into array of length "
                + data.length);
        }
        long         display_offset = offset + index;
        buffer         = new StringBuffer(74);

        for (int j = index; j < data.length; j += 16)
        {
            int chars_read = data.length - j;

            if (chars_read > 16)
            {
                chars_read = 16;
            }
            buffer.append(dump(display_offset)).append(' ");
            for (int k = 0; k < 16; k++)
            {
                if (k < chars_read)
                {
                    buffer.append(dump(data[ k + j ]));
                }
                else
                {
                    buffer.append("  ");
                }
                buffer.append(' ");
            }
            for (int k = 0; k < chars_read; k++)
            {
                if ((data[ k + j ] >= ' ") && (data[ k + j ] < 127))
                {
                    buffer.append(( char ) data[ k + j ]);
                }
                else
                {
                    buffer.append('.");
                }
            }
            buffer.append(EOL);
            display_offset += chars_read;
        }                 
        return buffer.toString();
private static java.lang.Stringdump(long value)

        StringBuffer buf = new StringBuffer();
        buf.setLength(0);
        for (int j = 0; j < 8; j++)
        {
            buf.append( _hexcodes[ (( int ) (value >> _shifts[ j + _shifts.length - 8 ])) & 15 ]);
        }
        return buf.toString();
private static java.lang.Stringdump(byte value)

        StringBuffer buf = new StringBuffer();
        buf.setLength(0);
        for (int j = 0; j < 2; j++)
        {
            buf.append(_hexcodes[ (value >> _shifts[ j + 6 ]) & 15 ]);
        }
        return buf.toString();
public static voidmain(java.lang.String[] args)

        File file = new File(args[0]);
        InputStream in = new BufferedInputStream(new FileInputStream(file)); 
        byte[] b = new byte[(int)file.length()];
        in.read(b);
        System.out.println(HexDump.dump(b, 0, 0));
        in.close();
public static java.lang.StringtoHex(byte value)
Converts the parameter to a hex value.

param
value The value to convert
return
The result right padded with 0

        return toHex(value, 2);
public static java.lang.StringtoHex(int value)
Converts the parameter to a hex value.

param
value The value to convert
return
The result right padded with 0

        return toHex(value, 8);
public static java.lang.StringtoHex(long value)
Converts the parameter to a hex value.

param
value The value to convert
return
The result right padded with 0

        return toHex(value, 16);
private static java.lang.StringtoHex(long value, int digits)

        StringBuffer result = new StringBuffer(digits);
        for (int j = 0; j < digits; j++)
        {
            result.append( _hexcodes[ (int) ((value >> _shifts[ j + (16 - digits) ]) & 15)]);
        }
        return result.toString();
public static java.lang.StringtoHex(byte[] value)
Converts the parameter to a hex value.

param
value The value to convert
return
A String representing the array of bytes

        StringBuffer retVal = new StringBuffer();
        retVal.append('[");
        for(int x = 0; x < value.length; x++)
        {
            retVal.append(toHex(value[x]));
            retVal.append(", ");
        }
        retVal.append(']");
        return retVal.toString();
public static java.lang.StringtoHex(byte[] value, int bytesPerLine)

Converts the parameter to a hex value breaking the results into lines.

param
value The value to convert
param
bytesPerLine The maximum number of bytes per line. The next byte will be written to a new line
return
A String representing the array of bytes

        final int digits =
            (int) Math.round(Math.log(value.length) / Math.log(10) + 0.5);
        final StringBuffer formatString = new StringBuffer();
        for (int i = 0; i < digits; i++)
            formatString.append('0");
        formatString.append(": ");
        final DecimalFormat format = new DecimalFormat(formatString.toString());
        StringBuffer retVal = new StringBuffer();
        retVal.append(format.format(0));
        int i = -1;
        for(int x = 0; x < value.length; x++)
        {
            if (++i == bytesPerLine)
            {
                retVal.append('\n");
                retVal.append(format.format(x));
                i = 0;
            }
            retVal.append(toHex(value[x]));
            retVal.append(", ");
        }
        return retVal.toString();
public static java.lang.StringtoHex(short value)
Converts the parameter to a hex value.

param
value The value to convert
return
The result right padded with 0

        return toHex(value, 4);