xmlsecurity/tools/uno/SAXEventPrinter.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SAXEventPrinter.java,v $
  10  * $Revision: 1.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 package com.sun.star.xml.security.uno;
  32
  33 import org.w3c.dom.Node;
  34 import org.w3c.dom.NamedNodeMap;
  35 import org.w3c.dom.Attr;
  36 import org.w3c.dom.NodeList;
  37 import java.io.IOException;
  38 import java.io.FileOutputStream;
  39
  40 /* uno classes */
  41 import com.sun.star.xml.sax.XDocumentHandler;
  42 import com.sun.star.xml.sax.XAttributeList;
  43
  44 /*
  45  * The SAXEventPrinter class is used to print out received
  46  * SAX event stream.
  47  */
  48 class SAXEventPrinter implements XDocumentHandler
  49 {
  50     /*
  51      * how many spaces as the indent of line
  52      */
  53     private int m_nIndent;
  54
  55     /*
  56      * whether a NEW LINE character need to be appended to
  57      * each line
  58      */
  59     private boolean m_bIsFormatted;
  60
  61     /*
  62      * the output stream to write
  63      */
  64     private FileOutputStream m_fileOutputStream;
  65
  66     SAXEventPrinter(FileOutputStream fileOutputStream, boolean isFormatted)
  67     {
  68         m_nIndent = 0;
  69         m_fileOutputStream = fileOutputStream;
  70         m_bIsFormatted = isFormatted;
  71     }
  72
  73     protected static void outputIndent(int m_nIndent, FileOutputStream fileOutputStream)
  74         throws IOException
  75     {
  76         for (int i=0; i<m_nIndent; ++i)
  77         {
  78             fileOutputStream.write(" ".getBytes());
  79         }
  80     }
  81
  82     /*
  83      * displays the tree of a Node.
  84      */
  85     protected static void display(Node node, int indent, FileOutputStream fileOutputStream, boolean isFormatted)
  86         throws IOException
  87     {
  88         if (node != null)
  89         {
  90             int type = node.getNodeType();
  91             String message;
  92             NodeList children;
  93             int i, length;
  94
  95             switch (type)
  96             {
  97             case Node.DOCUMENT_NODE:
  98                 children = node.getChildNodes();
  99                 length = children.getLength();
 100                 for (i=0; i<length; ++i)
 101                 {
 102                     display(children.item(i), indent+2, fileOutputStream, isFormatted);
 103                 }
 104
 105                 break;
 106
 107             case Node.ELEMENT_NODE:
 108                 message = new String("<"+node.getNodeName());
 109                 NamedNodeMap attrs = node.getAttributes();
 110
 111                 length = attrs.getLength();
 112                 for (i=0; i<length; ++i)
 113                 {
 114                     Attr attr = (Attr)attrs.item(i);
 115                     message += " "+attr.getNodeName()+"=\""+attr.getNodeValue()+"\"";
 116                 }
 117
 118                 message += ">";
 119
 120                 if (isFormatted)
 121                 {
 122                     outputIndent(indent, fileOutputStream);
 123                 }
 124
 125                 fileOutputStream.write(message.getBytes("UTF-8"));
 126
 127                 if (isFormatted)
 128                 {
 129                     fileOutputStream.write("\n".getBytes());
 130                 }
 131
 132                 children = node.getChildNodes();
 133                 length = children.getLength();
 134                 for (i=0; i<length; ++i)
 135                 {
 136                     display(children.item(i), indent+2, fileOutputStream, isFormatted);
 137                 }
 138
 139                 if (isFormatted)
 140                 {
 141                     outputIndent(indent, fileOutputStream);
 142                 }
 143
 144                 fileOutputStream.write("</".getBytes());
 145                 fileOutputStream.write(node.getNodeName().getBytes("UTF-8"));
 146                 fileOutputStream.write(">".getBytes());
 147
 148                 if (isFormatted)
 149                 {
 150                     fileOutputStream.write("\n".getBytes());
 151                 }
 152
 153                 break;
 154
 155             case Node.TEXT_NODE:
 156                 message = node.getNodeValue();
 157                 if (message != null )
 158                 {
 159                     if (isFormatted)
 160                     {
 161                         outputIndent(indent, fileOutputStream);
 162                     }
 163
 164                     fileOutputStream.write(node.getNodeValue().getBytes("UTF-8"));
 165
 166                     if (isFormatted)
 167                     {
 168                         fileOutputStream.write("\n".getBytes());
 169                     }
 170                 }
 171                 break;
 172
 173             case Node.PROCESSING_INSTRUCTION_NODE:
 174                 if (isFormatted)
 175                 {
 176                     outputIndent(indent, fileOutputStream);
 177                 }
 178
 179                 fileOutputStream.write("<?".getBytes());
 180                 fileOutputStream.write(node.getNodeName().getBytes("UTF-8"));
 181                 fileOutputStream.write(node.getNodeValue().getBytes("UTF-8"));
 182                 fileOutputStream.write("?>".getBytes());
 183
 184                 if (isFormatted)
 185                 {
 186                     fileOutputStream.write("\n".getBytes());
 187                 }
 188
 189                 break;
 190             default:
 191                 break;
 192             }
 193         }
 194     }
 195
 196     /*
 197      * XDocumentHandler
 198      */
 199     public void  startDocument ()
 200     {
 201     }
 202
 203     public void endDocument()
 204     {
 205     }
 206
 207     public void startElement (String str, com.sun.star.xml.sax.XAttributeList xattribs)
 208     {
 209         try
 210         {
 211             String message;
 212
 213             message = new String("<"+str);
 214             if (xattribs !=null)
 215             {
 216                 int length = xattribs.getLength();
 217                 for (short i=0; i<length; ++i)
 218                 {
 219                     message += " "+xattribs.getNameByIndex(i)+"=\""+xattribs.getValueByIndex(i)+"\"";
 220                 }
 221             }
 222             message += ">";
 223
 224             if (m_bIsFormatted)
 225             {
 226                 outputIndent(m_nIndent, m_fileOutputStream);
 227             }
 228
 229             m_fileOutputStream.write(message.getBytes("UTF-8"));
 230
 231             if (m_bIsFormatted)
 232             {
 233                 m_fileOutputStream.write("\n".getBytes());
 234             }
 235
 236             m_nIndent += 2;
 237         }
 238         catch (IOException e)
 239         {
 240             e.printStackTrace();
 241         }
 242     }
 243
 244     public void endElement(String str)
 245     {
 246         try
 247         {
 248             m_nIndent -= 2;
 249             if (m_bIsFormatted)
 250             {
 251                 outputIndent(m_nIndent, m_fileOutputStream);
 252             }
 253
 254             m_fileOutputStream.write("</".getBytes());
 255             m_fileOutputStream.write(str.getBytes("UTF-8"));
 256             m_fileOutputStream.write(">".getBytes());
 257
 258             if (m_bIsFormatted)
 259             {
 260                 m_fileOutputStream.write("\n".getBytes());
 261             }
 262         }
 263         catch (IOException e)
 264         {
 265             e.printStackTrace();
 266         }
 267     }
 268
 269     public void characters(String str)
 270     {
 271         try
 272         {
 273             if (m_bIsFormatted)
 274             {
 275                 outputIndent(m_nIndent, m_fileOutputStream);
 276             }
 277
 278             m_fileOutputStream.write(str.getBytes("UTF-8"));
 279
 280             if (m_bIsFormatted)
 281             {
 282                 m_fileOutputStream.write("\n".getBytes());
 283             }
 284         }
 285         catch (IOException e)
 286         {
 287             e.printStackTrace();
 288         }
 289     }
 290
 291     public void ignorableWhitespace(String str)
 292     {
 293     }
 294
 295     public void processingInstruction(String aTarget, String aData)
 296     {
 297         try
 298         {
 299             if (m_bIsFormatted)
 300             {
 301                 outputIndent(m_nIndent, m_fileOutputStream);
 302             }
 303
 304             m_fileOutputStream.write("<?".getBytes());
 305             m_fileOutputStream.write(aTarget.getBytes("UTF-8"));
 306             m_fileOutputStream.write("?>".getBytes());
 307
 308             if (m_bIsFormatted)
 309             {
 310                 m_fileOutputStream.write("\n".getBytes());
 311             }
 312         }
 313         catch (IOException e)
 314         {
 315             e.printStackTrace();
 316         }
 317     }
 318
 319     public void setDocumentLocator (com.sun.star.xml.sax.XLocator xLocator )
 320         throws com.sun.star.xml.sax.SAXException
 321     {
 322     }
 323 }