    1   /* Copyright (C) 2003 Internet Archive.
    2    *
    3    * This file is part of the Heritrix web crawler (crawler.archive.org).
    4    *
    5    * Heritrix is free software; you can redistribute it and/or modify
    6    * it under the terms of the GNU Lesser Public License as published by
    7    * the Free Software Foundation; either version 2.1 of the License, or
    8    * any later version.
    9    *
    10   * Heritrix is distributed in the hope that it will be useful,
    11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13   * GNU Lesser Public License for more details.
    14   *
    15   * You should have received a copy of the GNU Lesser Public License
    16   * along with Heritrix; if not, write to the Free Software
    17   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    18   *
    19   * PaddingStringBuffer.java
    20   * Created on Oct 23, 2003
    21   *
    22   * $Header$
    23   */
    24  package org.archive.util;
    25
    26  /***
    27   * StringBuffer-like utility which can add spaces to reach a certain column.  It
    28   * allows you to append {@link String}, <code>long</code> and <code>int</code>s
    29   * to the buffer.
    30   * <p>
    31   * Note: This class counts from 1, not 0.
    32   * <p>
    33   * It uses a StringBuffer behind the scenes.
    34   * <p>
    35   * To write a string with multiple lines, it is advisible to use the
    36   * {@link #newline() newline()} function. Regular appending of strings with
    37   * newlines (\n) character should be safe though. Right appending of strings
    38   * with such characters is <i>not</i> safe.
    39   *
    40   * @author Gordon Mohr
    41   */
    42  public final class PaddingStringBuffer {
    43      // The buffer.
    44      StringBuffer buffer;
    45      // Location in current line
    46      int linePos;
    47
    48      /***
    49       * Create a new PaddingStringBuffer
    50       *
    51       */
    52      public PaddingStringBuffer() {
    53          buffer = new StringBuffer();
    54          linePos=0;
    55      }
    56
    57      /*** append a string directly to the buffer
    58       * @param string the string to append
    59       * @return This wrapped buffer w/ the passed string appended.
    60       */
    61      public PaddingStringBuffer append(String string) {
    62          buffer.append(string);
    63          if ( string.indexOf('\n') == -1 ){
    64              linePos+=string.length();
    65          } else {
    66              while ( string.indexOf('\n') == -1 ){
    67                  string = string.substring(string.indexOf('\n'));
    68              }
    69              linePos=string.length();
    70          }
    71          return this;
    72      }
    73
    74      /***
    75       * Append a string, right-aligned to the given columm.  If the buffer
    76       * length is already greater than the column specified, it simply appends
    77       * the string
    78       *
    79       * @param col the column to right-align to
    80       * @param string the string, must not contain multiple lines.
    81       * @return This wrapped buffer w/ append string, right-aligned to the
    82       * given column.
    83       */
    84      public PaddingStringBuffer raAppend(int col, String string) {
    85          padTo(col-string.length());
    86          append(string);
    87          return this;
    88      }
    89
    90      /*** Pad to a given column.  If the buffer size is already greater than the
    91       * column, nothing is done.
    92       * @param col
    93       * @return The buffer padded to <code>i</code>.
    94       */
    95      public PaddingStringBuffer padTo(int col) {
    96          while(linePos<col) {
    97              buffer.append(" ");
    98              linePos++;
    99          }
    100         return this;
    101     }
    102
    103     /*** append an <code>int</code> to the buffer.
    104      * @param i the int to append
    105      * @return This wrapped buffer with <code>i</code> appended.
    106      */
    107     public PaddingStringBuffer append(int i) {
    108         append(Integer.toString(i));
    109         return this;
    110     }
    111
    112
    113     /***
    114      * Append an <code>int</code> right-aligned to the given column.  If the
    115      * buffer length is already greater than the column specified, it simply
    116      * appends the <code>int</code>.
    117      *
    118      * @param col the column to right-align to
    119      * @param i   the int to append
    120      * @return This wrapped buffer w/ appended int, right-aligned to the
    121      *         given column.
    122      */
    123     public PaddingStringBuffer raAppend(int col, int i) {
    124         return raAppend(col,Integer.toString(i));
    125     }
    126
    127     /*** append a <code>long</code> to the buffer.
    128      * @param lo the <code>long</code> to append
    129      * @return This wrapped buffer w/ appended long.
    130      */
    131     public PaddingStringBuffer append(long lo) {
    132         append(Long.toString(lo));
    133         return this;
    134     }
    135
    136     /***Append a <code>long</code>, right-aligned to the given column.  If the
    137      * buffer length is already greater than the column specified, it simply
    138      * appends the <code>long</code>.
    139      * @param col the column to right-align to
    140      * @param lo the long to append
    141      * @return This wrapped buffer w/ appended long, right-aligned to the
    142      * given column.
    143      */
    144     public PaddingStringBuffer raAppend(int col, long lo) {
    145         return raAppend(col,Long.toString(lo));
    146     }
    147
    148     /*** reset the buffer back to empty */
    149     public void reset() {
    150         buffer = new StringBuffer();
    151         linePos = 0;
    152     }
    153
    154     /* (non-Javadoc)
    155      * @see java.lang.Object#toString()
    156      */
    157     public String toString() {
    158         return buffer.toString();
    159     }
    160
    161     /***
    162      * Forces a new line in the buffer.
    163      */
    164     public PaddingStringBuffer newline() {
    165         buffer.append("\n");
    166         linePos = 0;
    167         return this;
    168     }
    169
    170 }