com.tangosol.io.DebugDataOutputStream Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.io;
import com.tangosol.util.Base;
import java.io.DataOutput;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* This is an imitation DataOutputStream class that logs the output in a
* human-readable format for debugging purposes. All output will be
*
* @author cp 2004.08.06
*/
public class DebugDataOutputStream
extends FilterOutputStream
implements DataOutput, OutputStreaming
{
// ----- constructors ---------------------------------------------------
/**
* Construct a DebugDataOutputStream that will output to the specified
* Stream object.
*
* @param stream an OutputStream to write to
*/
public DebugDataOutputStream(OutputStream stream)
{
super(stream);
try
{
println("::DebugDataOutputStream()");
}
catch (IOException e)
{
throw Base.ensureRuntimeException(e);
}
}
// ----- DataOutput methods ---------------------------------------------
/**
* Writes the eight low-order bits of the argument b. The 24
* high-order bits of b are ignored.
*
* @param b the byte to write (passed as an integer)
*
* @exception IOException if an I/O error occurs
*/
public void write(int b)
throws IOException
{
writeByte(b);
}
/**
* Writes all the bytes in the array ab.
*
* @param ab the byte array to write
*
* @exception IOException if an I/O error occurs
* @exception NullPointerException if ab is
* null
*/
public void write(byte ab[])
throws IOException
{
write(ab, 0, ab.length);
}
/**
* Writes cb bytes starting at offset of from
* the array ab.
*
* @param ab the byte array to write from
* @param of the offset into ab to start writing from
* @param cb the number of bytes from ab to write
*
* @exception IOException if an I/O error occurs
* @exception NullPointerException if ab is
* null
* @exception IndexOutOfBoundsException if of is negative,
* or cb is negative, or of+cb is
* greater than ab.length
*/
public void write(byte ab[], int of, int cb)
throws IOException
{
if (cb < 0)
{
throw new IndexOutOfBoundsException();
}
int cch = cb * 2;
char[] ach = new char[cch];
for (int ofch = 0; ofch < cch; ++of)
{
int n = ab[of] & 0xFF;
ach[ofch++] = HEX[n >>> 4];
ach[ofch++] = HEX[n & 0x0F];
}
println("byte[] 0x" + new String(ach));
}
/**
* Writes the boolean value f.
*
* @param f the boolean to be written
*
* @exception IOException if an I/O error occurs
*/
public void writeBoolean(boolean f)
throws IOException
{
println("boolean " + String.valueOf(f));
}
/**
* Writes the eight low-order bits of the argument b. The 24
* high-order bits of b are ignored.
*
* @param b the byte to write (passed as an integer)
*
* @exception IOException if an I/O error occurs
*/
public void writeByte(int b)
throws IOException
{
int n = b & 0xFF;
println("byte 0x" + HEX[n >>> 4] + HEX[n & 0x0F]);
}
/**
* Writes a short value, comprised of the 16 low-order bits of the
* argument n; the 16 high-order bits of n are
* ignored.
*
* @param n the short to write (passed as an integer)
*
* @exception IOException if an I/O error occurs
*/
public void writeShort(int n)
throws IOException
{
println("short " + String.valueOf(n));
}
/**
* Writes a char value, comprised of the 16 low-order bits of the
* argument ch; the 16 high-order bits of ch are
* ignored.
*
* @param ch the char to write (passed as an integer)
*
* @exception IOException if an I/O error occurs
*/
public void writeChar(int ch)
throws IOException
{
println("char \'" + String.valueOf(ch) + '\'');
}
/**
* Writes an int value.
*
* @param n the int to write
*
* @exception IOException if an I/O error occurs
*/
public void writeInt(int n)
throws IOException
{
println("int " + String.valueOf(n));
}
/**
* Writes a long value.
*
* @param l the long to write
*
* @exception IOException if an I/O error occurs
*/
public void writeLong(long l)
throws IOException
{
println("long " + String.valueOf(l));
}
/**
* Writes a float value.
*
* @param fl the float to write
*
* @exception IOException if an I/O error occurs
*/
public void writeFloat(float fl)
throws IOException
{
println("float " + String.valueOf(fl));
}
/**
* Writes a double value.
*
* @param dfl the double to write
*
* @exception IOException if an I/O error occurs
*/
public void writeDouble(double dfl)
throws IOException
{
println("double " + String.valueOf(dfl));
}
/**
* Writes the String s, but only the low-order byte from each
* character of the String is written.
*
* @param s the String to write
*
* @exception IOException if an I/O error occurs
* @exception NullPointerException if s is null
*/
public void writeBytes(String s)
throws IOException
{
println("String as byte[] \"" + s + '\"');
}
/**
* Writes the String s as a sequence of characters.
*
* @param s the String to write
*
* @exception IOException if an I/O error occurs
* @exception NullPointerException if s is null
*/
public void writeChars(String s)
throws IOException
{
println("String as char[] \"" + s + '\"');
}
/**
* Writes the String s as a sequence of characters, but using
* UTF-8 encoding for the characters, and including the String length data
* so that the corresponding {@link java.io.DataInput#readUTF} method can
* reconstitute a String from the written data.
*
* @param s the String to write
*
* @exception IOException if an I/O error occurs
* @exception NullPointerException if s is null
*/
public void writeUTF(String s)
throws IOException
{
println("String as UTF \"" + s + '\"');
}
// ----- OutputStream methods -------------------------------------------
/**
* Flushes this OutputStream and forces any buffered output bytes to be
* written.
*
* @exception IOException if an I/O error occurs
*/
public void flush()
throws IOException
{
println("::flush()");
out.flush();
}
/**
* Closes this OutputStream and releases any associated system resources.
*
* @exception IOException if an I/O error occurs
*/
public void close()
throws IOException
{
println("::close()");
try
{
out.flush();
}
catch (IOException eIgnore) {}
out.close();
}
// ----- internal -------------------------------------------------------
/**
* Hex digits.
*/
private static final char[] HEX = "0123456789ABCDEF".toCharArray();
/**
* Print the passed String to the underlying stream.
*
* @param s the String to print
*/
protected void println(String s)
throws IOException
{
OutputStream out = this.out;
// print out character by character, escaping anything outside of the
// visible ASCII range
char[] ach = s.toCharArray();
for (int of = 0, cch = ach.length; of < cch; ++of)
{
char ch = ach[of];
switch (ch)
{
case '\b':
out.write('\\');
out.write('b');
break;
case '\t':
out.write('\\');
out.write('t');
break;
case '\n':
out.write('\\');
out.write('n');
break;
case '\f':
out.write('\\');
out.write('f');
break;
case '\r':
out.write('\\');
out.write('r');
break;
case '\\':
out.write('\\');
out.write('\\');
break;
case 0x00: case 0x01: case 0x02: case 0x03:
case 0x04: case 0x05: case 0x06: case 0x07:
case 0x0B:
case 0x0E: case 0x0F:
case 0x10: case 0x11: case 0x12: case 0x13:
case 0x14: case 0x15: case 0x16: case 0x17:
case 0x18: case 0x19: case 0x1A: case 0x1B:
case 0x1C: case 0x1D: case 0x1E: case 0x1F:
out.write('\\');
out.write('0');
out.write((char)(ch / 8 + '0'));
out.write((char)(ch % 8 + '0'));
break;
default:
switch (Character.getType(ch))
{
default:
if (ch <= 0xFF)
{
out.write(ch);
break;
}
// fall through
case Character.CONTROL:
case Character.PRIVATE_USE:
case Character.UNASSIGNED:
{
int n = ch;
out.write('\\');
out.write('u');
out.write(HEX[n >> 12 ]);
out.write(HEX[n >> 8 & 0x0F]);
out.write(HEX[n >> 4 & 0x0F]);
out.write(HEX[n & 0x0F]);
}
break;
}
break;
}
}
// new line
out.write('\n');
}
/**
* Command line test.
*/
public static void main(String[] asArg)
throws Exception
{
DebugDataOutputStream stream = new DebugDataOutputStream(System.out);
for (int i = 0; i <= 0xFF; i += 64)
{
stream.write(i);
stream.writeChar((char) i);
stream.writeShort((short) (i * i));
stream.writeInt(i * i);
stream.writeLong(i * i);
stream.writeFloat(1.0F / i);
stream.writeDouble(1.0 / i);
}
String s = "start-test \07\r\n\b\t\\\uFEFF end-test";
stream.writeBytes(s);
stream.writeChars(s);
stream.writeUTF(s);
}
}