xmlsecurity/tools/uno/ParsingThread.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: ParsingThread.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 com.sun.star.xml.sax.XDocumentHandler;
  35 import org.w3c.dom.Attr;
  36 import org.w3c.dom.NamedNodeMap;
  37
  38 /*
  39  * this class is used to parse a document into SAX events
  40  */
  41 class ParsingThread
  42 {
  43     /*
  44      * the Node which will be handled with in the next step
  45      */
  46     private Node m_node;
  47
  48     /*
  49      * the event to be handled in the next step.
  50      * true means endElement event, false otherwise.
  51      */
  52     private boolean m_bIsEndEvent;
  53
  54     /*
  55      * the document handler which receives generated SAX events
  56      */
  57     private XDocumentHandler m_xDocumentHandler;
  58
  59     /*
  60      * the TestTool which receives UI feedbacks
  61      */
  62     private TestTool m_testTool;
  63
  64
  65         ParsingThread(Node node, XDocumentHandler xDocumentHandler, TestTool testTool)
  66         {
  67             m_node = node;
  68             m_xDocumentHandler = xDocumentHandler;
  69             m_testTool = testTool;
  70
  71             m_bIsEndEvent = false;
  72         }
  73
  74         /*
  75          * changes the document handler.
  76          */
  77         protected void setHandler(XDocumentHandler xDocumentHandler)
  78         {
  79             this.m_xDocumentHandler = xDocumentHandler;
  80         }
  81
  82         /*
  83          * sends the next SAX event.
  84          * when there is no further step, then false is returned,
  85          * otherwise, true returned.
  86          */
  87         protected boolean nextStep()
  88         {
  89             boolean rc = true;
  90
  91             try
  92             {
  93                 String message;
  94             int type = m_node.getNodeType();
  95             if (!m_bIsEndEvent)
  96             /*
  97              * the next event is not a endElement event.
  98              */
  99             {
 100                 switch (type)
 101                 {
 102                 case Node.DOCUMENT_NODE: /* startDocument */
 103                     m_testTool.updatesCurrentSAXEventInformation("startDocument");
 104                     m_xDocumentHandler.startDocument();
 105                     m_testTool.updatesUIs();
 106                     break;
 107                 case Node.ELEMENT_NODE: /* startElement */
 108                     String nodeName = m_node.getNodeName();
 109                     message = "startElement:"+nodeName;
 110                     NamedNodeMap attrs = m_node.getAttributes();
 111
 112                     AttributeListHelper attributeListHelper = new AttributeListHelper();
 113
 114                     int length = attrs.getLength();
 115                     for (int i=0; i<length; ++i)
 116                     {
 117                         Attr attr = (Attr)attrs.item(i);
 118                         attributeListHelper.setAttribute(attr.getName(), "CDATA", attr.getValue());
 119                         message += " "+attr.getName()+"='"+attr.getValue()+"'";
 120                     }
 121
 122                     m_testTool.updatesCurrentSAXEventInformation(message);
 123                     m_xDocumentHandler.startElement(m_node.getNodeName(), attributeListHelper);
 124
 125                     m_testTool.updatesUIs();
 126                     break;
 127                 case Node.TEXT_NODE: /* characters */
 128                     message = m_node.getNodeValue();
 129                     if (message != null)
 130                     {
 131                         m_testTool.updatesCurrentSAXEventInformation("characters:"+message);
 132                         m_xDocumentHandler.characters(message);
 133                         m_testTool.updatesUIs();
 134                     }
 135                     break;
 136                 case Node.COMMENT_NODE: /* comment */
 137                     break;
 138                 case Node.PROCESSING_INSTRUCTION_NODE: /* PI */
 139                     m_testTool.updatesCurrentSAXEventInformation("processingInstruction:"+m_node.getNodeName()+" "+m_node.getNodeValue());
 140                     m_xDocumentHandler.processingInstruction(m_node.getNodeName(), m_node.getNodeValue());
 141                     m_testTool.updatesUIs();
 142                     break;
 143                 }
 144
 145                 /*
 146                  * figures out the event for the next step.
 147                  */
 148                 switch (type)
 149                 {
 150                     case Node.DOCUMENT_NODE:
 151                     case Node.ELEMENT_NODE:
 152                         if (m_node.hasChildNodes())
 153                         /*
 154                          * for a Document node or an Element node,
 155                          * if the node has children, then the next event will be for its
 156                          * first child node.
 157                          */
 158                         {
 159                             m_node = m_node.getFirstChild();
 160                         }
 161                         else
 162                         /*
 163                          * otherwise, the next event will be endElement.
 164                          */
 165                         {
 166                             m_bIsEndEvent = true;
 167                         }
 168                         break;
 169                     case Node.TEXT_NODE:
 170                     case Node.PROCESSING_INSTRUCTION_NODE:
 171                     case Node.COMMENT_NODE:
 172                         Node nextNode = m_node.getNextSibling();
 173                         if (nextNode != null)
 174                         /*
 175                          * for other kinds of node,
 176                          * if it has a next sibling, then the next event will be for that
 177                          * sibling.
 178                          */
 179                         {
 180                             m_node = nextNode;
 181                         }
 182                         else
 183                         /*
 184                          * otherwise, the next event will be the endElement for the node's
 185                          * parent node.
 186                          */
 187                         {
 188                             m_node = m_node.getParentNode();
 189                             m_bIsEndEvent = true;
 190                         }
 191                         break;
 192                 }
 193             }
 194             else
 195             /*
 196              * the next event is an endElement event.
 197              */
 198             {
 199                 switch (type)
 200                 {
 201                     case Node.DOCUMENT_NODE: /* endDocument */
 202                         m_testTool.updatesCurrentSAXEventInformation("endDocument");
 203                         m_xDocumentHandler.endDocument();
 204                         m_testTool.updatesUIs();
 205
 206                         /*
 207                          * no further steps.
 208                          */
 209                         rc = false;
 210                         break;
 211                     case Node.ELEMENT_NODE: /* endElement */
 212                         m_testTool.updatesCurrentSAXEventInformation("endElement:"+m_node.getNodeName());
 213                         m_xDocumentHandler.endElement(m_node.getNodeName());
 214                         m_testTool.updatesUIs();
 215
 216                         Node nextNode = m_node.getNextSibling();
 217                         if (nextNode != null)
 218                         /*
 219                          * if the node has a next sibling, then the next event will be the
 220                          * start event for that sibling node.
 221                          */
 222                         {
 223                             m_node = nextNode;
 224                             m_bIsEndEvent = false;
 225                         }
 226                         else
 227                         /*
 228                          * otherwise, the next event will be the endElement for the node's
 229                          * parent node.
 230                          */
 231                         {
 232                             m_node = m_node.getParentNode();
 233                         }
 234                         break;
 235                 }
 236             }
 237         }
 238         catch(  com.sun.star.xml.sax.SAXException e)
 239         {
 240             e.printStackTrace();
 241
 242             /*
 243              * forces to end.
 244              */
 245             rc = false;
 246         }
 247
 248         return rc;
 249     }
 250 }
 251