| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 2001 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The name "Apache Software Foundation" must not be used to endorse or |
| * promote products derived from this software without prior written |
| * permission. For written permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.xml.dtm.ref.xni2dtm; |
| |
| import javax.xml.transform.Source; |
| import javax.xml.transform.stream.StreamSource; |
| import javax.xml.transform.sax.SAXSource; |
| |
| import java.lang.String; |
| |
| import java.io.OutputStream; |
| import java.io.Writer; |
| |
| import org.apache.xerces.xni.parser.XMLDocumentScanner; |
| import org.apache.xerces.xni.parser.XMLDocumentSource; |
| import org.apache.xerces.xni.parser.XMLInputSource; |
| import org.apache.xerces.xni.XMLDocumentHandler; |
| import org.apache.xerces.xni.parser.XMLErrorHandler; |
| import org.apache.xerces.xni.parser.XMLParserConfiguration; |
| |
| /** |
| * Acts as an holder for XNI-style Source. |
| * Should be made more compatable with JAXP Source |
| * (eg, accept JAXP InputSource and convert to XNI?) |
| * Should this be moved to javax.xml.transform? |
| */ |
| public class XNISource implements Source { |
| XMLDocumentScanner docScanner; |
| XMLDocumentSource eventSource; |
| XMLInputSource xniInputSource; |
| |
| // This should be |
| // XMLParserConfiguration parserConfiguration; |
| // but the reset() operation is unfortunately _NOT_ part of the |
| // architecture of the Configuration! |
| DOMValidationConfigurationSwipedFromXerces parserConfiguration; |
| |
| /** |
| * If {@link javax.xml.transform.TransformerFactory#getFeature} |
| * returns true when passed this value as an argument, |
| * the Transformer supports Source input of this type. |
| */ |
| public static final String FEATURE = |
| "http://org.apache.xml.dtm.ref.xni2dtm.XNISource/feature"; |
| |
| /** |
| * Zero-argument default constructor. If this constructor |
| * is used, and no other method is called, the |
| * {@link javax.xml.transform.Transformer} |
| * assumes an empty input tree, with a default root node. |
| */ |
| public XNISource() {} |
| |
| /** |
| * Create a <code>XNISource</code>, using an {@link org.xml.XNI.XMLReader} |
| * and a XNI InputSource. The {@link javax.xml.transform.Transformer} |
| * or {@link javax.xml.transform.XNI.XNITransformerFactory} will set itself |
| * to be the reader's {@link org.xml.XNI.ContentHandler}, and then will call |
| * reader.parse(inputSource). |
| * |
| * @param reader An XMLReader to be used for the parse. Must also implement |
| * XMLParserConfiguration. (That may make this a non-useful method |
| * as it stands. %REVIEW%.) |
| * @param inputSource A XNI input source reference that must be non-null |
| * and that will be passed to the reader parse method. |
| */ |
| public XNISource(XMLDocumentScanner reader, XMLInputSource inputSource) |
| { |
| this(reader,(XMLParserConfiguration)reader,reader,inputSource); |
| } |
| |
| /** |
| * Create a <code>XNISource</code>, using an {@link org.xml.xni.XMLDocumentScanner} |
| * (which we will send the parse request to), an {@link org.xml.xni.XMLDocumentSource} |
| * (which we will expect the events from) and a XNI InputSource. The first two |
| * are separated because there might be a filtering pipeline between the |
| * scanner and our own immediate source. |
| * |
| * The {@link javax.xml.transform.Transformer} |
| * or {@link javax.xml.transform.XNI.XNITransformerFactory} will set itself |
| * to be the reader's {@link org.xml.XNI.ContentHandler}, and then will call |
| * reader.parse(inputSource). |
| * |
| * @param reader An XMLReader to be used for the parse. |
| * @param inputSource A XNI input source reference that must be non-null |
| * and that will be passed to the reader parse method. |
| */ |
| public XNISource(XMLDocumentScanner reader, |
| XMLParserConfiguration parserConfiguration, |
| XMLDocumentSource eventSource, |
| XMLInputSource inputSource) |
| { |
| this.docScanner = reader; |
| this.eventSource = eventSource; |
| this.xniInputSource = inputSource; |
| // Sloppy, but XMLParserConfiguration has no reset() operation |
| // and reset _must_ be performed late (eg after setting the |
| // error handler). |
| this.parserConfiguration = (DOMValidationConfigurationSwipedFromXerces)parserConfiguration; |
| } |
| |
| |
| |
| /** |
| * Create a <code>XNISource</code>, using a XNI <code>InputSource</code>. |
| * The {@link javax.xml.transform.Transformer} or |
| * {@link javax.xml.transform.XNI.XNITransformerFactory} creates a |
| * reader via {@link org.xml.XNI.helpers.XMLReaderFactory} |
| * (if setXMLReader is not used), sets itself as |
| * the reader's {@link org.xml.XNI.ContentHandler}, and calls |
| * reader.parse(inputSource). |
| * |
| * @param inputSource An input source reference that must be non-null |
| * and that will be passed to the parse method of the reader. |
| */ |
| public XNISource(XMLInputSource inputSource) { |
| this.xniInputSource = inputSource; |
| } |
| |
| /** |
| * Convert SAX source to XNI source (by swiping its input) |
| * |
| * @param inputSource An input source reference that must be non-null |
| * and that will be passed to the parse method of the reader. |
| */ |
| public XNISource(SAXSource saxSource) { |
| setInputSource(saxSource.getInputSource()); |
| } |
| |
| /** |
| * Read from SAX-style InputSource |
| * |
| * @param inputSource An input source reference that must be non-null |
| * and that will be passed to the parse method of the reader. |
| */ |
| public void setInputSource(org.xml.sax.InputSource saxInputSource) { |
| if(saxInputSource.getCharacterStream()!=null) |
| this.xniInputSource=new XMLInputSource( |
| saxInputSource.getPublicId(), |
| saxInputSource.getSystemId(), |
| null, |
| saxInputSource.getCharacterStream(), |
| saxInputSource.getEncoding() |
| ); |
| else if(saxInputSource.getByteStream()!=null) |
| this.xniInputSource=new XMLInputSource( |
| saxInputSource.getPublicId(), |
| saxInputSource.getSystemId(), |
| null, |
| saxInputSource.getByteStream(), |
| saxInputSource.getEncoding() |
| ); |
| else |
| this.xniInputSource=new XMLInputSource( |
| saxInputSource.getPublicId(), |
| saxInputSource.getSystemId(), |
| null); |
| } |
| |
| /** |
| * Set the XMLReader to be used for the Source. |
| * Be sure to set the document handler _after_ this. |
| * %REVIEW%: Should we save and reassert that value? |
| * |
| * @param reader A valid XMLReader or XMLFilter reference. |
| */ |
| public void setXMLReader(org.apache.xerces.xni.parser.XMLDocumentScanner reader) { |
| this.docScanner = reader; |
| } |
| |
| /** |
| * Set the XNI InputSource to be used for the Source. |
| * |
| * @param inputSource A valid InputSource reference. |
| */ |
| public void setInputSource(XMLInputSource inputSource) { |
| this.xniInputSource = inputSource; |
| } |
| |
| /** |
| * Get the XNI InputSource to be used for the Source. |
| * |
| * @return A valid InputSource reference, or null. |
| */ |
| public XMLInputSource getInputSource() { |
| return xniInputSource; |
| } |
| |
| /** |
| * Set the XNI DocumentHandler to receive our output. Note that |
| * this ties to the event source, which is not necessarily the |
| * scanner. |
| * |
| * @param inputSource A valid XMLDocumentHandler reference. |
| */ |
| public void setDocumentHandler(XMLDocumentHandler target) |
| { |
| eventSource.setDocumentHandler(target); |
| } |
| |
| /** |
| * Set the XNI ErrorHandler to receive our output. Note that |
| * this ties to the parser configuration. |
| * |
| * @param inputSource A valid XMLDocumentHandler reference. |
| */ |
| public void setErrorHandler(XMLErrorHandler target) |
| { |
| parserConfiguration.setErrorHandler(target); |
| } |
| |
| /** |
| * Start/resume parsing. |
| * Note that this gets passed to the scanner, which is not necessarily |
| * the immediate event source. |
| * |
| * @param toCompletion False for incremental parse, true to read the |
| * rest of the document. |
| */ |
| public void reset() throws java.io.IOException |
| { |
| parserConfiguration.reset(); |
| } |
| |
| /** |
| * Start/resume parsing. |
| * Note that this gets passed to the scanner, which is not necessarily |
| * the immediate event source. |
| * |
| * @param toCompletion False for incremental parse, true to read the |
| * rest of the document. |
| */ |
| public void scanDocument(boolean toCompletion) throws java.io.IOException |
| { |
| docScanner.scanDocument(toCompletion); |
| } |
| |
| |
| /** |
| * Set the system identifier for this Source. If an input source |
| * has already been set, it will set the system ID or that |
| * input source, otherwise it will create a new input source. |
| * |
| * <p>The system identifier is optional if there is a byte stream |
| * or a character stream, but it is still useful to provide one, |
| * since the application can use it to resolve relative URIs |
| * and can include it in error messages and warnings (the parser |
| * will attempt to open a connection to the URI only if |
| * no byte stream or character stream is specified).</p> |
| * |
| * @param systemId The system identifier as a URI string. |
| */ |
| public void setSystemId(String systemId) { |
| |
| if (null == xniInputSource) { |
| xniInputSource = new XMLInputSource(null,systemId,null); |
| } else { |
| xniInputSource.setSystemId(systemId); |
| } |
| } |
| |
| /** |
| * Get the base ID (URI or system ID) from where URIs |
| * will be resolved. |
| * |
| * @return Base URL for the Source, or null. |
| */ |
| public String getSystemId() { |
| |
| return (null != xniInputSource) |
| ? xniInputSource.getSystemId() |
| : null; |
| } |
| } |
| |