Mercurial > jdk8-mips64-public > jaxws / file comparison

comparison: src/share/jaxws_classes/com/sun/tools/internal/ws/processor/util/IndentingWriter.java

src/share/jaxws_classes/com/sun/tools/internal/ws/processor/util/IndentingWriter.java

changeset 0
373ffda63c9a
child 637
9c07ef4934dd
equal deleted inserted replaced
-1:000000000000 0:373ffda63c9a
1 /*
2 * Copyright (c) 1997, 2012, 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 package com.sun.tools.internal.ws.processor.util;
27
28 import com.sun.tools.internal.ws.processor.generator.GeneratorException;
29
30 import java.io.BufferedWriter;
31 import java.io.IOException;
32 import java.io.Writer;
33 import java.nio.charset.Charset;
34 import java.nio.charset.CharsetEncoder;
35 import java.text.MessageFormat;
36
37 /**
38 *
39 * @author WS Development Team
40 */
41 public class IndentingWriter extends BufferedWriter {
42
43 private boolean beginningOfLine = true;
44 private int currentIndent = 0;
45 private int indentStep = 4;
46
47 public IndentingWriter(Writer out) {
48 super(out);
49 }
50
51 public IndentingWriter(Writer out,int step) {
52 this(out);
53
54 if (indentStep < 0) {
55 throw new IllegalArgumentException("negative indent step");
56 }
57 indentStep = step;
58 }
59
60 public void write(int c) throws IOException {
61 checkWrite();
62 super.write(c);
63 }
64
65 public void write(char[] cbuf, int off, int len) throws IOException {
66 if (len > 0) {
67 checkWrite();
68 }
69 super.write(cbuf, off, len);
70 }
71
72 public void write(String s, int off, int len) throws IOException {
73 if (len > 0) {
74 checkWrite();
75 }
76 super.write(s, off, len);
77 }
78
79 public void newLine() throws IOException {
80 super.newLine();
81 beginningOfLine = true;
82 }
83
84 protected void checkWrite() throws IOException {
85 if (beginningOfLine) {
86 beginningOfLine = false;
87 int i = currentIndent;
88 while (i > 0) {
89 super.write(' ');
90 -- i;
91 }
92 }
93 }
94
95 protected void indentIn() {
96 currentIndent += indentStep;
97 }
98
99 protected void indentOut() {
100 currentIndent -= indentStep;
101 if (currentIndent < 0) {
102 currentIndent = 0;
103 }
104 }
105
106 public void pI() {
107 indentIn();
108 }
109
110 public void pO() {
111 indentOut();
112 }
113
114 public void pI(int levels) {
115 for (int i = 0; i < levels; ++i) {
116 indentIn();
117 }
118 }
119
120 public void pO(int levels) {
121 for (int i = 0; i < levels; ++i) {
122 indentOut();
123 }
124 }
125
126 public void p(String s) throws IOException {
127 /*
128 int tabCount = 0;
129 for (int i = 0; i < s.length(); ++i) {
130 if (s.charAt(i) == '\t') {
131 ++tabCount;
132 indentIn();
133 }
134 }
135
136 String printStr = s.substring(tabCount);
137 */
138 boolean canEncode = true;
139
140 //bug fix: 4839636
141 try{
142 if(!canEncode(s)) {
143 canEncode = false;
144 }
145 } catch (Throwable t) {
146
147 // there was some exception, what should we do?
148 // lets ignore it for now and proceed with the code generation!
149 }
150
151 if(!canEncode) {
152 throw new GeneratorException(
153 "generator.indentingwriter.charset.cantencode", s);
154 }
155 write(s);
156 /*
157 while (tabCount-- > 0) {
158 indentOut();
159 }
160 */
161 }
162
163 /**
164 * Check if encode can handle the chars in this string.
165 *
166 */
167 protected boolean canEncode(String s) {
168 final CharsetEncoder encoder =
169 Charset.forName(System.getProperty("file.encoding")).newEncoder();
170 char[] chars = s.toCharArray();
171 for (int i=0; i<chars.length; i++) {
172 if(!encoder.canEncode(chars[i])) {
173 return false;
174 }
175 }
176 return true;
177 }
178
179 public void p(String s1, String s2) throws IOException {
180 p(s1);
181 p(s2);
182 }
183
184 public void p(String s1, String s2, String s3) throws IOException {
185 p(s1);
186 p(s2);
187 p(s3);
188 }
189
190 public void p(String s1, String s2, String s3, String s4) throws IOException {
191 p(s1);
192 p(s2);
193 p(s3);
194 p(s4);
195 }
196
197 public void p(String s1, String s2, String s3, String s4, String s5) throws IOException {
198 p(s1);
199 p(s2);
200 p(s3);
201 p(s4);
202 p(s5);
203 }
204
205 public void pln() throws IOException {
206 newLine();
207 }
208
209 public void pln(String s) throws IOException {
210 p(s);
211 pln();
212 }
213
214 public void pln(String s1, String s2) throws IOException {
215 p(s1, s2);
216 pln();
217 }
218
219 public void pln(String s1, String s2, String s3) throws IOException {
220 p(s1, s2, s3);
221 pln();
222 }
223
224 public void pln(String s1, String s2, String s3, String s4) throws IOException {
225 p(s1, s2, s3, s4);
226 pln();
227 }
228
229 public void pln(String s1, String s2, String s3, String s4, String s5) throws IOException {
230 p(s1, s2, s3, s4, s5);
231 pln();
232 }
233
234 public void plnI(String s) throws IOException {
235 p(s);
236 pln();
237 pI();
238 }
239
240 public void pO(String s) throws IOException {
241 pO();
242 p(s);
243 }
244
245 public void pOln(String s) throws IOException {
246 pO(s);
247 pln();
248 }
249
250 public void pOlnI(String s) throws IOException {
251 pO(s);
252 pln();
253 pI();
254 }
255
256 public void p(Object o) throws IOException {
257 write(o.toString());
258 }
259
260 public void pln(Object o) throws IOException {
261 p(o.toString());
262 pln();
263 }
264
265 public void plnI(Object o) throws IOException {
266 p(o.toString());
267 pln();
268 pI();
269 }
270
271 public void pO(Object o) throws IOException {
272 pO();
273 p(o.toString());
274 }
275
276 public void pOln(Object o) throws IOException {
277 pO(o.toString());
278 pln();
279 }
280
281 public void pOlnI(Object o) throws IOException {
282 pO(o.toString());
283 pln();
284 pI();
285 }
286
287 public void pM(String s) throws IOException {
288 int i = 0;
289 while (i < s.length()) {
290 int j = s.indexOf('\n', i);
291 if (j == -1) {
292 p(s.substring(i));
293 break;
294 } else {
295 pln(s.substring(i, j));
296 i = j + 1;
297 }
298 }
299 }
300
301 public void pMln(String s) throws IOException {
302 pM(s);
303 pln();
304 }
305
306 public void pMlnI(String s) throws IOException {
307 pM(s);
308 pln();
309 pI();
310 }
311
312 public void pMO(String s) throws IOException {
313 pO();
314 pM(s);
315 }
316
317 public void pMOln(String s) throws IOException {
318 pMO(s);
319 pln();
320 }
321
322 public void pF(String pattern, Object[] arguments) throws IOException {
323 pM(MessageFormat.format(pattern, arguments));
324 }
325
326 public void pFln(String pattern, Object[] arguments) throws IOException {
327 pF(pattern, arguments);
328 pln();
329 }
330 }

Mercurial Repository: jdk8-mips64-public/jaxws

mercurial