1 /*
2  * Copyright (c) 2005, 2020, 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 package com.sun.xml.internal.stream.events;
26 
27 import com.sun.org.apache.xerces.internal.impl.PropertyManager;
28 import java.util.List;
29 import javax.xml.stream.util.XMLEventAllocator;
30 import javax.xml.stream.*;
31 import javax.xml.stream.events.*;
32 import javax.xml.XMLConstants;
33 import javax.xml.namespace.QName;
34 import com.sun.org.apache.xerces.internal.util.NamespaceContextWrapper;
35 import com.sun.org.apache.xerces.internal.util.NamespaceSupport;
36 import javax.xml.stream.util.XMLEventConsumer;
37 
38 /**
39  * Implementation of XMLEvent Allocator.
40  *
41  * @author Neeraj bajaj, k venugopal
42  */
43 public class XMLEventAllocatorImpl implements XMLEventAllocator {
44 
45     /**
46      * Creates a new instance of XMLEventAllocator
47      */
XMLEventAllocatorImpl()48     public XMLEventAllocatorImpl() {
49     }
50 
allocate(XMLStreamReader xMLStreamReader)51     public XMLEvent allocate(XMLStreamReader xMLStreamReader) throws XMLStreamException {
52         if (xMLStreamReader == null) {
53             throw new XMLStreamException("Reader cannot be null");
54         }
55         //        allocate is not supposed to change the state of the reader so we shouldn't be calling next.
56         //        return getNextEvent(xMLStreamReader);
57         return getXMLEvent(xMLStreamReader);
58     }
59 
allocate(XMLStreamReader xMLStreamReader, XMLEventConsumer xMLEventConsumer)60     public void allocate(XMLStreamReader xMLStreamReader, XMLEventConsumer xMLEventConsumer)
61             throws XMLStreamException {
62         XMLEvent currentEvent = getXMLEvent(xMLStreamReader);
63         if (currentEvent != null) {
64             xMLEventConsumer.add(currentEvent);
65         }
66 
67         return;
68     }
69 
newInstance()70     public javax.xml.stream.util.XMLEventAllocator newInstance() {
71         return new XMLEventAllocatorImpl();
72     }
73 
74     //REVISIT: shouldn't we be using XMLEventFactory to create events.
getXMLEvent(XMLStreamReader streamReader)75     XMLEvent getXMLEvent(XMLStreamReader streamReader) {
76         XMLEvent event = null;
77         //returns the current event
78         int eventType = streamReader.getEventType();
79         switch (eventType) {
80 
81             case XMLEvent.START_ELEMENT: {
82                 StartElementEvent startElementEvent = new StartElementEvent(getQName(streamReader));
83                 fillAttributes(startElementEvent, streamReader);
84                 //we might have different XMLStreamReader so check every time for
85                 //the namespace aware property. we should be setting namespace
86                 //related values only when isNamespaceAware is 'true'
87                 if (((Boolean) streamReader.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE))) {
88                     fillNamespaceAttributes(startElementEvent, streamReader);
89                     setNamespaceContext(startElementEvent, streamReader);
90                 }
91 
92                 startElementEvent.setLocation(streamReader.getLocation());
93                 event = startElementEvent;
94                 break;
95             }
96             case XMLEvent.END_ELEMENT: {
97                 EndElementEvent endElementEvent = new EndElementEvent(getQName(streamReader));
98                 endElementEvent.setLocation(streamReader.getLocation());
99 
100                 if (((Boolean) streamReader.getProperty(XMLInputFactory.IS_NAMESPACE_AWARE))) {
101                     fillNamespaceAttributes(endElementEvent, streamReader);
102                 }
103                 event = endElementEvent;
104                 break;
105             }
106             case XMLEvent.PROCESSING_INSTRUCTION: {
107                 ProcessingInstructionEvent piEvent = new ProcessingInstructionEvent(
108                         streamReader.getPITarget(), streamReader.getPIData());
109                 piEvent.setLocation(streamReader.getLocation());
110                 event = piEvent;
111                 break;
112             }
113             case XMLEvent.CHARACTERS: {
114                 CharacterEvent cDataEvent = new CharacterEvent(streamReader.getText());
115                 cDataEvent.setLocation(streamReader.getLocation());
116                 event = cDataEvent;
117                 break;
118             }
119             case XMLEvent.COMMENT: {
120                 CommentEvent commentEvent = new CommentEvent(streamReader.getText());
121                 commentEvent.setLocation(streamReader.getLocation());
122                 event = commentEvent;
123                 break;
124             }
125             case XMLEvent.START_DOCUMENT: {
126                 StartDocumentEvent sdEvent = new StartDocumentEvent();
127                 sdEvent.setVersion(streamReader.getVersion());
128                 sdEvent.setEncoding(streamReader.getEncoding());
129                 if (streamReader.getCharacterEncodingScheme() != null) {
130                     sdEvent.setDeclaredEncoding(true);
131                 } else {
132                     sdEvent.setDeclaredEncoding(false);
133                 }
134                 sdEvent.setStandalone(streamReader.isStandalone(), streamReader.standaloneSet());
135                 sdEvent.setLocation(streamReader.getLocation());
136                 event = sdEvent;
137                 break;
138             }
139             case XMLEvent.END_DOCUMENT: {
140                 EndDocumentEvent endDocumentEvent = new EndDocumentEvent();
141                 endDocumentEvent.setLocation(streamReader.getLocation());
142                 event = endDocumentEvent;
143                 break;
144             }
145             case XMLEvent.ENTITY_REFERENCE: {
146                 EntityReferenceEvent entityEvent = new EntityReferenceEvent(streamReader.getLocalName(),
147                         new EntityDeclarationImpl(streamReader.getLocalName(), streamReader.getText()));
148                 entityEvent.setLocation(streamReader.getLocation());
149                 event = entityEvent;
150                 break;
151 
152             }
153             case XMLEvent.ATTRIBUTE: {
154                 event = null;
155                 break;
156             }
157             case XMLEvent.DTD: {
158                 DTDEvent dtdEvent = new DTDEvent(streamReader.getText());
159                 dtdEvent.setLocation(streamReader.getLocation());
160                 @SuppressWarnings("unchecked")
161                 List<EntityDeclaration> entities = (List<EntityDeclaration>)
162                         streamReader.getProperty(PropertyManager.STAX_ENTITIES);
163                 if (entities != null && entities.size() != 0) {
164                     dtdEvent.setEntities(entities);
165                 }
166                 @SuppressWarnings("unchecked")
167                 List<NotationDeclaration> notations = (List<NotationDeclaration>)
168                         streamReader.getProperty(PropertyManager.STAX_NOTATIONS);
169                 if (notations != null && !notations.isEmpty()) {
170                     dtdEvent.setNotations(notations);
171                 }
172                 event = dtdEvent;
173                 break;
174             }
175             case XMLEvent.CDATA: {
176                 CharacterEvent cDataEvent = new CharacterEvent(streamReader.getText(), true);
177                 cDataEvent.setLocation(streamReader.getLocation());
178                 event = cDataEvent;
179                 break;
180             }
181             case XMLEvent.SPACE: {
182                 CharacterEvent spaceEvent = new CharacterEvent(streamReader.getText(), false, true);
183                 spaceEvent.setLocation(streamReader.getLocation());
184                 event = spaceEvent;
185                 break;
186             }
187         }
188         return event;
189     }
190 
191     //this function is not used..
getNextEvent(XMLStreamReader streamReader)192     protected XMLEvent getNextEvent(XMLStreamReader streamReader) throws XMLStreamException {
193         //advance the reader to next event.
194         streamReader.next();
195         return getXMLEvent(streamReader);
196     }
197 
fillAttributes(StartElementEvent event, XMLStreamReader xmlr)198     protected void fillAttributes(StartElementEvent event, XMLStreamReader xmlr) {
199 
200         int len = xmlr.getAttributeCount();
201         QName qname = null;
202         AttributeImpl attr = null;
203         NamespaceImpl nattr = null;
204         for (int i = 0; i < len; i++) {
205             qname = xmlr.getAttributeName(i);
206             //this method doesn't include namespace declarations
207             //so we can be sure that there wont be any namespace declaration as part of this function call
208             //we can avoid this check - nb.
209             /**
210              * prefix = qname.getPrefix(); localpart = qname.getLocalPart(); if
211              * (prefix.equals(XMLConstants.XMLNS_ATTRIBUTE) ) { attr = new
212              * NamespaceImpl(localpart,xmlr.getAttributeValue(i)); }else if
213              * (prefix.equals(XMLConstants.DEFAULT_NS_PREFIX)){ attr = new
214              * NamespaceImpl(xmlr.getAttributeValue(i)); }else{ attr = new
215              * AttributeImpl(); attr.setName(qname); }
216              *
217              */
218             attr = new AttributeImpl();
219             attr.setName(qname);
220             attr.setAttributeType(xmlr.getAttributeType(i));
221             attr.setSpecified(xmlr.isAttributeSpecified(i));
222             attr.setValue(xmlr.getAttributeValue(i));
223             event.addAttribute(attr);
224         }
225     }
226 
fillNamespaceAttributes(StartElementEvent event, XMLStreamReader xmlr)227     protected void fillNamespaceAttributes(StartElementEvent event, XMLStreamReader xmlr) {
228         int count = xmlr.getNamespaceCount();
229         String uri = null;
230         String prefix = null;
231         NamespaceImpl attr = null;
232         for (int i = 0; i < count; i++) {
233             uri = xmlr.getNamespaceURI(i);
234             prefix = xmlr.getNamespacePrefix(i);
235             if (prefix == null) {
236                 prefix = XMLConstants.DEFAULT_NS_PREFIX;
237             }
238             attr = new NamespaceImpl(prefix, uri);
239             event.addNamespaceAttribute(attr);
240         }
241     }
242 
fillNamespaceAttributes(EndElementEvent event, XMLStreamReader xmlr)243     protected void fillNamespaceAttributes(EndElementEvent event, XMLStreamReader xmlr) {
244         int count = xmlr.getNamespaceCount();
245         String uri = null;
246         String prefix = null;
247         NamespaceImpl attr = null;
248         for (int i = 0; i < count; i++) {
249             uri = xmlr.getNamespaceURI(i);
250             prefix = xmlr.getNamespacePrefix(i);
251             if (prefix == null) {
252                 prefix = XMLConstants.DEFAULT_NS_PREFIX;
253             }
254             attr = new NamespaceImpl(prefix, uri);
255             event.addNamespace(attr);
256         }
257     }
258 
259     //Revisit : Creating a new Namespacecontext for now.
260     //see if we can do better job.
setNamespaceContext(StartElementEvent event, XMLStreamReader xmlr)261     private void setNamespaceContext(StartElementEvent event, XMLStreamReader xmlr) {
262         NamespaceContextWrapper contextWrapper = (NamespaceContextWrapper) xmlr.getNamespaceContext();
263         NamespaceSupport ns = new NamespaceSupport(contextWrapper.getNamespaceContext());
264         event.setNamespaceContext(new NamespaceContextWrapper(ns));
265     }
266 
getQName(XMLStreamReader xmlr)267     private QName getQName(XMLStreamReader xmlr) {
268         return new QName(xmlr.getNamespaceURI(), xmlr.getLocalName(),
269                 xmlr.getPrefix());
270     }
271 }
272