Example usage for org.xml.sax XMLReader setEntityResolver

List of usage examples for org.xml.sax XMLReader setEntityResolver

Introduction

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

Prototype

public void setEntityResolver(EntityResolver resolver);

Source Link

Document

Allow an application to register an entity resolver.

Usage

From source file:org.infoscoop.web.MultiRssServlet.java

private void mergeRssAnd2JSON(HttpServletRequest request, HttpServletResponse response, String uid,
        String widgetId, int pageSize, NodeList urlList) throws Exception {

    try {//  w w  w.j  a  va 2s .  c o  m
        RssJsonResultBuilder resultBuilder = new SortedRssJsonResultBuilder(pageSize);

        String dateTimeFormat = request.getHeader("X-IS-DATETIMEFORMAT");
        if (dateTimeFormat != null) {
            dateTimeFormat = URLDecoder.decode(dateTimeFormat, "UTF-8");
        }
        String freshTime = request.getHeader("X-IS-FRESHTIME");
        String maxCountString = request.getHeader("X-IS-RSSMAXCOUNT");
        int maxCount = 1000;
        if (maxCountString != null) {
            try {
                int paramMaxCount = Integer.parseInt(maxCountString);
                if (paramMaxCount >= 0) {
                    maxCount = paramMaxCount;
                }
            } catch (NumberFormatException e) {
                log.warn("rssmaxcount \"" + maxCountString + "\" isn't integer value.");
            }
        }

        // Norrowing
        String titleFilter = request.getHeader("X-IS-TITLEFILTER");
        if (titleFilter != null)
            titleFilter = URLDecoder.decode(titleFilter, "UTF-8");
        String creatorFilter = request.getHeader("X-IS-CREATORFILTER");
        if (creatorFilter != null)
            creatorFilter = URLDecoder.decode(creatorFilter, "UTF-8");
        String categoryFilter = request.getHeader("X-IS-CATEGORYFILTER");
        if (categoryFilter != null)
            categoryFilter = URLDecoder.decode(categoryFilter, "UTF-8");

        int DEFAULT_TIMEOUT = 15 * 1000;

        boolean modified = false;
        Map cacheHeaders = new HashMap();
        Map errorMap = new HashMap();
        List siteCacheHeaders = new ArrayList();
        for (int i = 0; i < urlList.getLength(); i++) {
            Element rssEl = (Element) urlList.item(i);
            String url = rssEl.getAttribute("url");

            ProxyRequest proxyRequest = new ProxyRequest(url, "NoOperation");
            proxyRequest.setLocales(request.getLocales());
            proxyRequest.setPortalUid(uid);

            int timeout = request.getIntHeader("MSDPortal-Timeout") - 1000;
            proxyRequest.setTimeout((timeout > 0) ? timeout : DEFAULT_TIMEOUT);
            //proxyRequest.setTimeout(timeout);

            proxyRequest.addIgnoreHeader("user-agent");
            proxyRequest.addIgnoreHeader("X-IS-DATETIMEFORMAT");
            proxyRequest.addIgnoreHeader("X-IS-FRESHTIME");
            proxyRequest.addIgnoreHeader("X-IS-REFRESH");
            proxyRequest.addIgnoreHeader("X-IS-RSSMAXCOUNT");
            proxyRequest.addIgnoreHeader("X-IS-PAGESIZE");

            Enumeration headers = request.getHeaderNames();
            while (headers.hasMoreElements()) {
                String headerName = (String) headers.nextElement();
                proxyRequest.putRequestHeader(headerName, request.getHeader(headerName));
            }

            NodeList rssChildNodes = rssEl.getElementsByTagName("header");
            for (int j = 0; j < rssChildNodes.getLength(); j++) {
                Element header = (Element) rssChildNodes.item(j);
                if (header.getFirstChild() != null) {
                    String name = header.getAttribute("name");
                    String value = header.getFirstChild().getNodeValue();
                    if (name == null || name.trim().length() == 0 || value == null
                            || value.trim().length() == 0)
                        continue;

                    proxyRequest.putRequestHeader(name, value);
                }
            }

            int statusCode = 0;
            String methodType = rssEl.getAttribute("method");
            try {
                if ("post".equals(methodType)) {
                    statusCode = proxyRequest.executePost();
                } else {
                    statusCode = proxyRequest.executeGet();
                }
            } catch (SocketTimeoutException ex) {
                log.error("url: [" + url + "] socket timeout.", ex);
                errorMap.put(url, new Integer(HttpStatusCode.MSD_SC_TIMEOUT));
            } catch (ConnectTimeoutException ex) {
                log.error("url: [" + url + "] connection timeout.", ex);
                errorMap.put(url, new Integer(500));
            } catch (SocketException ex) {
                log.error("url: [" + url + "] socket error.", ex);
                errorMap.put(url, new Integer(HttpStatus.SC_NOT_FOUND));
            } catch (IOException ex) {
                log.error("url: [" + url + "] I/O error.", ex);
                errorMap.put(url, new Integer(HttpStatus.SC_NOT_FOUND));
            } catch (Exception ex) {
                log.error("url: [" + url + "]" + ex.getMessage(), ex);
                errorMap.put(url, new Integer(500));
            }

            BufferedInputStream bis = null;
            if (errorMap.containsKey(url)) {
                // nothing

            } else if (statusCode == 204) {
                log.warn("url:[" + url + "] is no content #" + statusCode);
                modified = true;
            } else if (statusCode == 304) {
                log.warn("url:[" + url + "] is not modified #" + statusCode);
            } else if (statusCode != 200) {
                log.error("url:[" + url + "] had error status code #" + statusCode);
                errorMap.put(url, new Integer(statusCode));
            } else {
                log.info("url:[" + url + "] is succed #" + statusCode);

                try {
                    modified = true;

                    bis = new BufferedInputStream(proxyRequest.getResponseBody());

                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    byte[] buf = new byte[10240];
                    int c;
                    while ((c = bis.read(buf)) != -1) {
                        baos.write(buf, 0, c);
                        baos.flush();
                    }
                    bis.close();

                    byte[] data = baos.toByteArray();
                    baos.close();

                    //RssCacheDAO.newInstance().insertCache(uid, widgetId+url, -1,data );

                    Map responseHeaders = proxyRequest.getResponseHeaders();
                    String lastModifiedName = "Last-Modified".toLowerCase();
                    if (responseHeaders.containsKey(lastModifiedName)) {
                        siteCacheHeaders.add(lastModifiedName);
                        siteCacheHeaders.add(responseHeaders.get(lastModifiedName));
                    }

                    String etagName = "ETag".toLowerCase();
                    if (responseHeaders.containsKey(etagName)) {
                        siteCacheHeaders.add(etagName);
                        siteCacheHeaders.add(responseHeaders.get(etagName));
                    }

                    if (siteCacheHeaders.size() > 0) {
                        cacheHeaders.put(url, siteCacheHeaders.toArray());
                        siteCacheHeaders.clear();
                    }

                    bis = new BufferedInputStream(new ByteArrayInputStream(data));
                } catch (IOException ex) {
                    log.error("rss reading " + url + " is failed.", ex);
                    cacheHeaders.remove(url);
                    errorMap.put(url, new Integer(500));

                    bis.close();
                    bis = null;
                }
            }

            if (bis == null)
                continue;

            RssHandler handler;

            boolean isAtom = RssFilter.isAtom(bis);

            XMLFilter.skipEmptyLine(bis);
            if (isAtom) {
                handler = new AtomHandler(resultBuilder, dateTimeFormat, freshTime, maxCount, titleFilter,
                        creatorFilter, categoryFilter, i);
            } else {
                handler = new RssHandler(resultBuilder, dateTimeFormat, freshTime, maxCount, titleFilter,
                        creatorFilter, categoryFilter, i);
            }

            try {
                XMLReader reader = factory.newSAXParser().getXMLReader();
                reader.setEntityResolver(NoOpEntityResolver.getInstance());
                reader.setContentHandler(handler);
                reader.parse(new InputSource(bis));
            } catch (SAXException e) {
                log.info("Parsing rss " + url + " is failed.", e);
                cacheHeaders.remove(url);
                errorMap.put(url, new Integer(HttpStatusCode.MSD_SC_CONTENT_PARSE_ERROR));
            }
        }

        if (!modified && errorMap.isEmpty()) {
            log.warn("multi rss is not modified.");
            response.setStatus(304);

            return;
        } else {
            try {
                long freshTimeLong = new Date().getTime();
                if (freshTime != null)
                    freshTimeLong = Long.parseLong(freshTime.trim());
                setOldData(resultBuilder, uid, widgetId, freshTimeLong, titleFilter, creatorFilter,
                        categoryFilter);

            } catch (NumberFormatException e) {
                log.error("", e);
            }

            //}

            int pageCount = resultBuilder.getPageCount();
            // We create the result cash by all means.
            //if( pageCount > 1 ) {
            for (int pageNum = 0; pageNum < pageCount; pageNum++) {
                RssCacheDAO.newInstance().insertCache(uid, widgetId, pageNum, resultBuilder.getResult(pageNum));
            }
            //}
        }

        response.addHeader("Content-Type", "text/plain; charset=UTF-8");

        String result = resultBuilder.getResult();

        if (!errorMap.isEmpty()) {
            JSONObject errors = new JSONObject(errorMap);
            result = "{errors:" + errors.toString() + "," + result.substring(result.indexOf("{") + 1);
        }
        if (!cacheHeaders.isEmpty()) {
            StringBuffer cacheHeadersBuf = new StringBuffer();
            cacheHeadersBuf.append("cacheHeaders : {");
            for (Iterator keys = cacheHeaders.keySet().iterator(); keys.hasNext();) {
                String url = (String) keys.next();
                Object[] headers = (Object[]) cacheHeaders.get(url);

                cacheHeadersBuf.append("\"").append(url).append("\" : {");
                for (int i = 0; i < headers.length; i += 2) {
                    cacheHeadersBuf.append("\"").append(headers[i]).append("\"");
                    cacheHeadersBuf.append(" : '").append(headers[i + 1]).append("'");
                    if (i + 2 < headers.length)
                        cacheHeadersBuf.append(",");
                }
                cacheHeadersBuf.append("}");
                if (keys.hasNext())
                    cacheHeadersBuf.append(",");
            }
            cacheHeadersBuf.append("}");

            result = "{" + cacheHeadersBuf.toString() + "," + result.substring(result.indexOf("{") + 1);
        }

        response.setContentLength(result.getBytes("UTF-8").length);

        OutputStreamWriter out = new OutputStreamWriter(response.getOutputStream(), "UTF-8");
        try {
            out.write(result);

            out.flush();
        } catch (SocketException ex) {
            // ignore client abort exception
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException ex) {
                    // ignore
                }
            }
        }
    } catch (Exception e) {
        log.error("unexpected error occurred.", e);
        response.sendError(500, e.getMessage());
    }

}

From source file:org.infoscoop.web.ValidationServlet.java

private static boolean checkXml(String text) {

    try {/*from   ww w .ja  v a 2s .c om*/
        XMLReader reader = factory.newSAXParser().getXMLReader();
        reader.setEntityResolver(NoOpEntityResolver.getInstance());
        reader.parse(text);
        return true;
    } catch (SAXException e) {
        return false;
    } catch (IOException e) {
        return false;
    } catch (ParserConfigurationException e) {
        return false;
    }
}

From source file:org.jboss.confluence.plugin.docbook_tools.docbookimport.DocbookImporter.java

/**
 * Process XSLT transformation./*  w ww .  j a  va2s.c  o  m*/
 * 
 * @param xsltTemplate input stream with XSLT template file used to transform (closed inside this method)
 * @param xmlToTransform input stream with XML file to transform (closed inside this method)
 * @param xmlToTransformURL URL of <code>xmlToTransform</code> file (may be <code>file://</code> too). We need it to
 *          correctly evaluate relative paths.
 * @param output stream to write transformed output to
 * @throws javax.xml.transform.TransformerException
 */
protected void processXslt(final InputStream xsltTemplate, final InputStream xmlToTransform,
        final String xmlToTransformURL, final OutputStream output) throws Exception {

    final XSLTErrorListener errorListener = new XSLTErrorListener();
    final SAXErrorHandler eh = new SAXErrorHandler();

    Thread th = new Thread(new Runnable() {

        public void run() {
            try {
                org.xml.sax.InputSource xmlSource = new org.xml.sax.InputSource(xmlToTransform);
                xmlSource.setSystemId(xmlToTransformURL);
                javax.xml.transform.Source xsltSource = new javax.xml.transform.stream.StreamSource(
                        xsltTemplate);
                javax.xml.transform.Result result = new javax.xml.transform.stream.StreamResult(output);

                // prepare XInclude aware parser which resolves necessary entities correctly
                XMLReader reader = new ParserAdapter(saxParserFactory.newSAXParser().getParser());
                reader.setEntityResolver(new JDGEntityResolver(reader.getEntityResolver()));
                reader.setErrorHandler(eh);
                SAXSource xmlSAXSource = new SAXSource(reader, xmlSource);

                javax.xml.transform.Transformer trans = transformerFact.newTransformer(xsltSource);

                trans.setErrorListener(errorListener);
                trans.transform(xmlSAXSource, result);

            } catch (Exception e) {
                if (e instanceof TransformerException) {
                    errorListener.setException((TransformerException) e);
                } else {
                    errorListener.setException(new TransformerException(e));
                }
            } finally {
                FileUtils.closeInputStream(xmlToTransform);
                FileUtils.closeInputStream(xsltTemplate);
            }
        }
    });
    th.setName("DocbookImporter XSLT transformation thread");
    th.setDaemon(true);
    th.setContextClassLoader(DocbookImporter.class.getClassLoader());
    th.start();
    th.join();

    if (eh.getException() != null) {
        throw eh.getException();
    }

    if (errorListener.getException() != null) {
        throw errorListener.getException();
    }

}

From source file:org.jbuiltDemo.managed.view.Xhtml2Jbuilt.java

public Xhtml2Jbuilt() throws Exception {
    factory = SAXParserFactory.newInstance();
    factory.setNamespaceAware(true);//  w w w .ja  va  2s. c  o  m
    factory.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
    factory.setFeature("http://xml.org/sax/features/validation", false);
    factory.setValidating(false);

    parser = factory.newSAXParser();
    XMLReader reader = parser.getXMLReader();
    reader.setDTDHandler(this);
    reader.setContentHandler(this);
    reader.setProperty("http://xml.org/sax/properties/lexical-handler", this);
    reader.setErrorHandler(this);
    reader.setEntityResolver(this);
}

From source file:org.mycore.common.content.transformer.MCRXSLTransformer.java

protected XMLReader getXMLReader(LinkedList<TransformerHandler> transformHandlerList) throws SAXException {
    XMLReader reader = XMLReaderFactory.createXMLReader();
    reader.setEntityResolver(ENTITY_RESOLVER);
    reader.setContentHandler(transformHandlerList.getFirst());
    return reader;
}

From source file:org.olat.ims.qti.qpool.ItemFileResourceValidator.java

private boolean validateDocument(Document in) {
    try {/*  w w w .  j  av  a  2  s.c o  m*/
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setValidating(true);
        factory.setNamespaceAware(true);

        SimpleErrorHandler errorHandler = new SimpleErrorHandler();
        ItemContentHandler contentHandler = new ItemContentHandler();

        SAXParser parser = factory.newSAXParser();
        XMLReader reader = parser.getXMLReader();
        reader.setEntityResolver(new IMSEntityResolver());
        reader.setErrorHandler(errorHandler);
        reader.setContentHandler(contentHandler);

        SAXValidator validator = new SAXValidator(reader);
        validator.validate(in);

        return errorHandler.isValid() && contentHandler.isItem();
    } catch (ParserConfigurationException e) {
        return false;
    } catch (SAXException e) {
        return false;
    } catch (Exception e) {
        return false;
    }
}

From source file:org.opencms.xml.CmsXmlUtils.java

/**
 * Validates the structure of a XML document contained in a byte array 
 * with the DTD or XML schema used by the document.<p>
 * /*from  w  ww  . jav a 2 s . c  o m*/
 * @param xmlStream a source providing a XML document that should be validated
 * @param resolver the XML entity resolver to use
 * 
 * @throws CmsXmlException if the validation fails
 */
public static void validateXmlStructure(InputStream xmlStream, EntityResolver resolver) throws CmsXmlException {

    XMLReader reader;
    try {
        reader = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");
    } catch (SAXException e) {
        // xerces parser not available - no schema validation possible
        if (LOG.isWarnEnabled()) {
            LOG.warn(Messages.get().getBundle().key(Messages.LOG_VALIDATION_INIT_XERXES_SAX_READER_FAILED_0),
                    e);
        }
        // no validation of the content is possible
        return;
    }
    // turn on validation
    try {
        reader.setFeature("http://xml.org/sax/features/validation", true);
        // turn on schema validation
        reader.setFeature("http://apache.org/xml/features/validation/schema", true);
        // configure namespace support
        reader.setFeature("http://xml.org/sax/features/namespaces", true);
        reader.setFeature("http://xml.org/sax/features/namespace-prefixes", false);
    } catch (SAXNotRecognizedException e) {
        // should not happen as Xerces 2 support this feature
        if (LOG.isWarnEnabled()) {
            LOG.warn(Messages.get().getBundle().key(Messages.LOG_SAX_READER_FEATURE_NOT_RECOGNIZED_0), e);
        }
        // no validation of the content is possible
        return;
    } catch (SAXNotSupportedException e) {
        // should not happen as Xerces 2 support this feature
        if (LOG.isWarnEnabled()) {
            LOG.warn(Messages.get().getBundle().key(Messages.LOG_SAX_READER_FEATURE_NOT_SUPPORTED_0), e);
        }
        // no validation of the content is possible
        return;
    }

    // add an error handler which turns any errors into XML
    CmsXmlValidationErrorHandler errorHandler = new CmsXmlValidationErrorHandler();
    reader.setErrorHandler(errorHandler);

    if (resolver != null) {
        // set the resolver for the "opencms://" URIs
        reader.setEntityResolver(resolver);
    }

    try {
        reader.parse(new InputSource(xmlStream));
    } catch (IOException e) {
        // should not happen since we read form a byte array
        if (LOG.isErrorEnabled()) {
            LOG.error(Messages.get().getBundle().key(Messages.LOG_READ_XML_FROM_BYTE_ARR_FAILED_0), e);
        }
        return;
    } catch (SAXException e) {
        // should not happen since all errors are handled in the XML error handler
        if (LOG.isErrorEnabled()) {
            LOG.error(Messages.get().getBundle().key(Messages.LOG_PARSE_SAX_EXC_0), e);
        }
        return;
    }

    if (errorHandler.getErrors().elements().size() > 0) {
        // there was at last one validation error, so throw an exception
        StringWriter out = new StringWriter(256);
        OutputFormat format = OutputFormat.createPrettyPrint();
        XMLWriter writer = new XMLWriter(out, format);
        try {
            writer.write(errorHandler.getErrors());
            writer.write(errorHandler.getWarnings());
            writer.close();
        } catch (IOException e) {
            // should not happen since we write to a StringWriter
            if (LOG.isErrorEnabled()) {
                LOG.error(Messages.get().getBundle().key(Messages.LOG_STRINGWRITER_IO_EXC_0), e);
            }
        }
        // generate String from XML for display of document in error message
        throw new CmsXmlException(Messages.get().container(Messages.ERR_XML_VALIDATION_1, out.toString()));
    }
}

From source file:org.openstreetmap.josm.tools.ImageProvider.java

/**
 * Reads the wiki page on a certain file in html format in order to find the real image URL.
 *//*from ww  w.jav  a 2  s  . c  om*/
private static String getImgUrlFromWikiInfoPage(final String base, final String fn) {

    /** Quit parsing, when a certain condition is met */
    class SAXReturnException extends SAXException {
        private String result;

        public SAXReturnException(String result) {
            this.result = result;
        }

        public String getResult() {
            return result;
        }
    }

    try {
        final XMLReader parser = XMLReaderFactory.createXMLReader();
        parser.setContentHandler(new DefaultHandler() {
            @Override
            public void startElement(String uri, String localName, String qName, Attributes atts)
                    throws SAXException {
                System.out.println();
                if (localName.equalsIgnoreCase("img")) {
                    String val = atts.getValue("src");
                    if (val.endsWith(fn))
                        throw new SAXReturnException(val); // parsing done, quit early
                }
            }
        });

        parser.setEntityResolver(new EntityResolver() {
            public InputSource resolveEntity(String publicId, String systemId) {
                return new InputSource(new ByteArrayInputStream(new byte[0]));
            }
        });

        parser.parse(new InputSource(new MirroredInputStream(base + fn,
                new File(Main.pref.getPreferencesDir(), "images").toString())));
    } catch (SAXReturnException r) {
        return r.getResult();
    } catch (Exception e) {
        System.out.println("INFO: parsing " + base + fn + " failed:\n" + e);
        return null;
    }
    System.out.println("INFO: parsing " + base + fn + " failed: Unexpected content.");
    return null;
}

From source file:org.pentaho.reporting.libraries.xmlns.parser.AbstractXmlResourceFactory.java

/**
 * Creates a resource by interpreting the data given in the resource-data object. If additional datastreams need to be
 * parsed, the provided resource manager should be used. This method parses the given resource-data as XML stream.
 *
 * @param manager the resource manager used for all resource loading.
 * @param data    the resource-data from where the binary data is read.
 * @param context the resource context used to resolve relative resource paths.
 * @return the parsed result, never null.
 * @throws ResourceCreationException if the resource could not be parsed due to syntaxctial or logical errors in the
 *                                   data.
 * @throws ResourceLoadingException  if the resource could not be accessed from the physical storage.
 *//*from  ww w .j a  v  a2 s.  c  o m*/
public Resource create(final ResourceManager manager, final ResourceData data, final ResourceKey context)
        throws ResourceCreationException, ResourceLoadingException {
    try {
        final SAXParser parser = getParser();

        final XMLReader reader = parser.getXMLReader();
        final XmlFactoryModule[] rootHandlers = getModules();
        if (rootHandlers.length == 0) {
            throw new ResourceCreationException(
                    "There are no root-handlers registered for the factory for type " + getFactoryType());
        }

        final ResourceDataInputSource input = new ResourceDataInputSource(data, manager);

        final ResourceKey contextKey;
        final long version;
        final ResourceKey targetKey = data.getKey();
        if (context == null) {
            contextKey = targetKey;
            version = data.getVersion(manager);
        } else {
            contextKey = context;
            version = -1;
        }

        final RootXmlReadHandler handler = createRootHandler(manager, targetKey, rootHandlers, contextKey,
                version);

        final DefaultConfiguration parserConfiguration = handler.getParserConfiguration();
        final URL value = manager.toURL(contextKey);
        if (value != null) {
            parserConfiguration.setConfigProperty(CONTENTBASE_KEY, value.toExternalForm());
        }

        configureReader(reader, handler);
        reader.setContentHandler(handler);
        reader.setDTDHandler(handler);
        reader.setEntityResolver(handler.getEntityResolver());
        reader.setErrorHandler(getErrorHandler());

        final Map parameters = targetKey.getFactoryParameters();
        final Iterator it = parameters.keySet().iterator();
        while (it.hasNext()) {
            final Object o = it.next();
            if (o instanceof FactoryParameterKey) {
                final FactoryParameterKey fpk = (FactoryParameterKey) o;
                handler.setHelperObject(fpk.getName(), parameters.get(fpk));
            }
        }

        reader.parse(input);

        final Object createdProduct = finishResult(handler.getResult(), manager, data, contextKey);
        handler.getDependencyCollector().add(targetKey, data.getVersion(manager));
        return createResource(targetKey, handler, createdProduct, getFactoryType());
    } catch (ParserConfigurationException e) {
        throw new ResourceCreationException("Unable to initialize the XML-Parser", e);
    } catch (SAXException e) {
        throw new ResourceCreationException("Unable to parse the document: " + data.getKey(), e);
    } catch (IOException e) {
        throw new ResourceLoadingException("Unable to read the stream from document: " + data.getKey(), e);
    }
}

From source file:org.pentaho.reporting.libraries.xmlns.parser.AbstractXmlResourceFactory.java

/**
 * A method to allow to invoke the parsing without accessing the LibLoader layer. The data to be parsed is held in the
 * given InputSource object.//w w w  .  jav a 2 s .  co m
 *
 * @param manager    the resource manager used for all resource loading.
 * @param input      the raw-data given as SAX-InputSource.
 * @param context    the resource context used to resolve relative resource paths.
 * @param parameters the parse parameters.
 * @return the parsed result, never null.
 * @throws ResourceCreationException    if the resource could not be parsed due to syntaxctial or logical errors in
 *                                      the data.
 * @throws ResourceLoadingException     if the resource could not be accessed from the physical storage.
 * @throws ResourceKeyCreationException if creating the context key failed.
 */
public Object parseDirectly(final ResourceManager manager, final InputSource input, final ResourceKey context,
        final Map parameters)
        throws ResourceKeyCreationException, ResourceCreationException, ResourceLoadingException {
    try {
        final SAXParser parser = getParser();

        final XMLReader reader = parser.getXMLReader();

        final ResourceKey targetKey = manager.createKey(EMPTY_DATA);
        final ResourceKey contextKey;
        if (context == null) {
            contextKey = targetKey;
        } else {
            contextKey = context;
        }

        final XmlFactoryModule[] rootHandlers = getModules();
        final RootXmlReadHandler handler = createRootHandler(manager, targetKey, rootHandlers, contextKey, -1);

        final DefaultConfiguration parserConfiguration = handler.getParserConfiguration();
        final URL value = manager.toURL(contextKey);
        if (value != null) {
            parserConfiguration.setConfigProperty(CONTENTBASE_KEY, value.toExternalForm());
        }

        configureReader(reader, handler);
        reader.setContentHandler(handler);
        reader.setDTDHandler(handler);
        reader.setEntityResolver(handler.getEntityResolver());
        reader.setErrorHandler(getErrorHandler());

        final Iterator it = parameters.keySet().iterator();
        while (it.hasNext()) {
            final Object o = it.next();
            if (o instanceof FactoryParameterKey) {
                final FactoryParameterKey fpk = (FactoryParameterKey) o;
                handler.setHelperObject(fpk.getName(), parameters.get(fpk));
            }
        }

        reader.parse(input);

        return finishResult(handler.getResult(), manager, new RawResourceData(targetKey), contextKey);
    } catch (ParserConfigurationException e) {
        throw new ResourceCreationException("Unable to initialize the XML-Parser", e);
    } catch (SAXException e) {
        throw new ResourceCreationException("Unable to parse the document", e);
    } catch (IOException e) {
        throw new ResourceLoadingException("Unable to read the stream", e);
    }

}