FileDocCategorySizeDatePackage
TwoColumnOutput.javaAPI DocAndroid 1.5 API7976Wed May 06 22:41:02 BST 2009com.android.dx.util

TwoColumnOutput

public final class TwoColumnOutput extends Object
Class that takes a combined output destination and provides two output writers, one of which ends up writing to the left column and one which goes on the right.

Fields Summary
private final Writer
out
non-null; underlying writer for final output
private final int
leftWidth
> 0; the left column width
private final StringBuffer
leftBuf
non-null; pending left column output
private final StringBuffer
rightBuf
non-null; pending right column output
private final IndentingWriter
leftColumn
non-null; left column writer
private final IndentingWriter
rightColumn
non-null; right column writer
Constructors Summary
public TwoColumnOutput(Writer out, int leftWidth, int rightWidth, String spacer)
Constructs an instance.

param
out non-null; writer to send final output to
param
leftWidth > 0; width of the left column, in characters
param
rightWidth > 0; width of the right column, in characters
param
spacer non-null; spacer string to sit between the two columns

        if (out == null) {
            throw new NullPointerException("out == null");
        }

        if (leftWidth < 1) {
            throw new IllegalArgumentException("leftWidth < 1");
        }

        if (rightWidth < 1) {
            throw new IllegalArgumentException("rightWidth < 1");
        }

        if (spacer == null) {
            throw new NullPointerException("spacer == null");
        }

        StringWriter leftWriter = new StringWriter(1000);
        StringWriter rightWriter = new StringWriter(1000);

        this.out = out;
        this.leftWidth = leftWidth;
        this.leftBuf = leftWriter.getBuffer();
        this.rightBuf = rightWriter.getBuffer();
        this.leftColumn = new IndentingWriter(leftWriter, leftWidth);
        this.rightColumn =
            new IndentingWriter(rightWriter, rightWidth, spacer);
public TwoColumnOutput(OutputStream out, int leftWidth, int rightWidth, String spacer)
Constructs an instance.

param
out non-null; stream to send final output to
param
leftWidth >= 1; width of the left column, in characters
param
rightWidth >= 1; width of the right column, in characters
param
spacer non-null; spacer string to sit between the two columns

        this(new OutputStreamWriter(out), leftWidth, rightWidth, spacer);
Methods Summary
private static voidappendNewlineIfNecessary(java.lang.StringBuffer buf, java.io.Writer out)
Appends a newline to the given buffer via the given writer, but only if it isn't empty and doesn't already end with one.

param
buf non-null; the buffer in question
param
out non-null; the writer to use

        int len = buf.length();

        if ((len != 0) && (buf.charAt(len - 1) != '\n")) {
            out.write('\n");
        }
public voidflush()
Flushes the output. If there are more lines of pending output in one column, then the other column will get filled with blank lines.

        try {
            appendNewlineIfNecessary(leftBuf, leftColumn);
            appendNewlineIfNecessary(rightBuf, rightColumn);
            outputFullLines();
            flushLeft();
            flushRight();
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
private voidflushLeft()
Flushes the left column buffer, printing it and clearing the buffer. If the buffer is already empty, this does nothing.

        appendNewlineIfNecessary(leftBuf, leftColumn);

        while (leftBuf.length() != 0) {
            rightColumn.write('\n");
            outputFullLines();
        }
private voidflushRight()
Flushes the right column buffer, printing it and clearing the buffer. If the buffer is already empty, this does nothing.

        appendNewlineIfNecessary(rightBuf, rightColumn);

        while (rightBuf.length() != 0) {
            leftColumn.write('\n");
            outputFullLines();
        }
public java.io.WritergetLeft()
Gets the writer to use to write to the left column.

return
non-null; the left column writer

        return leftColumn;
public java.io.WritergetRight()
Gets the writer to use to write to the right column.

return
non-null; the right column writer

        return rightColumn;
private voidoutputFullLines()
Outputs to the final destination as many full line pairs as there are in the pending output, removing those lines from their respective buffers. This method terminates when at least one of the two column buffers is empty.

        for (;;) {
            int leftLen = leftBuf.indexOf("\n");
            if (leftLen < 0) {
                return;
            }

            int rightLen = rightBuf.indexOf("\n");
            if (rightLen < 0) {
                return;
            }

            if (leftLen != 0) {
                out.write(leftBuf.substring(0, leftLen));
            }

            if (rightLen != 0) {
                writeSpaces(out, leftWidth - leftLen);
                out.write(rightBuf.substring(0, rightLen));
            }

            out.write('\n");

            leftBuf.delete(0, leftLen + 1);
            rightBuf.delete(0, rightLen + 1);
        }
public static java.lang.StringtoString(java.lang.String s1, int width1, java.lang.String spacer, java.lang.String s2, int width2)
Turns the given two strings (with widths) and spacer into a formatted two-column string.

param
s1 non-null; first string
param
width1 > 0; width of the first column
param
spacer non-null; spacer string
param
s2 non-null; second string
param
width2 > 0; width of the second column
return
non-null; an appropriately-formatted string

        int len1 = s1.length();
        int len2 = s2.length();

        StringWriter sw = new StringWriter((len1 + len2) * 3);
        TwoColumnOutput twoOut =
            new TwoColumnOutput(sw, width1, width2, spacer);

        try {
            twoOut.getLeft().write(s1);
            twoOut.getRight().write(s2);
        } catch (IOException ex) {
            throw new RuntimeException("shouldn't happen", ex);
        }

        twoOut.flush();
        return sw.toString();
private static voidwriteSpaces(java.io.Writer out, int amt)
Writes the given number of spaces to the given writer.

param
out non-null; where to write
param
amt >= 0; the number of spaces to write

        while (amt > 0) {
            out.write(' ");
            amt--;
        }