Example usage for org.xml.sax XMLReader parse

Introduction

In this page you can find the example usage for org.xml.sax XMLReader parse.

Prototype

public void parse(String systemId) throws IOException, SAXException;

Source Link

Document

Parse an XML document from a system identifier (URI).

Usage

From source file:org.exist.http.SOAPServer.java

/**
 * Builds an XML Document from a string representation
 * /*  ww  w  . j  a v  a 2 s .c om*/
 * @param buf   The XML Document content
 * 
 * @return   DOM XML Document
 */
private Document BuildXMLDocument(byte[] buf) throws SAXException, ParserConfigurationException, IOException {
    //try and construct xml document from input stream, we use eXist's in-memory DOM implementation
    final SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setNamespaceAware(true);
    //TODO we should be able to cope with context.getBaseURI()            
    final InputSource src = new InputSource(new ByteArrayInputStream(buf));
    final SAXParser parser = factory.newSAXParser();
    final XMLReader reader = parser.getXMLReader();
    final SAXAdapter adapter = new SAXAdapter();
    reader.setContentHandler(adapter);
    reader.setContentHandler(adapter);
    reader.parse(src);

    //return receiver.getDocument();
    return adapter.getDocument();
}

---

From source file:org.exist.mongodb.xquery.gridfs.Get.java

/**
 * Parse an byte-array containing (compressed) XML data into an eXist-db
 * document.//  w w w.  j av a2 s.com
 *
 * @param data Byte array containing the XML data.
 * @return Sequence containing the XML as DocumentImpl
 *
 * @throws XPathException Something bad happened.
 */
private Sequence processXML(XQueryContext xqueryContext, InputStream is) throws XPathException {

    Sequence content = null;
    try {
        final ValidationReport validationReport = new ValidationReport();
        final SAXAdapter adapter = new SAXAdapter(xqueryContext);
        final SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        final InputSource src = new InputSource(is);
        final SAXParser parser = factory.newSAXParser();
        XMLReader xr = parser.getXMLReader();

        xr.setErrorHandler(validationReport);
        xr.setContentHandler(adapter);
        xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);

        xr.parse(src);

        // Cleanup
        IOUtils.closeQuietly(is);

        if (validationReport.isValid()) {
            content = (DocumentImpl) adapter.getDocument();
        } else {
            String txt = String.format("Received document is not valid: %s", validationReport.toString());
            LOG.debug(txt);
            throw new XPathException(txt);
        }

    } catch (SAXException | ParserConfigurationException | IOException ex) {
        LOG.error(ex.getMessage(), ex);
        throw new XPathException(ex.getMessage());

    }

    return content;
}

---

From source file:org.exist.xquery.functions.request.GetData.java

private Sequence parseAsXml(InputStream is) {

    Sequence result = Sequence.EMPTY_SEQUENCE;
    XMLReader reader = null;

    context.pushDocumentContext();/*from ww w.ja  v  a 2 s  .co m*/
    try {
        //try and construct xml document from input stream, we use eXist's in-memory DOM implementation

        //we have to use CloseShieldInputStream otherwise the parser closes the stream and we cant later reread
        final InputSource src = new InputSource(new CloseShieldInputStream(is));

        reader = context.getBroker().getBrokerPool().getParserPool().borrowXMLReader();
        final MemTreeBuilder builder = context.getDocumentBuilder();
        final DocumentBuilderReceiver receiver = new DocumentBuilderReceiver(builder, true);
        reader.setContentHandler(receiver);
        reader.setProperty(Namespaces.SAX_LEXICAL_HANDLER, receiver);
        reader.parse(src);
        final Document doc = receiver.getDocument();

        result = (NodeValue) doc;
    } catch (final SAXException saxe) {
        //do nothing, we will default to trying to return a string below
    } catch (final IOException ioe) {
        //do nothing, we will default to trying to return a string below
    } finally {
        context.popDocumentContext();

        if (reader != null) {
            context.getBroker().getBrokerPool().getParserPool().returnXMLReader(reader);
        }
    }

    return result;
}

---

From source file:org.exist.xquery.modules.sql.ExecuteFunction.java

/**
 * evaluate the call to the XQuery execute() function, it is really the main entry point of this class.
 *
 * @param   args             arguments from the execute() function call
 * @param   contextSequence  the Context Sequence to operate on (not used here internally!)
 *
 * @return  A node representing the SQL result set
 *
 * @throws  XPathException  DOCUMENT ME!
 *
 * @see     org.exist.xquery.BasicFunction#eval(org.exist.xquery.value.Sequence[], org.exist.xquery.value.Sequence)
 *//*from ww w  .j  av a2 s.co m*/
@Override
public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {
    // was a connection and SQL statement specified?
    if (args[0].isEmpty() || args[1].isEmpty()) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    // get the Connection
    long connectionUID = ((IntegerValue) args[0].itemAt(0)).getLong();
    Connection con = SQLModule.retrieveConnection(context, connectionUID);

    if (con == null) {
        return (Sequence.EMPTY_SEQUENCE);
    }

    boolean preparedStmt = false;

    //setup the SQL statement
    String sql = null;
    Statement stmt = null;
    boolean executeResult = false;
    ResultSet rs = null;

    try {
        boolean makeNodeFromColumnName = false;
        MemTreeBuilder builder = context.getDocumentBuilder();
        int iRow = 0;

        //SQL or PreparedStatement?
        if (args.length == 3) {

            // get the SQL statement
            sql = args[1].getStringValue();
            stmt = con.createStatement();
            makeNodeFromColumnName = ((BooleanValue) args[2].itemAt(0)).effectiveBooleanValue();

            //execute the statement
            executeResult = stmt.execute(sql);

        } else if (args.length == 4) {

            preparedStmt = true;

            //get the prepared statement
            long statementUID = ((IntegerValue) args[1].itemAt(0)).getLong();
            PreparedStatementWithSQL stmtWithSQL = SQLModule.retrievePreparedStatement(context, statementUID);
            sql = stmtWithSQL.getSql();
            stmt = stmtWithSQL.getStmt();
            makeNodeFromColumnName = ((BooleanValue) args[3].itemAt(0)).effectiveBooleanValue();

            if (!args[2].isEmpty()) {
                setParametersOnPreparedStatement(stmt, (Element) args[2].itemAt(0));
            }

            //execute the prepared statement
            executeResult = ((PreparedStatement) stmt).execute();
        } else {
            //TODO throw exception
        }

        // DW: stmt can be null ?

        // execute the query statement
        if (executeResult) {
            /* SQL Query returned results */

            // iterate through the result set building an XML document
            rs = stmt.getResultSet();
            ResultSetMetaData rsmd = rs.getMetaData();
            int iColumns = rsmd.getColumnCount();

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("count", null, null), String.valueOf(-1));

            while (rs.next()) {
                builder.startElement(new QName("row", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
                builder.addAttribute(new QName("index", null, null), String.valueOf(rs.getRow()));

                // get each tuple in the row
                for (int i = 0; i < iColumns; i++) {
                    String columnName = rsmd.getColumnLabel(i + 1);

                    if (columnName != null) {

                        String colElement = "field";

                        if (makeNodeFromColumnName && columnName.length() > 0) {
                            // use column names as the XML node

                            /**
                             * Spaces in column names are replaced with
                             * underscore's
                             */
                            colElement = SQLUtils.escapeXmlAttr(columnName.replace(' ', '_'));
                        }

                        builder.startElement(new QName(colElement, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                null);

                        if (!makeNodeFromColumnName || columnName.length() <= 0) {
                            String name;

                            if (columnName.length() > 0) {
                                name = SQLUtils.escapeXmlAttr(columnName);
                            } else {
                                name = "Column: " + String.valueOf(i + 1);
                            }

                            builder.addAttribute(new QName("name", null, null), name);
                        }

                        builder.addAttribute(
                                new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                rsmd.getColumnTypeName(i + 1));
                        builder.addAttribute(new QName(TYPE_ATTRIBUTE_NAME, Namespaces.SCHEMA_NS, "xs"),
                                Type.getTypeName(SQLUtils.sqlTypeToXMLType(rsmd.getColumnType(i + 1))));

                        //get the content
                        if (rsmd.getColumnType(i + 1) == Types.SQLXML) {
                            //parse sqlxml value
                            try {
                                final SQLXML sqlXml = rs.getSQLXML(i + 1);

                                if (rs.wasNull()) {
                                    // Add a null indicator attribute if the value was SQL Null
                                    builder.addAttribute(
                                            new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX),
                                            "true");
                                } else {

                                    SAXParserFactory factory = SAXParserFactory.newInstance();
                                    factory.setNamespaceAware(true);
                                    InputSource src = new InputSource(sqlXml.getCharacterStream());
                                    SAXParser parser = factory.newSAXParser();
                                    XMLReader xr = parser.getXMLReader();

                                    SAXAdapter adapter = new AppendingSAXAdapter(builder);
                                    xr.setContentHandler(adapter);
                                    xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);
                                    xr.parse(src);
                                }
                            } catch (Exception e) {
                                throw new XPathException(
                                        "Could not parse column of type SQLXML: " + e.getMessage(), e);
                            }
                        } else {
                            //otherwise assume string value
                            final String colValue = rs.getString(i + 1);

                            if (rs.wasNull()) {
                                // Add a null indicator attribute if the value was SQL Null
                                builder.addAttribute(
                                        new QName("null", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), "true");
                            } else {
                                if (colValue != null) {
                                    builder.characters(SQLUtils.escapeXmlText(colValue));
                                }
                            }
                        }

                        builder.endElement();
                    }
                }

                builder.endElement();
                iRow++;
            }

            builder.endElement();
        } else {
            /* SQL Query performed updates */

            builder.startDocument();

            builder.startElement(new QName("result", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
            builder.addAttribute(new QName("updateCount", null, null), String.valueOf(stmt.getUpdateCount()));
            builder.endElement();
        }

        // Change the root element count attribute to have the correct value
        NodeValue node = (NodeValue) builder.getDocument().getDocumentElement();
        Node count = node.getNode().getAttributes().getNamedItem("count");

        if (count != null) {
            count.setNodeValue(String.valueOf(iRow));
        }

        builder.endDocument();

        // return the XML result set
        return (node);

    } catch (SQLException sqle) {
        LOG.error("sql:execute() Caught SQLException \"" + sqle.getMessage() + "\" for SQL: \"" + sql + "\"",
                sqle);

        //return details about the SQLException
        MemTreeBuilder builder = context.getDocumentBuilder();

        builder.startDocument();
        builder.startElement(new QName("exception", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        boolean recoverable = false;

        if (sqle instanceof SQLRecoverableException) {
            recoverable = true;
        }
        builder.addAttribute(new QName("recoverable", null, null), String.valueOf(recoverable));

        builder.startElement(new QName("state", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(sqle.getSQLState());
        builder.endElement();

        builder.startElement(new QName("message", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

        String state = sqle.getMessage();

        if (state != null) {
            builder.characters(state);
        }

        builder.endElement();

        builder.startElement(new QName("stack-trace", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        ByteArrayOutputStream bufStackTrace = new ByteArrayOutputStream();
        sqle.printStackTrace(new PrintStream(bufStackTrace));
        builder.characters(new String(bufStackTrace.toByteArray()));
        builder.endElement();

        builder.startElement(new QName("sql", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.characters(SQLUtils.escapeXmlText(sql));
        builder.endElement();

        if (stmt instanceof PreparedStatement) {
            Element parametersElement = (Element) args[2].itemAt(0);

            if (parametersElement.getNamespaceURI().equals(SQLModule.NAMESPACE_URI)
                    && parametersElement.getLocalName().equals(PARAMETERS_ELEMENT_NAME)) {
                NodeList paramElements = parametersElement.getElementsByTagNameNS(SQLModule.NAMESPACE_URI,
                        PARAM_ELEMENT_NAME);

                builder.startElement(
                        new QName(PARAMETERS_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                for (int i = 0; i < paramElements.getLength(); i++) {
                    Element param = ((Element) paramElements.item(i));
                    String value = param.getFirstChild().getNodeValue();
                    String type = param.getAttributeNS(SQLModule.NAMESPACE_URI, TYPE_ATTRIBUTE_NAME);

                    builder.startElement(
                            new QName(PARAM_ELEMENT_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);

                    builder.addAttribute(
                            new QName(TYPE_ATTRIBUTE_NAME, SQLModule.NAMESPACE_URI, SQLModule.PREFIX), type);
                    builder.characters(SQLUtils.escapeXmlText(value));

                    builder.endElement();
                }

                builder.endElement();
            }
        }

        builder.startElement(new QName("xquery", SQLModule.NAMESPACE_URI, SQLModule.PREFIX), null);
        builder.addAttribute(new QName("line", null, null), String.valueOf(getLine()));
        builder.addAttribute(new QName("column", null, null), String.valueOf(getColumn()));
        builder.endElement();

        builder.endElement();
        builder.endDocument();

        return ((NodeValue) builder.getDocument().getDocumentElement());
    } finally {

        // close any record set or statement
        if (rs != null) {

            try {
                rs.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            rs = null;
        }

        if (!preparedStmt && stmt != null) {

            try {
                stmt.close();
            } catch (SQLException se) {
                LOG.warn("Unable to cleanup JDBC results", se);
            }
            stmt = null;
        }

    }
}

---

From source file:org.exist.xquery.xproc.ProcessFunction.java

public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {

    if (args[0].isEmpty()) {
        return Sequence.EMPTY_SEQUENCE;
    }/* w w  w . j  a  v  a  2 s . c o  m*/

    //        Sequence input = getArgument(0).eval(contextSequence, contextItem);

    UserArgs userArgs = new UserArgs();

    Sequence pipe = args[0];

    if (Type.subTypeOf(pipe.getItemType(), Type.NODE)) {

        if (pipe.getItemCount() != 1) {
            throw new XPathException(this, "Pipeline must have just ONE and only ONE element.");
        }

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStreamWriter osw;
        try {
            osw = new OutputStreamWriter(baos, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new XPathException(this, "Internal error");
        }

        XMLWriter xmlWriter = new XMLWriter(osw);

        SAXSerializer sax = new SAXSerializer();

        sax.setReceiver(xmlWriter);

        try {
            pipe.itemAt(0).toSAX(context.getBroker(), sax, new Properties());
            osw.flush();
            osw.close();
        } catch (Exception e) {
            throw new XPathException(this, e);
        }

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        userArgs.setPipeline(bais, XmldbURI.LOCAL_DB + "/");

    } else {
        userArgs.setPipeline(pipe.getStringValue());
    }

    InputStream defaultIn = null;

    //prepare primary input
    if (args.length > 2) {
        Sequence input = args[1];

        if (Type.subTypeOf(input.getItemType(), Type.NODE)) {

            if (input.getItemCount() != 1) {
                throw new XPathException(this, "Primary input must have just ONE and only ONE element.");
            }

            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            OutputStreamWriter osw;
            try {
                osw = new OutputStreamWriter(baos, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                throw new XPathException(this, "Internal error");
            }

            XMLWriter xmlWriter = new XMLWriter(osw);

            SAXSerializer sax = new SAXSerializer();

            sax.setReceiver(xmlWriter);

            try {
                input.itemAt(0).toSAX(context.getBroker(), sax, new Properties());
                osw.flush();
                osw.close();
            } catch (Exception e) {
                throw new XPathException(this, e);
            }

            defaultIn = new ByteArrayInputStream(baos.toByteArray());

        } else {
            defaultIn = new ByteArrayInputStream(input.getStringValue().getBytes());
        }
    }

    //parse options
    if (args.length > 2) {
        parseOptions(userArgs, args[2]);
    } else if (args.length > 1) {
        parseOptions(userArgs, args[1]);
    }

    String outputResult;
    try {

        //getContext().getModuleLoadPath();

        URI staticBaseURI = null;

        Object key = getContext().getSource().getKey();
        if (key instanceof XmldbURI) {

            String uri = ((XmldbURI) key).removeLastSegment().toString();

            if (!uri.endsWith("/")) {
                uri += "/";
            }

            staticBaseURI = new URI("xmldb", "", uri, null);

        } else {

            String uri = getContext().getModuleLoadPath();
            if (uri == null || uri.isEmpty()) {
                staticBaseURI = new URI(XmldbURI.LOCAL_DB + "/");

            } else {

                if (uri.startsWith(XmldbURI.EMBEDDED_SERVER_URI_PREFIX)) {
                    uri = uri.substring(XmldbURI.EMBEDDED_SERVER_URI_PREFIX.length());
                }
                if (!uri.endsWith("/")) {
                    uri += "/";
                }

                staticBaseURI = new URI("xmldb", "", uri, null);
            }
        }

        outputResult = XProcRunner.run(staticBaseURI, context.getBroker(), userArgs, defaultIn);

    } catch (Exception e) {
        e.printStackTrace();
        throw new XPathException(this, e);
    }

    if (outputResult == null || outputResult.isEmpty()) {
        return Sequence.EMPTY_SEQUENCE;
    }

    StringReader reader = new StringReader(outputResult);
    try {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        InputSource src = new InputSource(reader);

        XMLReader xr = null;

        if (xr == null) {
            SAXParser parser = factory.newSAXParser();
            xr = parser.getXMLReader();
        }

        SAXAdapter adapter = new SAXAdapter(context);
        xr.setContentHandler(adapter);
        xr.setProperty(Namespaces.SAX_LEXICAL_HANDLER, adapter);
        xr.parse(src);

        return (DocumentImpl) adapter.getDocument();
    } catch (ParserConfigurationException e) {
        throw new XPathException(this, "Error while constructing XML parser: " + e.getMessage(), e);
    } catch (SAXException e) {
        throw new XPathException(this, "Error while parsing XML: " + e.getMessage(), e);
    } catch (IOException e) {
        throw new XPathException(this, "Error while parsing XML: " + e.getMessage(), e);
    }
}

---

From source file:org.exoplatform.services.document.impl.MSXPPTDocumentReader.java

/**
 * Extracts the text content of the n first slides 
 *//*  w w w  .j  av  a2 s . c o  m*/
public String getContentAsText(InputStream is, int maxSlides) throws IOException, DocumentReadException {
    if (is == null) {
        throw new IllegalArgumentException("InputStream is null.");
    }
    StringBuilder appendText = new StringBuilder();
    try {

        int slideCount = 0;
        ZipInputStream zis = new ZipInputStream(is);

        try {
            ZipEntry ze = zis.getNextEntry();

            if (ze == null)
                return "";

            XMLReader xmlReader = SAXHelper.newXMLReader();
            xmlReader.setFeature("http://xml.org/sax/features/validation", false);
            xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            Map<Integer, String> slides = new TreeMap<Integer, String>();
            // PPTX: ppt/slides/slide<slide_no>.xml
            while (ze != null && slideCount < maxSlides) {
                String zeName = ze.getName();
                if (zeName.startsWith(PPTX_SLIDE_PREFIX) && zeName.length() > PPTX_SLIDE_PREFIX.length()) {
                    String slideNumberStr = zeName.substring(PPTX_SLIDE_PREFIX.length(),
                            zeName.indexOf(".xml"));
                    int slideNumber = -1;
                    try {
                        slideNumber = Integer.parseInt(slideNumberStr);
                    } catch (NumberFormatException e) {
                        LOG.warn("Could not parse the slide number: " + e.getMessage());
                    }
                    if (slideNumber > -1 && slideNumber <= maxSlides) {
                        MSPPTXContentHandler contentHandler = new MSPPTXContentHandler();
                        xmlReader.setContentHandler(contentHandler);
                        xmlReader.parse(new InputSource((new ByteArrayInputStream(IOUtils.toByteArray(zis)))));
                        slides.put(slideNumber, contentHandler.getContent());
                        slideCount++;
                    }
                }
                ze = zis.getNextEntry();
            }
            for (String slide : slides.values()) {
                appendText.append(slide);
                appendText.append(' ');
            }
        } finally {
            try {
                zis.close();
            } catch (IOException e) {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("An exception occurred: " + e.getMessage());
                }
            }
        }
        return appendText.toString();
    } catch (ParserConfigurationException e) {
        throw new DocumentReadException(e.getMessage(), e);
    } catch (SAXException e) {
        throw new DocumentReadException(e.getMessage(), e);
    } finally {
        try {
            is.close();
        } catch (IOException e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("An exception occurred: " + e.getMessage());
            }
        }
    }
}

---

From source file:org.exoplatform.services.document.impl.MSXPPTDocumentReader.java

public Properties getProperties(InputStream is) throws IOException, DocumentReadException {
    try {/*  ww w.  ja  v  a2  s  .  c o m*/

        ZipInputStream zis = new ZipInputStream(is);
        try {
            ZipEntry ze = zis.getNextEntry();

            while (ze != null && !ze.getName().equals(PPTX_CORE_NAME)) {
                ze = zis.getNextEntry();
            }

            if (ze == null)
                return new Properties();

            MSPPTXMetaHandler metaHandler = new MSPPTXMetaHandler();
            XMLReader xmlReader = SAXHelper.newXMLReader();

            xmlReader.setFeature("http://xml.org/sax/features/validation", false);
            xmlReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
            xmlReader.setFeature("http://xml.org/sax/features/namespaces", true);
            xmlReader.setContentHandler(metaHandler);
            xmlReader.parse(new InputSource(zis));
            return metaHandler.getProperties();
        } finally {
            zis.close();
        }

    } catch (ParserConfigurationException e) {
        throw new DocumentReadException(e.getMessage(), e);
    } catch (SAXException e) {
        throw new DocumentReadException(e.getMessage(), e);
    } finally {
        if (is != null)
            try {
                is.close();
            } catch (IOException e) {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("An exception occurred: " + e.getMessage());
                }
            }
    }
}

---

From source file:org.expath.exist.ftclient.GetResourceMetadataFunction.java

@Override
public Sequence eval(Sequence[] args, Sequence contextSequence) throws XPathException {

    Sequence result = new ValueSequence();

    StreamResult resultAsStreamResult = null;

    try {//  ww w. java2  s  . c  o m
        resultAsStreamResult = ro.kuberam.libs.java.ftclient.GetResourceMetadata
                .getResourceMetadata(ExistExpathFTClientModule.retrieveRemoteConnection(context,
                        ((IntegerValue) args[0].itemAt(0)).getLong()), args[1].getStringValue());
    } catch (Exception ex) {
        throw new XPathException(ex.getMessage());
    }

    ByteArrayInputStream resultDocAsInputStream = null;
    try {
        resultDocAsInputStream = new ByteArrayInputStream(
                resultAsStreamResult.getWriter().toString().getBytes("UTF-8"));
    } catch (UnsupportedEncodingException ex) {
        throw new XPathException(ex.getMessage());
    }

    XMLReader reader = null;

    context.pushDocumentContext();
    try {
        InputSource src = new InputSource(new CloseShieldInputStream(resultDocAsInputStream));

        reader = context.getBroker().getBrokerPool().getParserPool().borrowXMLReader();
        MemTreeBuilder builder = context.getDocumentBuilder();
        DocumentBuilderReceiver receiver = new DocumentBuilderReceiver(builder, true);
        reader.setContentHandler(receiver);
        reader.parse(src);
        Document doc = receiver.getDocument();

        result = (NodeValue) doc;
    } catch (SAXException saxe) {
        // do nothing, we will default to trying to return a string below
    } catch (IOException ioe) {
        // do nothing, we will default to trying to return a string below
    } finally {
        context.popDocumentContext();

        if (reader != null) {
            context.getBroker().getBrokerPool().getParserPool().returnXMLReader(reader);
        }
    }

    return result;
}

---

From source file:org.getobjects.foundation.NSXMLPropertyListParser.java

public Object parse(InputStream _in) {
    if (_in == null)
        return null;

    final SAXParserFactory factory = SAXParserFactory.newInstance();

    try {//from www.j av  a2s .co m
        final NSXMLPlistHandler handler = new NSXMLPlistHandler();
        final XMLReader reader = factory.newSAXParser().getXMLReader();
        final InputSource input = new InputSource(_in);
        reader.setContentHandler(handler);
        reader.setEntityResolver(handler);
        try {
            reader.setFeature("http://xml.org/sax/features/validation", false);
            reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        } catch (Exception e) {
            log.error("Couldn't turn validation off: " + e);
        }
        reader.parse(input);
        return handler.rootObject();
    } catch (ParserConfigurationException e) {
        log.error("error during parser instantiation: " + e);
    } catch (SAXException e) {
        log.error("error during parsing: " + e);
    } catch (IOException e) {
        log.error("error during parsing: " + e);
    }
    return null;
}

---

From source file:org.globus.mds.bigindex.impl.database.xml.xindice.XindiceDriver.java

/**
 * Adds a document file to a collection.
 * @param parentCol - name of the parent collection
 * @param fileName - name of the file/*from   w ww .  j a  v a 2 s .c  o m*/
 * @param docName - name of the document
 * @return String - the document ID.
 * @exception Exception - if the collection does not exist.
 */
public String addDocumentFile(String parentCol, String fileName, String docName) throws Exception {
    checkInitialized();

    Collection col = null;
    String docID = null;
    InputStream fis = null;

    try {
        if (this.isProfiling) {
            this.performanceLogger.start();
        }

        // Create a collection instance
        String colURI = normalizeCollectionURI(parentCol, this.isLocal);
        col = DatabaseManager.getCollection(colURI);
        if (col == null) {
            String err = "XINDICE ERROR: Collection not found! " + colURI;
            if (logger.isDebugEnabled()) {
                logger.debug(err);
            }
            throw new Exception(err);
        }

        // Parse in XML using Xerces
        File file = new File(fileName);
        fis = new FileInputStream(file);

        SAXParserFactory spf = javax.xml.parsers.SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);

        XMLReader saxReader = spf.newSAXParser().getXMLReader();
        StringSerializer ser = new StringSerializer(null);

        saxReader.setContentHandler(ser);
        saxReader.setProperty("http://xml.org/sax/properties/lexical-handler", ser);
        saxReader.parse(new InputSource(fis));

        // Create the XMLResource and store the document
        XMLResource resource = (XMLResource) col.createResource(docName, "XMLResource");
        resource.setContent(ser.toString());
        col.storeResource(resource);
        docID = resource.getId();

        if (logger.isDebugEnabled()) {
            logger.debug("STORED Document: " + colURI + "/" + docID);
        }
        resource = null;
    } finally {
        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {
                logger.debug("Failed to close: " + e.getMessage(), e);
            }
        }
        if (col != null) {
            col.close();
        }
        col = null;
        if (this.isProfiling) {
            this.performanceLogger.stop("addDocumentFile");
        }
    }
    return docID;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• »