dexgen/src/com/android/dexgen/util/TwoColumnOutput.java - platform/dalvik - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dexgen.util;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.OutputStreamWriter;
 import java.io.StringWriter;
 import java.io.Writer;

 /**
  * 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.
  */
 public final class TwoColumnOutput {
     /** {@code non-null;} underlying writer for final output */
     private final Writer out;

     /** {@code > 0;} the left column width */
     private final int leftWidth;

     /** {@code non-null;} pending left column output */
     private final StringBuffer leftBuf;

     /** {@code non-null;} pending right column output */
     private final StringBuffer rightBuf;

     /** {@code non-null;} left column writer */
     private final IndentingWriter leftColumn;

     /** {@code non-null;} right column writer */
     private final IndentingWriter rightColumn;

     /**
      * Turns the given two strings (with widths) and spacer into a formatted
      * two-column string.
      *
      * @param s1 {@code non-null;} first string
      * @param width1 {@code > 0;} width of the first column
      * @param spacer {@code non-null;} spacer string
      * @param s2 {@code non-null;} second string
      * @param width2 {@code > 0;} width of the second column
      * @return {@code non-null;} an appropriately-formatted string
      */
     public static String toString(String s1, int width1, String spacer,
                                   String s2, int width2) {
         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();
     }

     /**
      * Constructs an instance.
      *
      * @param out {@code non-null;} writer to send final output to
      * @param leftWidth {@code > 0;} width of the left column, in characters
      * @param rightWidth {@code > 0;} width of the right column, in characters
      * @param spacer {@code non-null;} spacer string to sit between the two columns
      */
     public TwoColumnOutput(Writer out, int leftWidth, int rightWidth,
                            String spacer) {
         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);
     }

     /**
      * Constructs an instance.
      *
      * @param out {@code non-null;} stream to send final output to
      * @param leftWidth {@code >= 1;} width of the left column, in characters
      * @param rightWidth {@code >= 1;} width of the right column, in characters
      * @param spacer {@code non-null;} spacer string to sit between the two columns
      */
     public TwoColumnOutput(OutputStream out, int leftWidth, int rightWidth,
                            String spacer) {
         this(new OutputStreamWriter(out), leftWidth, rightWidth, spacer);
     }

     /**
      * Gets the writer to use to write to the left column.
      *
      * @return {@code non-null;} the left column writer
      */
     public Writer getLeft() {
         return leftColumn;
     }

     /**
      * Gets the writer to use to write to the right column.
      *
      * @return {@code non-null;} the right column writer
      */
     public Writer getRight() {
         return rightColumn;
     }

     /**
      * Flushes the output. If there are more lines of pending output in one
      * column, then the other column will get filled with blank lines.
      */
     public void flush() {
         try {
             appendNewlineIfNecessary(leftBuf, leftColumn);
             appendNewlineIfNecessary(rightBuf, rightColumn);
             outputFullLines();
             flushLeft();
             flushRight();
         } catch (IOException ex) {
             throw new RuntimeException(ex);
         }
     }

     /**
      * 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.
      */
     private void outputFullLines() throws IOException {
         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);
         }
     }

     /**
      * Flushes the left column buffer, printing it and clearing the buffer.
      * If the buffer is already empty, this does nothing.
      */
     private void flushLeft() throws IOException {
         appendNewlineIfNecessary(leftBuf, leftColumn);

         while (leftBuf.length() != 0) {
             rightColumn.write('\n');
             outputFullLines();
         }
     }

     /**
      * Flushes the right column buffer, printing it and clearing the buffer.
      * If the buffer is already empty, this does nothing.
      */
     private void flushRight() throws IOException {
         appendNewlineIfNecessary(rightBuf, rightColumn);

         while (rightBuf.length() != 0) {
             leftColumn.write('\n');
             outputFullLines();
         }
     }

     /**
      * 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 {@code non-null;} the buffer in question
      * @param out {@code non-null;} the writer to use
      */
     private static void appendNewlineIfNecessary(StringBuffer buf,
                                                  Writer out)
             throws IOException {
         int len = buf.length();

         if ((len != 0) && (buf.charAt(len - 1) != '\n')) {
             out.write('\n');
         }
     }

     /**
      * Writes the given number of spaces to the given writer.
      *
      * @param out {@code non-null;} where to write
      * @param amt {@code >= 0;} the number of spaces to write
      */
     private static void writeSpaces(Writer out, int amt) throws IOException {
         while (amt > 0) {
             out.write(' ');
             amt--;
         }
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dexgen.util;

	import java.io.IOException;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.StringWriter;
	import java.io.Writer;

	/**
	* 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.
	*/
	public final class TwoColumnOutput {
	/** {@code non-null;} underlying writer for final output */
	private final Writer out;

	/** {@code > 0;} the left column width */
	private final int leftWidth;

	/** {@code non-null;} pending left column output */
	private final StringBuffer leftBuf;

	/** {@code non-null;} pending right column output */
	private final StringBuffer rightBuf;

	/** {@code non-null;} left column writer */
	private final IndentingWriter leftColumn;

	/** {@code non-null;} right column writer */
	private final IndentingWriter rightColumn;

	/**
	* Turns the given two strings (with widths) and spacer into a formatted
	* two-column string.
	*
	* @param s1 {@code non-null;} first string
	* @param width1 {@code > 0;} width of the first column
	* @param spacer {@code non-null;} spacer string
	* @param s2 {@code non-null;} second string
	* @param width2 {@code > 0;} width of the second column
	* @return {@code non-null;} an appropriately-formatted string
	*/
	public static String toString(String s1, int width1, String spacer,
	String s2, int width2) {
	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();
	}

	/**
	* Constructs an instance.
	*
	* @param out {@code non-null;} writer to send final output to
	* @param leftWidth {@code > 0;} width of the left column, in characters
	* @param rightWidth {@code > 0;} width of the right column, in characters
	* @param spacer {@code non-null;} spacer string to sit between the two columns
	*/
	public TwoColumnOutput(Writer out, int leftWidth, int rightWidth,
	String spacer) {
	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);
	}

	/**
	* Constructs an instance.
	*
	* @param out {@code non-null;} stream to send final output to
	* @param leftWidth {@code >= 1;} width of the left column, in characters
	* @param rightWidth {@code >= 1;} width of the right column, in characters
	* @param spacer {@code non-null;} spacer string to sit between the two columns
	*/
	public TwoColumnOutput(OutputStream out, int leftWidth, int rightWidth,
	String spacer) {
	this(new OutputStreamWriter(out), leftWidth, rightWidth, spacer);
	}

	/**
	* Gets the writer to use to write to the left column.
	*
	* @return {@code non-null;} the left column writer
	*/
	public Writer getLeft() {
	return leftColumn;
	}

	/**
	* Gets the writer to use to write to the right column.
	*
	* @return {@code non-null;} the right column writer
	*/
	public Writer getRight() {
	return rightColumn;
	}

	/**
	* Flushes the output. If there are more lines of pending output in one
	* column, then the other column will get filled with blank lines.
	*/
	public void flush() {
	try {
	appendNewlineIfNecessary(leftBuf, leftColumn);
	appendNewlineIfNecessary(rightBuf, rightColumn);
	outputFullLines();
	flushLeft();
	flushRight();
	} catch (IOException ex) {
	throw new RuntimeException(ex);
	}
	}

	/**
	* 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.
	*/
	private void outputFullLines() throws IOException {
	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);
	}
	}

	/**
	* Flushes the left column buffer, printing it and clearing the buffer.
	* If the buffer is already empty, this does nothing.
	*/
	private void flushLeft() throws IOException {
	appendNewlineIfNecessary(leftBuf, leftColumn);

	while (leftBuf.length() != 0) {
	rightColumn.write('\n');
	outputFullLines();
	}
	}

	/**
	* Flushes the right column buffer, printing it and clearing the buffer.
	* If the buffer is already empty, this does nothing.
	*/
	private void flushRight() throws IOException {
	appendNewlineIfNecessary(rightBuf, rightColumn);

	while (rightBuf.length() != 0) {
	leftColumn.write('\n');
	outputFullLines();
	}
	}

	/**
	* 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 {@code non-null;} the buffer in question
	* @param out {@code non-null;} the writer to use
	*/
	private static void appendNewlineIfNecessary(StringBuffer buf,
	Writer out)
	throws IOException {
	int len = buf.length();

	if ((len != 0) && (buf.charAt(len - 1) != '\n')) {
	out.write('\n');
	}
	}

	/**
	* Writes the given number of spaces to the given writer.
	*
	* @param out {@code non-null;} where to write
	* @param amt {@code >= 0;} the number of spaces to write
	*/
	private static void writeSpaces(Writer out, int amt) throws IOException {
	while (amt > 0) {
	out.write(' ');
	amt--;
	}
	}
	}