001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017: package org.apache.commons.io;
018:
019: import java.io.IOException;
020: import java.io.OutputStream;
021:
022: /**
023: * Dumps data in hexadecimal format.
024: * <p>
025: * Provides a single function to take an array of bytes and display it
026: * in hexadecimal form.
027: * <p>
028: * Origin of code: POI.
029: *
030: * @author Scott Sanders
031: * @author Marc Johnson
032: * @version $Id: HexDump.java 437680 2006-08-28 11:57:00Z scolebourne $
033: */
034: public class HexDump {
035:
036: /**
037: * Instances should NOT be constructed in standard programming.
038: */
039: public HexDump() {
040: super ();
041: }
042:
043: /**
044: * Dump an array of bytes to an OutputStream.
045: *
046: * @param data the byte array to be dumped
047: * @param offset its offset, whatever that might mean
048: * @param stream the OutputStream to which the data is to be
049: * written
050: * @param index initial index into the byte array
051: *
052: * @throws IOException is thrown if anything goes wrong writing
053: * the data to stream
054: * @throws ArrayIndexOutOfBoundsException if the index is
055: * outside the data array's bounds
056: * @throws IllegalArgumentException if the output stream is null
057: */
058:
059: public static void dump(byte[] data, long offset,
060: OutputStream stream, int index) throws IOException,
061: ArrayIndexOutOfBoundsException, IllegalArgumentException {
062:
063: if ((index < 0) || (index >= data.length)) {
064: throw new ArrayIndexOutOfBoundsException("illegal index: "
065: + index + " into array of length " + data.length);
066: }
067: if (stream == null) {
068: throw new IllegalArgumentException(
069: "cannot write to nullstream");
070: }
071: long display_offset = offset + index;
072: StringBuffer buffer = new StringBuffer(74);
073:
074: for (int j = index; j < data.length; j += 16) {
075: int chars_read = data.length - j;
076:
077: if (chars_read > 16) {
078: chars_read = 16;
079: }
080: buffer.append(dump(display_offset)).append(' ');
081: for (int k = 0; k < 16; k++) {
082: if (k < chars_read) {
083: buffer.append(dump(data[k + j]));
084: } else {
085: buffer.append(" ");
086: }
087: buffer.append(' ');
088: }
089: for (int k = 0; k < chars_read; k++) {
090: if ((data[k + j] >= ' ') && (data[k + j] < 127)) {
091: buffer.append((char) data[k + j]);
092: } else {
093: buffer.append('.');
094: }
095: }
096: buffer.append(EOL);
097: stream.write(buffer.toString().getBytes());
098: stream.flush();
099: buffer.setLength(0);
100: display_offset += chars_read;
101: }
102: }
103:
104: /**
105: * The line-separator (initializes to "line.separator" system property.
106: */
107: public static final String EOL = System
108: .getProperty("line.separator");
109: private static final StringBuffer _lbuffer = new StringBuffer(8);
110: private static final StringBuffer _cbuffer = new StringBuffer(2);
111: private static final char[] _hexcodes = { '0', '1', '2', '3', '4',
112: '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
113: private static final int[] _shifts = { 28, 24, 20, 16, 12, 8, 4, 0 };
114:
115: /**
116: * Dump a long value into a StringBuffer.
117: *
118: * @param value the long value to be dumped
119: * @return StringBuffer containing the dumped value.
120: */
121: private static StringBuffer dump(long value) {
122: _lbuffer.setLength(0);
123: for (int j = 0; j < 8; j++) {
124: _lbuffer
125: .append(_hexcodes[((int) (value >> _shifts[j])) & 15]);
126: }
127: return _lbuffer;
128: }
129:
130: /**
131: * Dump a byte value into a StringBuffer.
132: *
133: * @param value the byte value to be dumped
134: * @return StringBuffer containing the dumped value.
135: */
136: private static StringBuffer dump(byte value) {
137: _cbuffer.setLength(0);
138: for (int j = 0; j < 2; j++) {
139: _cbuffer.append(_hexcodes[(value >> _shifts[j + 6]) & 15]);
140: }
141: return _cbuffer;
142: }
143:
144: }
|