View Javadoc

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 }