From 5d2e096f06d6cac9ed6ee18ad1cf716a09adc2b0 Mon Sep 17 00:00:00 2001 From: lresende Date: Thu, 30 Oct 2008 00:14:15 +0000 Subject: TUSCANY-2629 and TUSCANY-2624 - Enhancments to processor that handles unknown elements git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@709052 13f79535-47bb-0310-9956-ffa450edef68 --- .../processor/xml/AnyElementProcessor.java | 329 ++++---------- .../processor/xml/XMLDocumentStreamReader.java | 482 +++++++++++++++++++++ .../processor/xml/XMLEventsStreamReader.java | 448 +++++++++++++++++++ .../processor/xml/XMLFragmentStreamReader.java | 53 +++ 4 files changed, 1073 insertions(+), 239 deletions(-) create mode 100644 branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLDocumentStreamReader.java create mode 100644 branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLEventsStreamReader.java create mode 100644 branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLFragmentStreamReader.java (limited to 'branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache') diff --git a/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/AnyElementProcessor.java b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/AnyElementProcessor.java index 66bea7a4dd..e034cb1ecf 100644 --- a/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/AnyElementProcessor.java +++ b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/AnyElementProcessor.java @@ -22,17 +22,22 @@ import static javax.xml.stream.XMLStreamConstants.END_ELEMENT; import static javax.xml.stream.XMLStreamConstants.START_ELEMENT; import java.util.ArrayList; -import java.util.logging.Level; -import java.util.logging.Logger; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Stack; +import javax.xml.namespace.NamespaceContext; import javax.xml.namespace.QName; -import javax.xml.parsers.DocumentBuilderFactory; -import javax.xml.parsers.ParserConfigurationException; +import javax.xml.stream.XMLEventReader; +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamConstants; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamReader; import javax.xml.stream.XMLStreamWriter; +import javax.xml.stream.events.XMLEvent; -import org.apache.tuscany.sca.assembly.builder.impl.ProblemImpl; import org.apache.tuscany.sca.contribution.Constants; import org.apache.tuscany.sca.contribution.ModelFactoryExtensionPoint; import org.apache.tuscany.sca.contribution.processor.StAXArtifactProcessor; @@ -40,272 +45,118 @@ import org.apache.tuscany.sca.contribution.resolver.ModelResolver; import org.apache.tuscany.sca.contribution.service.ContributionReadException; import org.apache.tuscany.sca.contribution.service.ContributionResolveException; import org.apache.tuscany.sca.monitor.Monitor; -import org.apache.tuscany.sca.monitor.Problem; -import org.apache.tuscany.sca.monitor.Problem.Severity; -import org.w3c.dom.Document; -import org.w3c.dom.Element; -import org.w3c.dom.NamedNodeMap; -import org.w3c.dom.Node; -import org.w3c.dom.traversal.DocumentTraversal; -import org.w3c.dom.traversal.NodeFilter; -import org.w3c.dom.traversal.NodeIterator; -import org.w3c.dom.traversal.TreeWalker; +import org.apache.tuscany.sca.contribution.processor.xml.XMLEventsStreamReader; public class AnyElementProcessor implements StAXArtifactProcessor { - private static final QName ANY_ELEMENT = new QName(Constants.XMLSCHEMA_NS, "anyElement"); - - private static final Logger logger = Logger.getLogger(AnyElementProcessor.class.getName()); - private DocumentBuilderFactory documentBuilderFactory; - private Document document; + private static final QName ANY_ELEMENT = new QName(Constants.XMLSCHEMA_NS, + "anyElement"); + + private XMLInputFactory xmlInputFactory; + @SuppressWarnings("unused") private Monitor monitor; - - public AnyElementProcessor(ModelFactoryExtensionPoint modelFactories, Monitor monitor) { - documentBuilderFactory = modelFactories.getFactory(DocumentBuilderFactory.class); + //Map map = new HashMap(); + + public AnyElementProcessor(ModelFactoryExtensionPoint modelFactories, + Monitor monitor) { + xmlInputFactory = modelFactories.getFactory(XMLInputFactory.class); this.monitor = monitor; } - - public QName getArtifactType() { - return ANY_ELEMENT; - } + public QName getArtifactType() { + return ANY_ELEMENT; + } + + public Class getModelType() { + return Object.class; + } - public Class getModelType() { - return Object.class; - } - /** - * Reads the contetns of the unknown elements and generates the DOM + * Reads the contetns of the unknown elements and generates a custom + * implementation of XMLStreamReader i.e. XMLEventsStreamReader + * * @param reader - * @param name * @return * @throws XMLStreamException */ - public Object read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException { - - int event = reader.getEventType(); - int level = 0; - ArrayList elementList = new ArrayList(); - document = createDocument(); - - QName name = reader.getName(); - - while(reader.hasNext()){ - switch(event){ - case START_ELEMENT: - elementList.add(reader.getName().getLocalPart()); - if(level == 0){ - generateDOM(reader,null); - level++; - } - else{ - generateDOM(reader,elementList.get(elementList.size()-2).toString()); - } - - break; - case END_ELEMENT: - elementList.remove(reader.getName().getLocalPart()); - } - if(reader.hasNext()){ - event = reader.next(); - } - - if(event == START_ELEMENT || event == END_ELEMENT){ - if(reader.getName().equals(name)){ - break; - } - } - } - return document; - } + @SuppressWarnings("unchecked") + public Object read(XMLStreamReader reader) throws ContributionReadException, XMLStreamException { - /** - * Writes unknown portions back to the writer - * @param model - * @param writer - */ - public void write(Object model, XMLStreamWriter writer) { + //Custom variables + String currentElement = null; + List eventsList = new ArrayList(); - if( ! (model instanceof Document)) { - return; - } + Map eventContext = new HashMap(); - Document doc = (Document)model; try{ - DocumentTraversal traversal = (DocumentTraversal)doc; - TreeWalker walker = traversal.createTreeWalker(doc.getDocumentElement(),NodeFilter.SHOW_ALL, null, true); - writeDOM(walker,writer); - } - catch(Exception e){ - if (logger.isLoggable(Level.SEVERE)) { - logger.log(Level.SEVERE, "Document not created "); - } - error("Document not created",document,e); - } - } - - public void resolve(Object arg0, ModelResolver arg1) throws ContributionResolveException { - - } - - /** - * Method to generate the DOM - * @param reader - * @param parent - * @throws Exception - */ - //private void generateDOM(String elementText, String parent) { - private void generateDOM(XMLStreamReader reader, String parent) { - try{ - String elePrefix = reader.getPrefix(); - String eleQName = reader.getLocalName(); - if (elePrefix != null && elePrefix.length() != 0) { - eleQName = elePrefix + ":" + eleQName; - } + //Cast the block of unknown elements into document + XMLDocumentStreamReader docReader = new XMLDocumentStreamReader(reader); + + XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(docReader); - Element element = document.createElementNS(reader.getNamespaceURI(), eleQName); + while (xmlEventReader.hasNext()) { + XMLEvent event = xmlEventReader.nextEvent(); - int attributeCount = reader.getAttributeCount(); - for(int i = 0;i < attributeCount;i++){ - String ns = reader.getAttributeNamespace(i); - String prefix = reader.getAttributePrefix(i); - String qname = reader.getAttributeLocalName(i); - String value = reader.getAttributeValue(i); - if (prefix != null && prefix.length() != 0) { - qname = prefix + ":" + qname; - } - element.setAttributeNS(ns,qname,value); - } - if(parent == null){ - if(document != null){ - document.appendChild(element); + //Populate the eventContext map with the current element's name and corresponding NamesapceContext + if (currentElement != null && !(eventContext.containsKey(currentElement))) { + eventContext.put(currentElement, reader.getNamespaceContext()); } - else{ - if (logger.isLoggable(Level.SEVERE)) { - logger.log(Level.SEVERE, "Document not created "); - } - error("Document not created",document,element); - } - } - else{ - Node parentNode = getParentNode(document,parent); - if(parentNode != null){ - parentNode.appendChild(element); + + //Populate the list with the XMLEvents + eventsList.add(event); + if (event.isStartElement()) { + currentElement = reader.getName().getLocalPart(); } - else{ - if (logger.isLoggable(Level.SEVERE)) { - logger.log(Level.SEVERE, "Parent node not found"); - } - error("Parent node not found",document,parentNode.getNodeName()); + if (event.isEndDocument()) { + return new XMLEventsStreamReader(eventsList, eventContext); } } } catch(Exception e){ e.printStackTrace(); - if (logger.isLoggable(Level.SEVERE)) { - logger.log(Level.SEVERE, "Document not created "); - } - error("Document not created",document,e); } + return null; } /** - * Method to create an empty document - * @return - */ - private Document createDocument() { - try { - document = documentBuilderFactory.newDocumentBuilder().newDocument(); - return document; - } catch (ParserConfigurationException e) { - e.printStackTrace(); - } - return null; - } - - /** - * Method to traverse the DOM structure and write the elements - * @param walker + * Writes unknown portions back to the writer + * + * @param model * @param writer - * @throws XMLStreamException */ - private void writeDOM(TreeWalker walker,XMLStreamWriter writer) throws XMLStreamException { - - Node parent = walker.getCurrentNode(); - - writer.writeStartElement(parent.getPrefix(), parent.getLocalName(), parent.getNamespaceURI()); - - NamedNodeMap attributes = parent.getAttributes(); - - for(int i = 0;i. It's used wrap a XMLStreamReader to + * create a XMLStreamReader representing a document and it will produce + * START_DOCUMENT, END_DOCUMENT events. + * + * @version $Rev: 659153 $ $Date: 2008-05-22 09:43:58 -0700 (Thu, 22 May 2008) $ + */ +public class XMLDocumentStreamReader implements XMLStreamReader { + private static final int STATE_COMPLETE_AT_NEXT = 2; // The wrapper + // will produce + // END_DOCUMENT + + private static final int STATE_COMPLETED = 3; // Done + + private static final int STATE_INIT = 0; // The wrapper will produce + // START_DOCUMENT + + private static final int STATE_SWITCHED = 1; // The real reader will + // produce events + + private XMLStreamReader realReader; + private boolean fragment; + private int level = 0; + + private int state = STATE_INIT; + + public XMLDocumentStreamReader(XMLStreamReader realReader) { + if (realReader == null) { + throw new UnsupportedOperationException("Reader cannot be null"); + } + + this.realReader = realReader; + + if (realReader instanceof XMLFragmentStreamReader) { + ((XMLFragmentStreamReader)realReader).init(); + } + + // If the real reader is positioned at START_DOCUMENT, always use + // the real reader + if (realReader.getEventType() == START_DOCUMENT) { + fragment = false; + state = STATE_SWITCHED; + } + } + + public void close() throws XMLStreamException { + realReader.close(); + } + + public int getAttributeCount() { + if (isDelegating()) { + return realReader.getAttributeCount(); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributeLocalName(int i) { + if (isDelegating()) { + return realReader.getAttributeLocalName(i); + } else { + throw new IllegalStateException(); + } + } + + public QName getAttributeName(int i) { + if (isDelegating()) { + return realReader.getAttributeName(i); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributeNamespace(int i) { + if (isDelegating()) { + return realReader.getAttributeNamespace(i); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributePrefix(int i) { + if (isDelegating()) { + return realReader.getAttributePrefix(i); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributeType(int i) { + if (isDelegating()) { + return realReader.getAttributeType(i); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributeValue(int i) { + if (isDelegating()) { + return realReader.getAttributeValue(i); + } else { + throw new IllegalStateException(); + } + } + + public String getAttributeValue(String s, String s1) { + if (isDelegating()) { + return realReader.getAttributeValue(s, s1); + } else { + throw new IllegalStateException(); + } + } + + public String getCharacterEncodingScheme() { + return realReader.getCharacterEncodingScheme(); + } + + public String getElementText() throws XMLStreamException { + if (isDelegating()) { + return realReader.getElementText(); + } else { + throw new XMLStreamException(); + } + } + + public String getEncoding() { + return realReader.getEncoding(); + } + + public int getEventType() { + int event = -1; + switch (state) { + case STATE_SWITCHED: + case STATE_COMPLETE_AT_NEXT: + event = realReader.getEventType(); + break; + case STATE_INIT: + event = START_DOCUMENT; + break; + case STATE_COMPLETED: + event = END_DOCUMENT; + break; + } + return event; + } + + public String getLocalName() { + if (isDelegating()) { + return realReader.getLocalName(); + } else { + throw new IllegalStateException(); + } + } + + public Location getLocation() { + if (isDelegating()) { + return realReader.getLocation(); + } else { + return null; + } + } + + public QName getName() { + if (isDelegating()) { + return realReader.getName(); + } else { + throw new IllegalStateException(); + } + } + + public NamespaceContext getNamespaceContext() { + return realReader.getNamespaceContext(); + } + + public int getNamespaceCount() { + if (isDelegating()) { + return realReader.getNamespaceCount(); + } else { + throw new IllegalStateException(); + } + } + + public String getNamespacePrefix(int i) { + if (isDelegating()) { + return realReader.getNamespacePrefix(i); + } else { + throw new IllegalStateException(); + } + } + + public String getNamespaceURI() { + if (isDelegating()) { + return realReader.getNamespaceURI(); + } else { + throw new IllegalStateException(); + } + } + + public String getNamespaceURI(int i) { + if (isDelegating()) { + return realReader.getNamespaceURI(i); + } else { + throw new IllegalStateException(); + } + } + + public String getNamespaceURI(String s) { + if (isDelegating()) { + return realReader.getNamespaceURI(s); + } else { + throw new IllegalStateException(); + } + } + + public String getPIData() { + if (isDelegating()) { + return realReader.getPIData(); + } else { + throw new IllegalStateException(); + } + } + + public String getPITarget() { + if (isDelegating()) { + return realReader.getPITarget(); + } else { + throw new IllegalStateException(); + } + } + + public String getPrefix() { + if (isDelegating()) { + return realReader.getPrefix(); + } else { + throw new IllegalStateException(); + } + } + + public Object getProperty(String s) throws IllegalArgumentException { + if (isDelegating()) { + return realReader.getProperty(s); + } else { + throw new IllegalArgumentException(); + } + } + + public String getText() { + if (isDelegating()) { + return realReader.getText(); + } else { + throw new IllegalStateException(); + } + } + + public char[] getTextCharacters() { + if (isDelegating()) { + return realReader.getTextCharacters(); + } else { + throw new IllegalStateException(); + } + } + + public int getTextCharacters(int i, char[] chars, int i1, int i2) throws XMLStreamException { + if (isDelegating()) { + return realReader.getTextCharacters(i, chars, i1, i2); + } else { + throw new IllegalStateException(); + } + } + + public int getTextLength() { + if (isDelegating()) { + return realReader.getTextLength(); + } else { + throw new IllegalStateException(); + } + } + + public int getTextStart() { + if (isDelegating()) { + return realReader.getTextStart(); + } else { + throw new IllegalStateException(); + } + } + + public String getVersion() { + if (isDelegating()) { + return realReader.getVersion(); + } else { + return null; + } + } + + public boolean hasName() { + if (isDelegating()) { + return realReader.hasName(); + } else { + return false; + } + } + + public boolean hasNext() throws XMLStreamException { + if (state == STATE_COMPLETE_AT_NEXT) { + return true; + } else if (state == STATE_COMPLETED) { + return false; + } else if (state == STATE_SWITCHED) { + return realReader.hasNext(); + } else { + return true; + } + } + + public boolean hasText() { + if (isDelegating()) { + return realReader.hasText(); + } else { + return false; + } + } + + public boolean isAttributeSpecified(int i) { + if (isDelegating()) { + return realReader.isAttributeSpecified(i); + } else { + return false; + } + } + + public boolean isCharacters() { + if (isDelegating()) { + return realReader.isCharacters(); + } else { + return false; + } + } + + private boolean isDelegating() { + return state == STATE_SWITCHED || state == STATE_COMPLETE_AT_NEXT; + } + + public boolean isEndElement() { + if (isDelegating()) { + return realReader.isEndElement(); + } else { + return false; + } + } + + public boolean isStandalone() { + if (isDelegating()) { + return realReader.isStandalone(); + } else { + return false; + } + } + + public boolean isStartElement() { + if (isDelegating()) { + return realReader.isStartElement(); + } else { + return false; + } + } + + public boolean isWhiteSpace() { + if (isDelegating()) { + return realReader.isWhiteSpace(); + } else { + return false; + } + } + + public int next() throws XMLStreamException { + int returnEvent; + + switch (state) { + case STATE_SWITCHED: + returnEvent = realReader.next(); + if (returnEvent == END_DOCUMENT) { + state = STATE_COMPLETED; + } else if (!realReader.hasNext()) { + state = STATE_COMPLETE_AT_NEXT; + } + if (fragment && returnEvent == END_ELEMENT) { + level--; + if (level == -1) { + // We are now at the end of the top-level element in the fragment + state = STATE_COMPLETE_AT_NEXT; + } + } + if (fragment && returnEvent == START_ELEMENT) { + level++; + } + break; + case STATE_INIT: + state = STATE_SWITCHED; + returnEvent = realReader.getEventType(); + if (returnEvent == START_ELEMENT) { + // The real reader is positioned at the top-level element in the fragment + level = 0; + fragment = true; + } + break; + case STATE_COMPLETE_AT_NEXT: + state = STATE_COMPLETED; + returnEvent = END_DOCUMENT; + break; + case STATE_COMPLETED: + // oops - no way we can go beyond this + throw new NoSuchElementException("End of stream has reached."); + default: + throw new UnsupportedOperationException(); + } + + return returnEvent; + } + + public int nextTag() throws XMLStreamException { + if (isDelegating()) { + int returnEvent = realReader.nextTag(); + if (fragment && returnEvent == END_ELEMENT) { + level--; + if (level == 0) { + // We are now at the end of the top-level element in the fragment + state = STATE_COMPLETE_AT_NEXT; + } + } + if (fragment && returnEvent == START_ELEMENT) { + level++; + } + return returnEvent; + } else { + throw new XMLStreamException(); + } + } + + public void require(int i, String s, String s1) throws XMLStreamException { + if (isDelegating()) { + realReader.require(i, s, s1); + } + } + + public boolean standaloneSet() { + if (isDelegating()) { + return realReader.standaloneSet(); + } else { + return false; + } + } +} diff --git a/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLEventsStreamReader.java b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLEventsStreamReader.java new file mode 100644 index 0000000000..351929d8a1 --- /dev/null +++ b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLEventsStreamReader.java @@ -0,0 +1,448 @@ +/* + * 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.sca.contribution.processor.xml; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Stack; + +import java.util.Iterator; + +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 javax.xml.stream.events.Attribute; +import javax.xml.stream.events.Namespace; +import javax.xml.stream.events.ProcessingInstruction; +import javax.xml.stream.events.XMLEvent; + + +public class XMLEventsStreamReader implements XMLStreamReader { + + @SuppressWarnings("unused") + private ArrayList events = null; + @SuppressWarnings("unchecked") + private HashMap eventContext = null; + + private int state; + private java.util.Iterator iterator; + private XMLEvent current; + + @SuppressWarnings("unchecked") + public XMLEventsStreamReader(List events,Map map) { + this.events = (ArrayList) events; + this.eventContext = (HashMap) map; + this.iterator = events.iterator(); + this.current = iterator.next(); + this.state = current.getEventType(); + } + + public void close() throws XMLStreamException { + this.events = null; + this.eventContext = null; + this.iterator = null; + this.current = null; + } + + private void checkElementState() { + if (getEventType() != START_ELEMENT && getEventType() != END_ELEMENT) { + throw new IllegalStateException(); + } + } + + @SuppressWarnings("unchecked") + public int getAttributeCount() { + checkElementState(); + int count = 0; + Iterator iterator = current.asStartElement().getAttributes(); + while (iterator.hasNext()) { + count++; + iterator.next(); + } + return count; + } + + /* + * Custom method to get attribute from the specified index + */ + @SuppressWarnings("unchecked") + private Attribute getAttribute(int index) { + checkElementState(); + int count = 0; + Attribute attribute = null; + Iterator iterator = current.asStartElement().getAttributes(); + while (iterator.hasNext()) { + count++; + if (count == index) { + attribute = iterator.next(); + } else { + iterator.next(); + } + } + return attribute; + } + + + public String getAttributeLocalName(int index) { + checkElementState(); + return getAttribute(index).getName().getLocalPart(); + } + + public QName getAttributeName(int index) { + checkElementState(); + return getAttribute(index).getName(); + } + + public String getAttributeNamespace(int index) { + checkElementState(); + return getAttributeName(index).getNamespaceURI(); + } + + public String getAttributePrefix(int index) { + checkElementState(); + return getAttributeName(index).getPrefix(); + } + + public String getAttributeType(int index) { + checkElementState(); + return getAttribute(index).getDTDType(); + } + + public String getAttributeValue(int index) { + checkElementState(); + return getAttribute(index).getValue(); + } + + @SuppressWarnings("unchecked") + public String getAttributeValue(String namespaceURI, String localName) { + checkElementState(); + Iterator iterator = current.asStartElement().getAttributes(); + Attribute attribute; + while (iterator.hasNext()) { + attribute = iterator.next(); + if (attribute.getName().getNamespaceURI().equalsIgnoreCase( + namespaceURI) + && attribute.getName().getLocalPart().equalsIgnoreCase( + localName)) { + return attribute.getValue(); + } + } + return null; + + } + + public String getCharacterEncodingScheme() { + return "UTF-8"; + } + + public String getElementText() throws XMLStreamException { + checkElementState(); + int eventType = getEventType(); + String elementText = null; + + if (eventType == START_ELEMENT) { + elementText = current.asStartElement().getName().getLocalPart(); + } else if (eventType == END_ELEMENT) { + elementText = current.asEndElement().getName().getLocalPart(); + } + return elementText; + } + + public String getEncoding() { + return "UTF-8"; + } + + public int getEventType() { + return state; + } + + public String getLocalName() { + checkElementState(); + switch (current.getEventType()) { + case START_ELEMENT: + return current.asStartElement().getName().getLocalPart(); + case END_ELEMENT: + return current.asEndElement().getName().getLocalPart(); + } + return null; + } + + public Location getLocation() { + return current.getLocation(); + } + + public QName getName() { + checkElementState(); + switch (current.getEventType()) { + case START_ELEMENT: + return current.asStartElement().getName(); + case END_ELEMENT: + return current.asEndElement().getName(); + } + return null; + } + + public NamespaceContext getNamespaceContext() { + checkElementState(); + //return new TuscanyNamespaceContext(eventContext.get(getLocalName())); + return eventContext.get(getLocalName()); + } + + @SuppressWarnings("unchecked") + public int getNamespaceCount() { + int count = 0; + Iterator itr = current.asStartElement().getNamespaces(); + while (itr.hasNext()) { + count++; + itr.next(); + } + return count; + } + + @SuppressWarnings("unchecked") + public String getNamespacePrefix(int index) { + Iterator itr = current.asStartElement().getNamespaces(); + int level = 0; + Namespace ns = null; + while (itr.hasNext()) { + ns = itr.next(); + if (level == index) { + return ns.getPrefix(); + } + level++; + } + return null; + } + + public String getNamespaceURI() { + checkElementState(); + switch (current.getEventType()) { + case START_ELEMENT: + return current.asStartElement().getName().getNamespaceURI(); + case END_ELEMENT: + return current.asEndElement().getName().getNamespaceURI(); + } + return null; + } + + public String getNamespaceURI(String prefix) { + return getNamespaceContext().getNamespaceURI(prefix); + } + + @SuppressWarnings("unchecked") + public String getNamespaceURI(int index) { + Iterator itr = current.asStartElement().getNamespaces(); + int level = 0; + Namespace ns = null; + while (itr.hasNext()) { + ns = itr.next(); + if (level == index) { + return ns.getNamespaceURI(); + } + level++; + } + return null; + } + + public String getPIData() { + if (current.isProcessingInstruction()) { + ProcessingInstruction pi = (ProcessingInstruction) current; + return pi.getData(); + } else { + throw new IllegalStateException(current.toString()); + } + } + + public String getPITarget() { + if (current.isProcessingInstruction()) { + ProcessingInstruction pi = (ProcessingInstruction) current; + return pi.getTarget(); + } else { + throw new IllegalStateException(current.toString()); + } + } + + public String getPrefix() { + checkElementState(); + if (current.isStartElement()) { + return current.asStartElement().getName().getPrefix(); + } + return null; + } + + /* + * FIXME: Implementation pending... + * + * @see (non-Javadoc) + * javax.xml.stream.util.StreamReaderDelegate#getProperty(java.lang.String) + */ + public Object getProperty(String name) throws IllegalArgumentException { + // TODO Auto-generated method stub + + return null; + } + + public String getText() { + if (current.isCharacters()) { + return current.asCharacters().getData(); + } else { + throw new IllegalStateException(current.toString()); + } + } + + public char[] getTextCharacters() { + if (current.isCharacters()) { + return current.asCharacters().getData().toCharArray(); + } else { + throw new IllegalStateException(current.toString()); + } + } + + /* + * FIXME: Implementation pending... (non-Javadoc) + * + * @see javax.xml.stream.util.StreamReaderDelegate#getTextCharacters(int, + * char[], int, int) + */ + public int getTextCharacters(int sourceStart, char[] target, + int targetStart, int length) throws XMLStreamException { + // TODO Auto-generated method stub + return 0; + } + + /* + * FIXME:Implementaion can be improved (non-Javadoc) + * + * @see javax.xml.stream.util.StreamReaderDelegate#getTextLength() + */ + public int getTextLength() { + if (current.isCharacters()) { + return current.asCharacters().getData().length(); + } else { + throw new IllegalStateException(current.toString()); + } + } + + /* + * FIXME: Implementation pending... (non-Javadoc) + * + * @see javax.xml.stream.util.StreamReaderDelegate#getTextStart() + */ + public int getTextStart() { + // TODO Auto-generated method stub + return 0; + } + + /* + * FIXME: Implementation pending... (non-Javadoc) + * + * @see javax.xml.stream.util.StreamReaderDelegate#getTextStart() + */ + public String getVersion() { + // TODO Auto-generated method stub + + return null; + } + + public boolean hasName() { + return false; + } + + public boolean hasNext() throws XMLStreamException { + return iterator.hasNext() || state != END_DOCUMENT; + + } + + public boolean hasText() { + // TODO Auto-generated method stub + return false; + } + + /* + * FIXME: Implementation pending... (non-Javadoc) + * + * @see javax.xml.stream.util.StreamReaderDelegate#getTextStart() + */ + public boolean isAttributeSpecified(int index) { + // TODO Auto-generated method stub + return false; + } + + public boolean isCharacters() { + return current.isCharacters(); + } + + public boolean isEndElement() { + return current.isEndElement(); + } + + public boolean isStandalone() { + // TODO Auto-generated method stub + return false; + } + + public boolean isStartElement() { + return current.isStartElement(); + } + + public boolean isWhiteSpace() { + // TODO Auto-generated method stub + return false; + } + + public int next() throws XMLStreamException { + if (!hasNext()) { + throw new IllegalStateException("No more events"); + } + if (!iterator.hasNext()) { + state = END_DOCUMENT; + current = null; + return state; + } + current = iterator.next(); + state = current.getEventType(); + return state; + } + + public int nextTag() throws XMLStreamException { + return iterator.next().getEventType(); + } + + public void require(int type, String namespaceURI, String localName) + throws XMLStreamException { + boolean require = false; + String uri = getNamespaceURI(); + String name = getLocalName(); + if (state == type && namespaceURI.equals(uri) && localName.equals(name)) { + require = true; + } + if (require != true) { + throw new XMLStreamException(); + } + } + + public boolean standaloneSet() { + return false; + } + +} diff --git a/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLFragmentStreamReader.java b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLFragmentStreamReader.java new file mode 100644 index 0000000000..66361e1d76 --- /dev/null +++ b/branches/sca-java-1.3.3/modules/contribution-xml/src/main/java/org/apache/tuscany/sca/contribution/processor/xml/XMLFragmentStreamReader.java @@ -0,0 +1,53 @@ +/* + * 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.sca.contribution.processor.xml; + +import javax.xml.namespace.NamespaceContext; +import javax.xml.namespace.QName; +import javax.xml.stream.XMLStreamReader; + +public interface XMLFragmentStreamReader extends XMLStreamReader { + QName NIL_QNAME = new QName("http://www.w3.org/2001/XMLSchema-instance", "nil", "xsi"); + String NIL_VALUE_TRUE = "true"; + + /** + * this will help to handle Text within the current element. user should + * pass the element text to the property list as this ELEMENT_TEXT as the + * key. This key deliberately has a space in it so that it is not a valid + * XML name + */ + String ELEMENT_TEXT = "Element Text"; + + /** + * Extra method to query the state of the pullparser + */ + boolean isDone(); + + /** + * add the parent namespace context to this parser + */ + void setParentNamespaceContext(NamespaceContext nsContext); + + /** + * Initiate the parser - this will do whatever the needed tasks to initiate + * the parser and must be called before attempting any specific parsing + * using this parser + */ + void init(); +} -- cgit v1.2.3