1 /* 2 * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /*****************************************************************************/ 27 /* Copyright (c) IBM Corporation 1998 */ 28 /* */ 29 /* (C) Copyright IBM Corp. 1998 */ 30 /* */ 31 /*****************************************************************************/ 32 33 package sun.rmi.rmic; 34 35 import java.io.Writer; 36 import java.io.BufferedWriter; 37 import java.io.IOException; 38 39 /** 40 * IndentingWriter is a BufferedWriter subclass that supports automatic 41 * indentation of lines of text written to the underlying Writer. 42 * 43 * Methods are provided for compact, convenient indenting, writing text, 44 * and writing lines in various combinations. 45 * 46 * WARNING: The contents of this source file are not part of any 47 * supported API. Code that depends on them does so at its own risk: 48 * they are subject to change or removal without notice. 49 */ 50 public class IndentingWriter extends BufferedWriter { 51 52 /** true if the next character written is the first on a line */ 53 private boolean beginningOfLine = true; 54 55 /** current number of spaces to prepend to lines */ 56 private int currentIndent = 0; 57 58 /** number of spaces to change indent when indenting in or out */ 59 private int indentStep = 4; 60 61 /** number of spaces to convert into tabs. Use MAX_VALUE to disable */ 62 private int tabSize = 8; 63 64 /** 65 * Create a new IndentingWriter that writes indented text to the 66 * given Writer. Use the default indent step of four spaces. 67 */ IndentingWriter(Writer out)68 public IndentingWriter(Writer out) { 69 super(out); 70 } 71 72 /** 73 * Create a new IndentingWriter that writes indented text to the 74 * given Writer and uses the supplied indent step. 75 */ IndentingWriter(Writer out, int step)76 public IndentingWriter(Writer out, int step) { 77 this(out); 78 79 if (indentStep < 0) 80 throw new IllegalArgumentException("negative indent step"); 81 82 indentStep = step; 83 } 84 85 /** 86 * Create a new IndentingWriter that writes indented text to the 87 * given Writer and uses the supplied indent step and tab size. 88 */ IndentingWriter(Writer out, int step, int tabSize)89 public IndentingWriter(Writer out, int step, int tabSize) { 90 this(out); 91 92 if (indentStep < 0) 93 throw new IllegalArgumentException("negative indent step"); 94 95 indentStep = step; 96 this.tabSize = tabSize; 97 } 98 99 /** 100 * Write a single character. 101 */ write(int c)102 public void write(int c) throws IOException { 103 checkWrite(); 104 super.write(c); 105 } 106 107 /** 108 * Write a portion of an array of characters. 109 */ write(char[] cbuf, int off, int len)110 public void write(char[] cbuf, int off, int len) throws IOException { 111 if (len > 0) { 112 checkWrite(); 113 } 114 super.write(cbuf, off, len); 115 } 116 117 /** 118 * Write a portion of a String. 119 */ write(String s, int off, int len)120 public void write(String s, int off, int len) throws IOException { 121 if (len > 0) { 122 checkWrite(); 123 } 124 super.write(s, off, len); 125 } 126 127 /** 128 * Write a line separator. The next character written will be 129 * preceded by an indent. 130 */ newLine()131 public void newLine() throws IOException { 132 super.newLine(); 133 beginningOfLine = true; 134 } 135 136 /** 137 * Check if an indent needs to be written before writing the next 138 * character. 139 * 140 * The indent generation is optimized (and made consistent with 141 * certain coding conventions) by condensing groups of eight spaces 142 * into tab characters. 143 */ checkWrite()144 protected void checkWrite() throws IOException { 145 if (beginningOfLine) { 146 beginningOfLine = false; 147 int i = currentIndent; 148 while (i >= tabSize) { 149 super.write('\t'); 150 i -= tabSize; 151 } 152 while (i > 0) { 153 super.write(' '); 154 -- i; 155 } 156 } 157 } 158 159 /** 160 * Increase the current indent by the indent step. 161 */ indentIn()162 protected void indentIn() { 163 currentIndent += indentStep; 164 } 165 166 /** 167 * Decrease the current indent by the indent step. 168 */ indentOut()169 protected void indentOut() { 170 currentIndent -= indentStep; 171 if (currentIndent < 0) 172 currentIndent = 0; 173 } 174 175 /** 176 * Indent in. 177 */ pI()178 public void pI() { 179 indentIn(); 180 } 181 182 /** 183 * Indent out. 184 */ pO()185 public void pO() { 186 indentOut(); 187 } 188 189 /** 190 * Write string. 191 */ p(String s)192 public void p(String s) throws IOException { 193 write(s); 194 } 195 196 /** 197 * End current line. 198 */ pln()199 public void pln() throws IOException { 200 newLine(); 201 } 202 203 /** 204 * Write string; end current line. 205 */ pln(String s)206 public void pln(String s) throws IOException { 207 p(s); 208 pln(); 209 } 210 211 /** 212 * Write string; end current line; indent in. 213 */ plnI(String s)214 public void plnI(String s) throws IOException { 215 p(s); 216 pln(); 217 pI(); 218 } 219 220 /** 221 * Indent out; write string. 222 */ pO(String s)223 public void pO(String s) throws IOException { 224 pO(); 225 p(s); 226 } 227 228 /** 229 * Indent out; write string; end current line. 230 */ pOln(String s)231 public void pOln(String s) throws IOException { 232 pO(s); 233 pln(); 234 } 235 236 /** 237 * Indent out; write string; end current line; indent in. 238 * 239 * This method is useful for generating lines of code that both 240 * end and begin nested blocks, like "} else {". 241 */ pOlnI(String s)242 public void pOlnI(String s) throws IOException { 243 pO(s); 244 pln(); 245 pI(); 246 } 247 248 /** 249 * Write Object. 250 */ p(Object o)251 public void p(Object o) throws IOException { 252 write(o.toString()); 253 } 254 /** 255 * Write Object; end current line. 256 */ pln(Object o)257 public void pln(Object o) throws IOException { 258 p(o.toString()); 259 pln(); 260 } 261 262 /** 263 * Write Object; end current line; indent in. 264 */ plnI(Object o)265 public void plnI(Object o) throws IOException { 266 p(o.toString()); 267 pln(); 268 pI(); 269 } 270 271 /** 272 * Indent out; write Object. 273 */ pO(Object o)274 public void pO(Object o) throws IOException { 275 pO(); 276 p(o.toString()); 277 } 278 279 /** 280 * Indent out; write Object; end current line. 281 */ pOln(Object o)282 public void pOln(Object o) throws IOException { 283 pO(o.toString()); 284 pln(); 285 } 286 287 /** 288 * Indent out; write Object; end current line; indent in. 289 * 290 * This method is useful for generating lines of code that both 291 * end and begin nested blocks, like "} else {". 292 */ pOlnI(Object o)293 public void pOlnI(Object o) throws IOException { 294 pO(o.toString()); 295 pln(); 296 pI(); 297 } 298 299 } 300