jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/tools/internal/ws/processor/util/IndentingWriter.java@9c07ef4934dd

     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  */

    26 package com.sun.tools.internal.ws.processor.util;

    28 import com.sun.tools.internal.ws.processor.generator.GeneratorException;

    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;

    37 /**

    38  *

    39  * @author WS Development Team

    40  */

    41 public class IndentingWriter extends BufferedWriter {

    43     private boolean beginningOfLine = true;

    44     private int currentIndent = 0;

    45     private int indentStep = 4;

    47     public IndentingWriter(Writer out) {

    48         super(out);

    49     }

    51     public IndentingWriter(Writer out,int step) {

    52         this(out);

    54         if (indentStep < 0) {

    55             throw new IllegalArgumentException("negative indent step");

    56         }

    57         indentStep = step;

    58     }

    60     public void write(int c) throws IOException {

    61         checkWrite();

    62         super.write(c);

    63     }

    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     }

    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     }

    79     public void newLine() throws IOException {

    80         super.newLine();

    81         beginningOfLine = true;

    82     }

    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     }

    95     protected void indentIn() {

    96         currentIndent += indentStep;

    97     }

    99     protected void indentOut() {

   100         currentIndent -= indentStep;

   101         if (currentIndent < 0) {

   102             currentIndent = 0;

   103         }

   104     }

   106     public void pI() {

   107         indentIn();

   108     }

   110     public void pO() {

   111         indentOut();

   112     }

   114     public void pI(int levels) {

   115         for (int i = 0; i < levels; ++i) {

   116             indentIn();

   117         }

   118     }

   120     public void pO(int levels) {

   121         for (int i = 0; i < levels; ++i) {

   122             indentOut();

   123         }

   124     }

   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         }

   136         String printStr = s.substring(tabCount);

   137          */

   138         boolean canEncode = true;

   140         //bug fix: 4839636

   141         try{

   142             if(!canEncode(s)) {

   143                 canEncode = false;

   144             }

   145         } catch (Throwable t) {

   147             // there was some exception, what should we do?

   148             // lets ignore it for now and proceed with the code generation!

   149         }

   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     }

   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     }

   179     public void p(String s1, String s2) throws IOException {

   180         p(s1);

   181         p(s2);

   182     }

   184     public void p(String s1, String s2, String s3) throws IOException {

   185         p(s1);

   186         p(s2);

   187         p(s3);

   188     }

   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     }

   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     }

   205     public void pln() throws IOException {

   206         newLine();

   207     }

   209     public void pln(String s) throws IOException {

   210         p(s);

   211         pln();

   212     }

   214     public void pln(String s1, String s2) throws IOException {

   215         p(s1, s2);

   216         pln();

   217     }

   219     public void pln(String s1, String s2, String s3) throws IOException {

   220         p(s1, s2, s3);

   221         pln();

   222     }

   224     public void pln(String s1, String s2, String s3, String s4) throws IOException {

   225         p(s1, s2, s3, s4);

   226         pln();

   227     }

   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     }

   234     public void plnI(String s) throws IOException {

   235         p(s);

   236         pln();

   237         pI();

   238     }

   240     public void pO(String s) throws IOException {

   241         pO();

   242         p(s);

   243     }

   245     public void pOln(String s) throws IOException {

   246         pO(s);

   247         pln();

   248     }

   250     public void pOlnI(String s) throws IOException {

   251         pO(s);

   252         pln();

   253         pI();

   254     }

   256     public void p(Object o) throws IOException {

   257         write(o.toString());

   258     }

   260     public void pln(Object o) throws IOException {

   261         p(o.toString());

   262         pln();

   263     }

   265     public void plnI(Object o) throws IOException {

   266         p(o.toString());

   267         pln();

   268         pI();

   269     }

   271     public void pO(Object o) throws IOException {

   272         pO();

   273         p(o.toString());

   274     }

   276     public void pOln(Object o) throws IOException {

   277         pO(o.toString());

   278         pln();

   279     }

   281     public void pOlnI(Object o) throws IOException {

   282         pO(o.toString());

   283         pln();

   284         pI();

   285     }

   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     }

   301     public void pMln(String s) throws IOException {

   302         pM(s);

   303         pln();

   304     }

   306     public void pMlnI(String s) throws IOException {

   307         pM(s);

   308         pln();

   309         pI();

   310     }

   312     public void pMO(String s) throws IOException {

   313         pO();

   314         pM(s);

   315     }

   317     public void pMOln(String s) throws IOException {

   318         pMO(s);

   319         pln();

   320     }

   322     public void pF(String pattern, Object[] arguments) throws IOException {

   323         pM(MessageFormat.format(pattern, arguments));

   324     }

   326     public void pFln(String pattern, Object[] arguments) throws IOException {

   327         pF(pattern, arguments);

   328         pln();

   329     }

   330 }

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

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

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