| /** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.tuscany.sdo.util.resource; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.NoSuchElementException; |
| |
| import javax.xml.XMLConstants; |
| import javax.xml.namespace.NamespaceContext; |
| import javax.xml.namespace.QName; |
| import javax.xml.stream.Location; |
| import javax.xml.stream.XMLStreamException; |
| import javax.xml.stream.XMLStreamReader; |
| |
| import org.eclipse.emf.ecore.xmi.XMLResource; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.Locator; |
| |
| /** |
| * This special purpose XMLStreamReader is used to produce a StAX event stream corresponding to a list of events |
| * recorded earlier. The recorded events are generated by the inner class RecordedEventXMLStreamReader.Tag, |
| * which records the events in either of 2 ways: |
| * |
| * 1) in conjunction with class SDOXMLLoadImpl, it records events corresponding to the SAX events being |
| * handled by the SDOXMLLoadImpl when loading XML using SDOXMLResourceImpl. |
| * 2) when Tag.record() is called (see class ChangeSummaryStreamDeserializer), it walks through and records |
| * the StAX events produced by another XMLStreamReader. |
| * |
| * This class is used by the SDO StAX-based ChangeSummaryType-property loader, class |
| * ChangeSummaryStreamDeserializer, which is inoked by and uses (for loading deleted object XML fragments) |
| * the SAX-based loader class XMLResourceImpl. |
| */ |
| public abstract class RecordedEventXMLStreamReader implements XMLStreamReader { |
| |
| static private class Event { |
| int type; |
| |
| public NamespaceContext nameSpaceContext; |
| |
| Location location; |
| |
| protected final void initialize(XMLStreamReader reader) { |
| nameSpaceContext = reader.getNamespaceContext(); |
| location = reader.getLocation(); |
| } |
| |
| protected final void location(final Locator locator) { |
| location = new Location() { |
| public int getCharacterOffset() { |
| return -1; |
| } |
| |
| public int getColumnNumber() { |
| return locator.getColumnNumber(); |
| } |
| |
| public int getLineNumber() { |
| return locator.getLineNumber(); |
| } |
| |
| public String getPublicId() { |
| return locator.getPublicId(); |
| } |
| |
| public String getSystemId() { |
| return locator.getSystemId(); |
| } |
| }; |
| } |
| } |
| |
| static class ValueEvent extends Event { |
| final String value; |
| |
| protected ValueEvent(String v) { |
| value = v; |
| } |
| } |
| |
| static protected class Reference extends ValueEvent { |
| final String target; |
| |
| protected Reference(String name, String data) { |
| super(data); |
| target = name; |
| } |
| } |
| |
| static protected final class AttributeEvent extends Reference { |
| final QName name; |
| |
| final String nameSpace, prefix; |
| |
| int attributes; |
| |
| final boolean specified; |
| |
| protected AttributeEvent(XMLStreamReader reader) { |
| super(reader.getAttributeType(0), reader.getAttributeValue(0)); |
| attributes = reader.getAttributeCount(); |
| name = reader.getAttributeName(0); |
| nameSpace = reader.getAttributeNamespace(0); |
| prefix = reader.getAttributePrefix(0); |
| specified = reader.isAttributeSpecified(0); |
| } |
| } |
| |
| static protected final class NameSpaceEvent extends Reference { |
| int nameSpaces; |
| |
| protected NameSpaceEvent(XMLStreamReader reader) { |
| super(reader.getNamespacePrefix(0), reader.getNamespaceURI(0)); |
| nameSpaces = reader.getNamespaceCount(); |
| } |
| } |
| |
| static protected String prefix(String qName, String nameSpace) { |
| int delimiter = qName.indexOf(':'); |
| if (delimiter != -1) |
| return qName.substring(0, delimiter); |
| if (nameSpace.length() != 0) |
| return XMLConstants.DEFAULT_NS_PREFIX; |
| // if (nameSpaceContext.getNamespaceURI(XMLConstants.DEFAULT_NS_PREFIX) != null || xsdHelper.getGlobalProperty(null, name, element) == null) |
| return null; |
| } |
| |
| static class EndElement extends Event { |
| List nameSpaces/* = null */; |
| |
| public final QName name; |
| |
| public final String nameSpace; |
| |
| final String prefix; |
| |
| protected EndElement(XMLStreamReader reader) { |
| name = reader.getName(); |
| nameSpace = reader.getNamespaceURI(); |
| prefix = reader.getPrefix(); |
| int count = reader.getNamespaceCount(); |
| if (count == 0) |
| return; |
| nameSpaces = new ArrayList(count); |
| int index = 0; |
| do |
| Tag.bind(reader.getNamespacePrefix(index), reader.getNamespaceURI(index), nameSpaces); |
| while (++index != count); |
| } |
| |
| protected EndElement(String uri, String local, String p, Locator locator) { |
| if (p == null) { |
| name = new QName(uri, local, XMLConstants.DEFAULT_NS_PREFIX); |
| nameSpace = null; |
| } else { |
| name = new QName(uri, local, p); |
| nameSpace = uri; |
| } |
| prefix = p; |
| location(locator); |
| } |
| } |
| |
| static class NameSpace { |
| final String prefix, uri; |
| |
| protected NameSpace(String p, String nameSpace) { |
| prefix = p; |
| uri = nameSpace; |
| } |
| } |
| |
| static final class Attribute extends NameSpace { |
| final String type, value; |
| |
| final QName qName; |
| |
| boolean specified/* = false */; |
| |
| protected Attribute(String t, String v, QName name, String prefix, String nameSpace) { |
| super(prefix, nameSpace); |
| type = t; |
| value = v; |
| qName = name; |
| } |
| } |
| |
| static final class AttributeList /* implements Attributes */{// TODO exclude XMLConstants.XMLNS_ATTRIBUTE |
| final List attributes; |
| |
| protected AttributeList(int size) { |
| attributes = new ArrayList(size); |
| } |
| |
| /* |
| * @param uri Never null |
| */ |
| public final int getIndex(String uri, String localName) { |
| for (int index = getLength(); index != 0;) |
| if (getLocalName(--index).equals(localName) && uri.equals(getURI(index))) |
| return index; |
| return -1; |
| } |
| |
| public final int getLength() { |
| return attributes.size(); |
| } |
| |
| protected final Attribute attribute(int index) { |
| return (Attribute) attributes.get(index); |
| } |
| |
| public final String getLocalName(int index) { |
| return attribute(index).qName.getLocalPart(); |
| } |
| |
| public final String getType(int index) { |
| return attribute(index).type; |
| } |
| |
| /*public String getType(String uri, String localName) { |
| int index = getIndex(uri, localName); |
| return index == -1 ? null: getType(index); |
| } */ |
| |
| public final String getURI(int index) { |
| return attribute(index).uri; |
| } |
| |
| public final String getValue(int index) { |
| return attribute(index).value; |
| } |
| |
| /* |
| * @param uri Never null |
| */ |
| public final String getValue(String uri, String localName) { |
| int index = getIndex(uri, localName); |
| return index == -1 ? null : getValue(index); |
| } |
| } |
| |
| static protected class StartElement extends EndElement { |
| final AttributeList attributes; |
| |
| protected StartElement(XMLStreamReader reader) { |
| super(reader); |
| int count = reader.getAttributeCount(); |
| if (count == 0) |
| attributes = null; |
| else { |
| attributes = new AttributeList(count); |
| int index = 0; |
| do { |
| Attribute attribute = new Attribute(reader.getAttributeType(index), reader.getAttributeValue(index), reader |
| .getAttributeName(index), reader.getAttributePrefix(index), reader.getAttributeNamespace(index)); |
| attribute.specified = reader.isAttributeSpecified(index); |
| attributes.attributes.add(attribute); |
| } while (++index != count); |
| } |
| } |
| |
| protected StartElement(String nameSpace, String local, String prefix, Attributes attributeArray, Locator locator, List bindings, |
| final NamespaceContext context) { |
| super(nameSpace, local, prefix, locator); |
| nameSpaces = bindings; |
| nameSpaceContext = bindings == null || bindings.isEmpty() ? context : new NamespaceContext() { |
| public String getNamespaceURI(String prefix) { |
| for (int index = nameSpaces.size(); index != 0;) { |
| NameSpace binding = (NameSpace) nameSpaces.get(--index); |
| if (binding.prefix.equals(prefix)) |
| return binding.uri; |
| } |
| return context.getNamespaceURI(prefix); |
| } |
| |
| public String getPrefix(String namespaceURI) { |
| for (int index = nameSpaces.size(); index != 0;) { |
| NameSpace binding = (NameSpace) nameSpaces.get(--index); |
| if (binding.uri.equals(namespaceURI)) |
| return binding.prefix; |
| } |
| return context.getPrefix(namespaceURI); |
| } |
| |
| public Iterator getPrefixes(final String namespaceURI) { |
| final Iterator iterator = context.getPrefixes(namespaceURI); |
| return new Iterator() { |
| Iterator bindings = nameSpaces.iterator(); |
| |
| NameSpace binding/* = null */; |
| |
| protected final boolean prefix() { |
| while (bindings.hasNext()) { |
| binding = (NameSpace) bindings.next(); |
| if (binding.uri.equals(namespaceURI)) |
| return true; |
| } |
| bindings = null; |
| return false; |
| } |
| |
| public boolean hasNext() { |
| return bindings != null && prefix() || iterator.hasNext(); |
| } |
| |
| protected NameSpace nameSpace; |
| |
| public Object next() { |
| if (bindings == null || binding == null && !prefix()) |
| return iterator.next(); |
| nameSpace = binding; |
| binding = null; |
| return nameSpace.prefix; |
| } |
| |
| public void remove() { |
| if (bindings == null) |
| iterator.remove(); |
| else |
| nameSpaces.remove(nameSpace); |
| } |
| }; |
| } |
| }; |
| int count = attributeArray.getLength(); |
| if (count == 0) |
| attributes = null; |
| else { |
| attributes = new AttributeList(count); |
| int index = 0; |
| do { |
| QName name; |
| nameSpace = attributeArray.getURI(index); |
| local = attributeArray.getLocalName(index); |
| prefix = prefix(attributeArray.getQName(index), nameSpace); |
| if (prefix == null) { |
| name = new QName(nameSpace, local, XMLConstants.DEFAULT_NS_PREFIX); |
| nameSpace = null; |
| } else |
| name = new QName(nameSpace, local, prefix); |
| attributes.attributes.add(new Attribute(attributeArray.getType(index), attributeArray.getValue(index), name, prefix, nameSpace)); |
| } while (++index != count); |
| } |
| } |
| } |
| |
| static public class Tag extends StartElement { |
| public Tag(XMLStreamReader reader) { |
| super(reader); |
| initialize(reader); |
| } |
| |
| public List events/* = null */; // may be empty |
| |
| protected final void events() { |
| events = new ArrayList(); |
| } |
| |
| public Tag(String nameSpace, String local, String prefix, Attributes attributes, Locator locator, NamespaceContext context, List bindings) { |
| super(nameSpace, local, prefix, attributes, locator, bindings, context); |
| events(); |
| } |
| |
| static public void bind(String prefix, String nameSpace, Collection nameSpaces) { |
| nameSpaces.add(new NameSpace(prefix, nameSpace)); |
| } |
| |
| protected int nest/* = 0 */; |
| |
| public final void start(String nameSpace, String local, String qName, Attributes attributes, Locator locator, List bindings) { |
| Event event; |
| for (int index = events.size();/* true */;) { |
| if (index == 0) { |
| event = this; |
| break; |
| } |
| event = (Event) events.get(--index); |
| if (event.type != END_ELEMENT) |
| break; |
| siblings: for (int nest = 0;/* true */;) |
| switch (((Event) events.get(--index)).type) { |
| case START_ELEMENT: |
| if (nest == 0) |
| break siblings; |
| --nest; |
| break; |
| case END_ELEMENT: |
| ++nest; |
| } |
| } |
| Event start = new StartElement(nameSpace, local, prefix(qName, nameSpace), attributes, locator, bindings, event.nameSpaceContext); |
| start.type = START_ELEMENT; |
| events.add(start); |
| ++nest; |
| } |
| |
| protected final void add (Event event) |
| { |
| int index = events.size(); |
| event.nameSpaceContext = index == 0 ? nameSpaceContext : ((Event) events.get(--index)).nameSpaceContext; |
| events.add(event); |
| } |
| |
| public final void text(int type, String value, Locator locator) { |
| Event event = new ValueEvent(value); |
| event.type = type; |
| event.location(locator); |
| //int index = events.size(); |
| add(event); |
| } |
| |
| public final boolean end(String nameSpace, String local, String qName, Locator locator) { |
| Event end = new EndElement(nameSpace, local, prefix(qName, nameSpace), locator); |
| end.type = END_ELEMENT; |
| add(end); |
| if (nest == 0) |
| return true; |
| --nest; |
| return false; |
| } |
| |
| public final XMLStreamReader play(final XMLResource resource) { |
| return new RecordedEventXMLStreamReader(this) { |
| public void close() { |
| } |
| |
| public String getCharacterEncodingScheme() { |
| return null; // TODO |
| } |
| |
| public String getEncoding() { |
| return resource.getEncoding(); |
| } |
| |
| public Object getProperty(String property) { |
| return null; // TODO javax.xml.stream.notations & javax.xml.stream.entities for DTD |
| } |
| |
| public String getVersion() { |
| return resource.getXMLVersion(); |
| } |
| |
| public boolean isStandalone() { |
| return false; // TODO |
| } |
| |
| public boolean standaloneSet() { |
| return false; // TODO |
| } |
| }; |
| } |
| |
| protected final void add(Event event, int type, XMLStreamReader reader) { |
| event.type = type; |
| event.initialize(reader); |
| events.add(event); |
| } |
| |
| public final boolean record(XMLStreamReader reader) throws XMLStreamException { |
| events(); |
| for (int nest = 0; reader.hasNext();) { |
| Event event; |
| int type = reader.next(); |
| switch (type) { |
| case CHARACTERS: |
| case CDATA: |
| case COMMENT: |
| case SPACE: |
| case DTD: |
| event = new ValueEvent(reader.getText()); |
| break; |
| case ENTITY_REFERENCE: |
| event = new Reference(reader.getLocalName(), reader.getText()); |
| break; |
| case PROCESSING_INSTRUCTION: |
| event = new Reference(reader.getPITarget(), reader.getPIData()); |
| break; |
| case ATTRIBUTE: |
| event = new AttributeEvent(reader); |
| break; |
| case NAMESPACE: |
| event = new NameSpaceEvent(reader); |
| break; |
| case START_ELEMENT: |
| ++nest; |
| event = new StartElement(reader); |
| break; |
| case END_ELEMENT: |
| add(new EndElement(reader), type, reader); |
| if (nest == 0) |
| return false; |
| --nest; |
| continue; |
| case END_DOCUMENT: |
| return true; // report error? |
| default: // new type |
| event = new Event(); |
| } |
| add(event, type, reader); |
| } |
| return true; // report error? |
| } |
| |
| public final XMLStreamReader play(final XMLStreamReader reader) { |
| return new RecordedEventXMLStreamReader(this) { |
| public void close() throws XMLStreamException { |
| reader.close(); |
| } |
| |
| public String getCharacterEncodingScheme() { |
| return reader.getCharacterEncodingScheme(); |
| } |
| |
| public String getEncoding() { |
| return reader.getEncoding(); |
| } |
| |
| public Object getProperty(String property) { |
| return reader.getProperty(property); // TODO javax.xml.stream.notations & javax.xml.stream.entities for DTD |
| } |
| |
| public String getVersion() { |
| return reader.getVersion(); |
| } |
| |
| public boolean isStandalone() { |
| return reader.isStandalone(); |
| } |
| |
| public boolean standaloneSet() { |
| return reader.standaloneSet(); |
| } |
| }; |
| } |
| } |
| |
| Event event; |
| |
| final List events; |
| |
| final int size; |
| |
| protected RecordedEventXMLStreamReader(Tag tag) { |
| event = tag; |
| tag.type = START_ELEMENT; |
| events = tag.events; |
| size = events.size(); |
| } |
| |
| public int getAttributeCount() { |
| switch (getEventType()) { |
| case START_ELEMENT: |
| AttributeList attributes = ((StartElement) event).attributes; |
| return attributes == null ? 0 : attributes.getLength(); |
| case ATTRIBUTE: |
| return ((AttributeEvent) event).attributes; |
| } |
| throw new IllegalStateException("Neither START_ELEMENT nor ATTRIBUTE"); |
| } |
| |
| protected final AttributeList attributes() { |
| if (getEventType() == START_ELEMENT) |
| return ((StartElement) event).attributes; |
| throw new IllegalStateException("Neither START_ELEMENT nor ATTRIBUTE"); |
| } |
| |
| public String getAttributeLocalName(int index) { |
| return attributes().getLocalName(index); |
| } |
| |
| static Attribute attribute(AttributeList attributes, int index) { |
| return (Attribute) attributes.attributes.get(index); |
| } |
| |
| public QName getAttributeName(int index) { |
| return getEventType() == ATTRIBUTE ? ((AttributeEvent) event).name : attribute(attributes(), index).qName; |
| } |
| |
| public String getAttributeNamespace(int index) { |
| return getEventType() == ATTRIBUTE ? ((AttributeEvent) event).nameSpace : attributes().getURI(index); |
| } |
| |
| public String getAttributePrefix(int index) { |
| return getEventType() == ATTRIBUTE ? ((AttributeEvent) event).prefix : attribute(attributes(), index).prefix; |
| } |
| |
| public String getAttributeType(int index) { |
| return getEventType() == ATTRIBUTE ? ((Reference) event).target : attributes().getType(index); |
| } |
| |
| public String getAttributeValue(int index) { |
| return getEventType() == ATTRIBUTE ? ((ValueEvent) event).value : attributes().getValue(index); |
| } |
| |
| public boolean isAttributeSpecified(int index) { |
| if (getEventType() == ATTRIBUTE) |
| return ((AttributeEvent) event).specified; |
| AttributeList attributes = attributes(); |
| return attribute(attributes, index).specified; |
| } |
| |
| public String getAttributeValue(String nameSpace, String name) { |
| if (getEventType() == ATTRIBUTE) { |
| AttributeEvent attribute = (AttributeEvent) event; |
| return !attribute.name.getLocalPart().equals(name) ? null : nameSpace == null ? (attribute.nameSpace == null ? attribute.value : null) |
| : nameSpace.equals(attribute.nameSpace) ? attribute.value : null; |
| } |
| AttributeList attributes = attributes(); |
| return attributes == null ? null : attributes.getValue(nameSpace == null ? "" : nameSpace, name); |
| } |
| |
| protected StringBuffer buffer/* = null */; |
| |
| public String getElementText() { |
| if (buffer != null) |
| buffer.delete(0, buffer.length()); |
| for (;;) |
| switch (next()) { |
| case END_ELEMENT: |
| return buffer == null ? null : buffer.toString(); |
| default: |
| if (buffer == null) |
| buffer = new StringBuffer(); |
| buffer.append(getText()); |
| case PROCESSING_INSTRUCTION: |
| case COMMENT: |
| } |
| } |
| |
| public final int getEventType() { |
| return event.type; |
| } |
| |
| public String getLocalName() { |
| if (getEventType() == ENTITY_REFERENCE) |
| return ((Reference) event).target; |
| if (event instanceof EndElement) |
| return ((EndElement) event).name.getLocalPart(); |
| throw new IllegalStateException("Neither START_ELEMENT, END_ELEMENT nor ENTITY_REFERENCE"); |
| } |
| |
| public final Location getLocation() { |
| return event.location; |
| } |
| |
| public QName getName() { |
| if (hasName()) |
| return ((EndElement) event).name; |
| throw new IllegalStateException("Neither START_ELEMENT nor END_ELEMENT"); |
| } |
| |
| public final NamespaceContext getNamespaceContext() { |
| return event.nameSpaceContext; |
| } |
| |
| public int getNamespaceCount() { |
| if (getEventType() == NAMESPACE) |
| return ((NameSpaceEvent) event).nameSpaces; |
| if (!(event instanceof EndElement)) |
| throw new IllegalStateException("Neither START_ELEMENT, END_ELEMENT nor NAMESPACE"); |
| Collection nameSpaces = ((EndElement) event).nameSpaces; |
| return nameSpaces == null ? 0 : nameSpaces.size(); |
| } |
| |
| protected final NameSpace getNameSpace(int index) { |
| if (event instanceof EndElement) |
| return (NameSpace) ((EndElement) event).nameSpaces.get(index); |
| throw new IllegalStateException("Neither START_ELEMENT, END_ELEMENT nor NAMESPACE"); |
| } |
| |
| public String getNamespacePrefix(int index) { |
| return getEventType() == NAMESPACE ? ((Reference) event).target : getNameSpace(index).prefix; |
| } |
| |
| public final String getNamespaceURI() { |
| switch (getEventType()) { |
| case ATTRIBUTE: |
| return ((AttributeEvent) event).nameSpace; |
| case NAMESPACE: |
| return ((ValueEvent) event).value; |
| } |
| return event instanceof EndElement ? ((EndElement) event).nameSpace : null; |
| } |
| |
| public String getNamespaceURI(String prefix) { |
| return getNamespaceContext().getNamespaceURI(prefix); |
| } |
| |
| public String getNamespaceURI(int index) { |
| return getEventType() == NAMESPACE ? ((ValueEvent) event).value : getNameSpace(index).uri; |
| } |
| |
| public String getPIData() { |
| return getEventType() == PROCESSING_INSTRUCTION ? ((ValueEvent) event).value : null; |
| } |
| |
| public String getPITarget() { |
| return getEventType() == PROCESSING_INSTRUCTION ? ((Reference) event).target : null; |
| } |
| |
| public String getPrefix() { |
| switch (getEventType()) { |
| case ATTRIBUTE: |
| return ((AttributeEvent) event).prefix; |
| case NAMESPACE: |
| return ((Reference) event).target; |
| } |
| return event instanceof EndElement ? ((EndElement) event).prefix : null; |
| } |
| |
| public final String getText() { |
| if (hasText()) |
| return ((ValueEvent) event).value; |
| throw new IllegalStateException("Neither CHARACTERS, CDATA, COMMENT, SPACE, ENTITY_REFERENCE nor DTD"); |
| } |
| |
| public final char[] getTextCharacters() { |
| switch (getEventType()) { |
| case CHARACTERS: |
| case CDATA: |
| case COMMENT: |
| case SPACE: |
| return ((ValueEvent) event).value.toCharArray(); |
| } |
| throw new IllegalStateException("Neither CHARACTERS, CDATA, COMMENT nor SPACE"); |
| } |
| |
| public int getTextCharacters(int sourceStart, char[] target, int targetStart, int length) { |
| char[] source = getTextCharacters(); |
| if (sourceStart > source.length) |
| throw new IndexOutOfBoundsException("source start > source length"); |
| int sourceLen = source.length - sourceStart; |
| if (length > sourceLen) |
| length = sourceLen; |
| System.arraycopy(source, sourceStart, target, targetStart, length); |
| return sourceLen; |
| } |
| |
| public int getTextLength() { |
| return getTextCharacters().length; |
| } |
| |
| public int getTextStart() { |
| return 0; |
| } |
| |
| public final boolean hasName() { |
| return event instanceof EndElement; |
| } |
| |
| protected int next/* = 0 */; |
| |
| public final boolean hasNext() { |
| return next != size; |
| } |
| |
| public final boolean hasText() { |
| switch (getEventType()) { |
| case CHARACTERS: |
| case CDATA: |
| case COMMENT: |
| case SPACE: |
| case ENTITY_REFERENCE: |
| case DTD: |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean isCharacters() { |
| switch (getEventType()) { |
| case CHARACTERS: |
| case CDATA: |
| case SPACE: |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean isEndElement() { |
| return getEventType() == END_ELEMENT; |
| } |
| |
| public boolean isStartElement() { |
| return getEventType() == START_ELEMENT; |
| } |
| |
| protected final boolean areWhiteSpace() { |
| String text = getText(); |
| for (int index = text.length(); index != 0;) |
| if (!Character.isWhitespace(text.charAt(--index))) |
| return false; |
| return true; |
| } |
| |
| public boolean isWhiteSpace() { |
| switch (getEventType()) { |
| case CHARACTERS: |
| case CDATA: |
| return areWhiteSpace(); |
| case SPACE: |
| return true; |
| } |
| return false; |
| } |
| |
| public final int next() { |
| if (!hasNext()) |
| throw new NoSuchElementException(); |
| event = (Event) events.get(next++); |
| return event.type; |
| } |
| |
| protected final void throwXMLStreamException(String message) throws XMLStreamException { |
| throw new XMLStreamException(message, getLocation()); |
| } |
| |
| public int nextTag() throws XMLStreamException { |
| for (;;) { |
| int type = next(); |
| switch (type) { |
| case CHARACTERS: |
| case CDATA: |
| if (!areWhiteSpace()) |
| break; |
| case SPACE: |
| case PROCESSING_INSTRUCTION: |
| case COMMENT: |
| continue; |
| case START_ELEMENT: |
| case END_ELEMENT: |
| return type; |
| } |
| throwXMLStreamException("expected start or end tag"); |
| } |
| } |
| |
| public void require(int type, String nameSpace, String name) throws XMLStreamException { |
| if (getEventType() != type) |
| throwXMLStreamException("type not matched"); |
| if (nameSpace != null && !nameSpace.equals(getNamespaceURI())) |
| throwXMLStreamException("Name Space not matched"); |
| if (name != null |
| && !(getEventType() == ATTRIBUTE ? name.equals(((AttributeEvent) event).name.getLocalPart()) : event instanceof EndElement |
| && name.equals(((EndElement) event).name.getLocalPart()))) |
| throwXMLStreamException("name not matched"); |
| } |
| } |