Examples with XMLReader org.xml.sax.XMLReader used on opensource projects

Example 11 with XMLReader

use of org.xml.sax.XMLReader in project j2objc by google.

the class TransformerIdentityImpl method transform.

/**
   * Process the source tree to the output result.
   * @param source  The input for the source tree.
   *
   * @param outputTarget The output target.
   *
   * @throws TransformerException If an unrecoverable error occurs
   * during the course of the transformation.
   */
public void transform(Source source, Result outputTarget) throws TransformerException {
    createResultContentHandler(outputTarget);
    /*
     * According to JAXP1.2, new SAXSource()/StreamSource()
     * should create an empty input tree, with a default root node. 
     * new DOMSource()creates an empty document using DocumentBuilder.
     * newDocument(); Use DocumentBuilder.newDocument() for all 3 situations,
     * since there is no clear spec. how to create an empty tree when
     * both SAXSource() and StreamSource() are used.
     */
    if ((source instanceof StreamSource && source.getSystemId() == null && ((StreamSource) source).getInputStream() == null && ((StreamSource) source).getReader() == null) || (source instanceof SAXSource && ((SAXSource) source).getInputSource() == null && ((SAXSource) source).getXMLReader() == null) || (source instanceof DOMSource && ((DOMSource) source).getNode() == null)) {
        try {
            DocumentBuilderFactory builderF = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = builderF.newDocumentBuilder();
            String systemID = source.getSystemId();
            source = new DOMSource(builder.newDocument());
            // Copy system ID from original, empty Source to new Source
            if (systemID != null) {
                source.setSystemId(systemID);
            }
        } catch (ParserConfigurationException e) {
            throw new TransformerException(e.getMessage());
        }
    }
    try {
        if (source instanceof DOMSource) {
            DOMSource dsource = (DOMSource) source;
            m_systemID = dsource.getSystemId();
            Node dNode = dsource.getNode();
            if (null != dNode) {
                try {
                    if (dNode.getNodeType() == Node.ATTRIBUTE_NODE)
                        this.startDocument();
                    try {
                        if (dNode.getNodeType() == Node.ATTRIBUTE_NODE) {
                            String data = dNode.getNodeValue();
                            char[] chars = data.toCharArray();
                            characters(chars, 0, chars.length);
                        } else {
                            org.apache.xml.serializer.TreeWalker walker;
                            walker = new org.apache.xml.serializer.TreeWalker(this, m_systemID);
                            walker.traverse(dNode);
                        }
                    } finally {
                        if (dNode.getNodeType() == Node.ATTRIBUTE_NODE)
                            this.endDocument();
                    }
                } catch (SAXException se) {
                    throw new TransformerException(se);
                }
                return;
            } else {
                String messageStr = XSLMessages.createMessage(XSLTErrorResources.ER_ILLEGAL_DOMSOURCE_INPUT, null);
                throw new IllegalArgumentException(messageStr);
            }
        }
        InputSource xmlSource = SAXSource.sourceToInputSource(source);
        if (null == xmlSource) {
            //"Can't transform a Source of type "
            throw new TransformerException(XSLMessages.createMessage(XSLTErrorResources.ER_CANNOT_TRANSFORM_SOURCE_TYPE, new Object[] { source.getClass().getName() }));
        //+ source.getClass().getName() + "!");
        }
        if (null != xmlSource.getSystemId())
            m_systemID = xmlSource.getSystemId();
        XMLReader reader = null;
        boolean managedReader = false;
        try {
            if (source instanceof SAXSource) {
                reader = ((SAXSource) source).getXMLReader();
            }
            if (null == reader) {
                try {
                    reader = XMLReaderManager.getInstance().getXMLReader();
                    managedReader = true;
                } catch (SAXException se) {
                    throw new TransformerException(se);
                }
            } else {
                try {
                    reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
                } catch (org.xml.sax.SAXException se) {
                // We don't care.
                }
            }
            // Get the input content handler, which will handle the 
            // parse events and create the source tree. 
            ContentHandler inputHandler = this;
            reader.setContentHandler(inputHandler);
            if (inputHandler instanceof org.xml.sax.DTDHandler)
                reader.setDTDHandler((org.xml.sax.DTDHandler) inputHandler);
            try {
                if (inputHandler instanceof org.xml.sax.ext.LexicalHandler)
                    reader.setProperty("http://xml.org/sax/properties/lexical-handler", inputHandler);
                if (inputHandler instanceof org.xml.sax.ext.DeclHandler)
                    reader.setProperty("http://xml.org/sax/properties/declaration-handler", inputHandler);
            } catch (org.xml.sax.SAXException se) {
            }
            try {
                if (inputHandler instanceof org.xml.sax.ext.LexicalHandler)
                    reader.setProperty("http://xml.org/sax/handlers/LexicalHandler", inputHandler);
                if (inputHandler instanceof org.xml.sax.ext.DeclHandler)
                    reader.setProperty("http://xml.org/sax/handlers/DeclHandler", inputHandler);
            } catch (org.xml.sax.SAXNotRecognizedException snre) {
            }
            reader.parse(xmlSource);
        } catch (org.apache.xml.utils.WrappedRuntimeException wre) {
            Throwable throwable = wre.getException();
            while (throwable instanceof org.apache.xml.utils.WrappedRuntimeException) {
                throwable = ((org.apache.xml.utils.WrappedRuntimeException) throwable).getException();
            }
            throw new TransformerException(wre.getException());
        } catch (org.xml.sax.SAXException se) {
            throw new TransformerException(se);
        } catch (IOException ioe) {
            throw new TransformerException(ioe);
        } finally {
            if (managedReader) {
                XMLReaderManager.getInstance().releaseXMLReader(reader);
            }
        }
    } finally {
        if (null != m_outputStream) {
            try {
                m_outputStream.close();
            } catch (IOException ioe) {
            }
            m_outputStream = null;
        }
    }
}

Example 12 with XMLReader

use of org.xml.sax.XMLReader in project j2objc by google.

the class DTMManagerDefault method getDTM.

/**
   * Get an instance of a DTM, loaded with the content from the
   * specified source.  If the unique flag is true, a new instance will
   * always be returned.  Otherwise it is up to the DTMManager to return a
   * new instance or an instance that it already created and may be being used
   * by someone else.
   * 
   * A bit of magic in this implementation: If the source is null, unique is true,
   * and incremental and doIndexing are both false, we return an instance of
   * SAX2RTFDTM, which see.
   * 
   * (I think more parameters will need to be added for error handling, and entity
   * resolution, and more explicit control of the RTF situation).
   *
   * @param source the specification of the source object.
   * @param unique true if the returned DTM must be unique, probably because it
   * is going to be mutated.
   * @param whiteSpaceFilter Enables filtering of whitespace nodes, and may
   *                         be null.
   * @param incremental true if the DTM should be built incrementally, if
   *                    possible.
   * @param doIndexing true if the caller considers it worth it to use
   *                   indexing schemes.
   *
   * @return a non-null DTM reference.
   */
public synchronized DTM getDTM(Source source, boolean unique, DTMWSFilter whiteSpaceFilter, boolean incremental, boolean doIndexing) {
    if (DEBUG && null != source)
        System.out.println("Starting " + (unique ? "UNIQUE" : "shared") + " source: " + source.getSystemId());
    XMLStringFactory xstringFactory = m_xsf;
    int dtmPos = getFirstFreeDTMID();
    int documentID = dtmPos << IDENT_DTM_NODE_BITS;
    if ((null != source) && source instanceof DOMSource) {
        DOM2DTM dtm = new DOM2DTM(this, (DOMSource) source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
        addDTM(dtm, dtmPos, 0);
        return dtm;
    } else {
        boolean isSAXSource = (null != source) ? (source instanceof SAXSource) : true;
        boolean isStreamSource = (null != source) ? (source instanceof StreamSource) : false;
        if (isSAXSource || isStreamSource) {
            XMLReader reader = null;
            SAX2DTM dtm;
            try {
                InputSource xmlSource;
                if (null == source) {
                    xmlSource = null;
                } else {
                    reader = getXMLReader(source);
                    xmlSource = SAXSource.sourceToInputSource(source);
                    String urlOfSource = xmlSource.getSystemId();
                    if (null != urlOfSource) {
                        try {
                            urlOfSource = SystemIDResolver.getAbsoluteURI(urlOfSource);
                        } catch (Exception e) {
                            // %REVIEW% Is there a better way to send a warning?
                            System.err.println("Can not absolutize URL: " + urlOfSource);
                        }
                        xmlSource.setSystemId(urlOfSource);
                    }
                }
                if (source == null && unique && !incremental && !doIndexing) {
                    // Special case to support RTF construction into shared DTM.
                    // It should actually still work for other uses,
                    // but may be slightly deoptimized relative to the base
                    // to allow it to deal with carrying multiple documents.
                    //
                    // %REVIEW% This is a sloppy way to request this mode;
                    // we need to consider architectural improvements.
                    dtm = new SAX2RTFDTM(this, source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
                } else /**************************************************************
          // EXPERIMENTAL 3/22/02
          else if(JKESS_XNI_EXPERIMENT && m_incremental) {        	
            dtm = new XNI2DTM(this, source, documentID, whiteSpaceFilter,
                              xstringFactory, doIndexing);
          }
          **************************************************************/
                // Create the basic SAX2DTM.
                {
                    dtm = new SAX2DTM(this, source, documentID, whiteSpaceFilter, xstringFactory, doIndexing);
                }
                // Go ahead and add the DTM to the lookup table.  This needs to be
                // done before any parsing occurs. Note offset 0, since we've just
                // created a new DTM.
                addDTM(dtm, dtmPos, 0);
                boolean haveXercesParser = (null != reader) && (reader.getClass().getName().equals("org.apache.xerces.parsers.SAXParser"));
                if (haveXercesParser) {
                    // No matter what.  %REVIEW%
                    incremental = true;
                }
                // build, then we still want to set up the IncrementalSAXSource stuff.
                if (m_incremental && incremental) /* || ((null == reader) && incremental) */
                {
                    IncrementalSAXSource coParser = null;
                    if (haveXercesParser) {
                        // IncrementalSAXSource_Xerces to avoid threading.
                        try {
                            coParser = (IncrementalSAXSource) Class.forName("org.apache.xml.dtm.ref.IncrementalSAXSource_Xerces").newInstance();
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            coParser = null;
                        }
                    }
                    if (coParser == null) {
                        // Create a IncrementalSAXSource to run on the secondary thread.
                        if (null == reader) {
                            coParser = new IncrementalSAXSource_Filter();
                        } else {
                            IncrementalSAXSource_Filter filter = new IncrementalSAXSource_Filter();
                            filter.setXMLReader(reader);
                            coParser = filter;
                        }
                    }
                    /**************************************************************
            // EXPERIMENTAL 3/22/02
            if (JKESS_XNI_EXPERIMENT && m_incremental &&
                  dtm instanceof XNI2DTM && 
                  coParser instanceof IncrementalSAXSource_Xerces) {
                org.apache.xerces.xni.parser.XMLPullParserConfiguration xpc=
                      ((IncrementalSAXSource_Xerces)coParser)
                                           .getXNIParserConfiguration();
              if (xpc!=null) {
                // Bypass SAX; listen to the XNI stream
                ((XNI2DTM)dtm).setIncrementalXNISource(xpc);
              } else {
                  // Listen to the SAX stream (will fail, diagnostically...)
                dtm.setIncrementalSAXSource(coParser);
              }
            } else
            ***************************************************************/
                    // Have the DTM set itself up as IncrementalSAXSource's listener.
                    dtm.setIncrementalSAXSource(coParser);
                    if (null == xmlSource) {
                        // Then the user will construct it themselves.
                        return dtm;
                    }
                    if (null == reader.getErrorHandler()) {
                        reader.setErrorHandler(dtm);
                    }
                    reader.setDTDHandler(dtm);
                    try {
                        // Launch parsing coroutine.  Launches a second thread,
                        // if we're using IncrementalSAXSource.filter().
                        coParser.startParse(xmlSource);
                    } catch (RuntimeException re) {
                        dtm.clearCoRoutine();
                        throw re;
                    } catch (Exception e) {
                        dtm.clearCoRoutine();
                        throw new org.apache.xml.utils.WrappedRuntimeException(e);
                    }
                } else {
                    if (null == reader) {
                        // Then the user will construct it themselves.
                        return dtm;
                    }
                    // not incremental
                    reader.setContentHandler(dtm);
                    reader.setDTDHandler(dtm);
                    if (null == reader.getErrorHandler()) {
                        reader.setErrorHandler(dtm);
                    }
                    try {
                        reader.setProperty("http://xml.org/sax/properties/lexical-handler", dtm);
                    } catch (SAXNotRecognizedException e) {
                    } catch (SAXNotSupportedException e) {
                    }
                    try {
                        reader.parse(xmlSource);
                    } catch (RuntimeException re) {
                        dtm.clearCoRoutine();
                        throw re;
                    } catch (Exception e) {
                        dtm.clearCoRoutine();
                        throw new org.apache.xml.utils.WrappedRuntimeException(e);
                    }
                }
                if (DUMPTREE) {
                    System.out.println("Dumping SAX2DOM");
                    dtm.dumpDTM(System.err);
                }
                return dtm;
            } finally {
                // after creating the DTM.
                if (reader != null && !(m_incremental && incremental)) {
                    reader.setContentHandler(m_defaultHandler);
                    reader.setDTDHandler(m_defaultHandler);
                    reader.setErrorHandler(m_defaultHandler);
                    // Reset the LexicalHandler to null after creating the DTM.
                    try {
                        reader.setProperty("http://xml.org/sax/properties/lexical-handler", null);
                    } catch (Exception e) {
                    }
                }
                releaseXMLReader(reader);
            }
        } else {
            //"Not supported: " + source);
            throw new DTMException(XMLMessages.createXMLMessage(XMLErrorResources.ER_NOT_SUPPORTED, new Object[] { source }));
        }
    }
}

Example 13 with XMLReader

use of org.xml.sax.XMLReader in project j2objc by google.

the class XMLReaderManager method getXMLReader.

/**
     * Retrieves a cached XMLReader for this thread, or creates a new
     * XMLReader, if the existing reader is in use.  When the caller no
     * longer needs the reader, it must release it with a call to
     * {@link #releaseXMLReader}.
     */
public synchronized XMLReader getXMLReader() throws SAXException {
    XMLReader reader;
    boolean readerInUse;
    if (m_readers == null) {
        // When the m_readers.get() method is called for the first time
        // on a thread, a new XMLReader will automatically be created.
        m_readers = new ThreadLocal();
    }
    if (m_inUse == null) {
        m_inUse = new Hashtable();
    }
    // If the cached reader for this thread is in use, construct a new
    // one; otherwise, return the cached reader.
    reader = (XMLReader) m_readers.get();
    boolean threadHasReader = (reader != null);
    if (!threadHasReader || m_inUse.get(reader) == Boolean.TRUE) {
        try {
            try {
                // According to JAXP 1.2 specification, if a SAXSource
                // is created using a SAX InputSource the Transformer or
                // TransformerFactory creates a reader via the
                // XMLReaderFactory if setXMLReader is not used
                reader = XMLReaderFactory.createXMLReader();
            } catch (Exception e) {
                try {
                    // the XMLReader from JAXP
                    if (m_parserFactory == null) {
                        m_parserFactory = SAXParserFactory.newInstance();
                        m_parserFactory.setNamespaceAware(true);
                    }
                    reader = m_parserFactory.newSAXParser().getXMLReader();
                } catch (ParserConfigurationException pce) {
                    // pass along pce
                    throw pce;
                }
            }
            try {
                reader.setFeature(NAMESPACES_FEATURE, true);
                reader.setFeature(NAMESPACE_PREFIXES_FEATURE, false);
            } catch (SAXException se) {
            // Try to carry on if we've got a parser that
            // doesn't know about namespace prefixes.
            }
        } catch (ParserConfigurationException ex) {
            throw new SAXException(ex);
        } catch (FactoryConfigurationError ex1) {
            throw new SAXException(ex1.toString());
        } catch (NoSuchMethodError ex2) {
        } catch (AbstractMethodError ame) {
        }
        // a reader for this thread.
        if (!threadHasReader) {
            m_readers.set(reader);
            m_inUse.put(reader, Boolean.TRUE);
        }
    } else {
        m_inUse.put(reader, Boolean.TRUE);
    }
    return reader;
}

Example 14 with XMLReader

use of org.xml.sax.XMLReader in project android-async-http by loopj.

the class SaxAsyncHttpResponseHandler method getResponseData.

/**
     * Deconstructs response into given content handler
     *
     * @param entity returned HttpEntity
     * @return deconstructed response
     * @throws java.io.IOException if there is problem assembling SAX response from stream
     * @see cz.msebera.android.httpclient.HttpEntity
     */
@Override
protected byte[] getResponseData(HttpEntity entity) throws IOException {
    if (entity != null) {
        InputStream instream = entity.getContent();
        InputStreamReader inputStreamReader = null;
        if (instream != null) {
            try {
                SAXParserFactory sfactory = SAXParserFactory.newInstance();
                SAXParser sparser = sfactory.newSAXParser();
                XMLReader rssReader = sparser.getXMLReader();
                rssReader.setContentHandler(handler);
                inputStreamReader = new InputStreamReader(instream, getCharset());
                rssReader.parse(new InputSource(inputStreamReader));
            } catch (SAXException e) {
                AsyncHttpClient.log.e(LOG_TAG, "getResponseData exception", e);
            } catch (ParserConfigurationException e) {
                AsyncHttpClient.log.e(LOG_TAG, "getResponseData exception", e);
            } finally {
                AsyncHttpClient.silentCloseInputStream(instream);
                if (inputStreamReader != null) {
                    try {
                        inputStreamReader.close();
                    } catch (IOException e) {
                    /*ignore*/
                    }
                }
            }
        }
    }
    return null;
}

Example 15 with XMLReader

use of org.xml.sax.XMLReader in project camel by apache.

the class XmlRpcDataFormat method unmarshalResponse.

protected Object unmarshalResponse(Exchange exchange, InputStream stream) throws Exception {
    InputSource isource = new InputSource(stream);
    XMLReader xr = newXMLReader();
    XmlRpcResponseParser xp;
    try {
        xp = new XmlRpcResponseParser(xmlRpcStreamRequestConfig, typeFactory);
        xr.setContentHandler(xp);
        xr.parse(isource);
    } catch (SAXException e) {
        throw new XmlRpcClientException("Failed to parse server's response: " + e.getMessage(), e);
    } catch (IOException e) {
        throw new XmlRpcClientException("Failed to read server's response: " + e.getMessage(), e);
    }
    if (xp.isSuccess()) {
        return xp.getResult();
    }
    Throwable t = xp.getErrorCause();
    if (t == null) {
        throw new XmlRpcException(xp.getErrorCode(), xp.getErrorMessage());
    }
    if (t instanceof XmlRpcException) {
        throw (XmlRpcException) t;
    }
    if (t instanceof RuntimeException) {
        throw (RuntimeException) t;
    }
    throw new XmlRpcException(xp.getErrorCode(), xp.getErrorMessage(), t);
}