Example usage for javax.xml.transform.sax TemplatesHandler setSystemId

Introduction

In this page you can find the example usage for javax.xml.transform.sax TemplatesHandler setSystemId.

Prototype

public void setSystemId(String systemID);

Source Link

Document

Set the base ID (URI or system ID) for the Templates object created by this builder.

Usage

From source file:Main.java

private static void transformInternal(final URIResolver xslResolver, final StreamSource xml,
        final InputSource xsl, final Map<String, Object> parameters, final StreamResult result)
        throws IOException, ParserConfigurationException, SAXException, TransformerConfigurationException,
        TransformerException {// w  w  w .j  a  va  2 s .c  o  m
    final TransformerFactory tfactory = TransformerFactory.newInstance();
    tfactory.setURIResolver(xslResolver);

    // Does this factory support SAX features?
    if (tfactory.getFeature(SAXSource.FEATURE)) {
        // if so, we can safely cast
        final SAXTransformerFactory stfactory = ((SAXTransformerFactory) tfactory);

        // create a Templates ContentHandler to handle parsing of the
        // stylesheet
        final javax.xml.transform.sax.TemplatesHandler templatesHandler = stfactory.newTemplatesHandler();
        templatesHandler.setDocumentLocator(emptyDocumentLocator);

        final XMLFilter filter = new XMLFilterImpl();
        filter.setParent(makeXMLReader());
        filter.setContentHandler(templatesHandler);

        // parse the stylesheet
        templatesHandler.setSystemId(xsl.getSystemId());
        filter.parse(xsl);

        // set xslt parameters
        final Transformer autobot = templatesHandler.getTemplates().newTransformer();
        if (parameters != null) {
            final Iterator<String> keys = parameters.keySet().iterator();
            while (keys.hasNext()) {
                final String name = keys.next();
                final Object value = parameters.get(name);
                autobot.setParameter(name, value);
            }
        }

        // set saxon parameters
        if (parameters != null) {
            final Iterator<String> keys = parameters.keySet().iterator();
            while (keys.hasNext()) {
                String name = keys.next();
                if (name.startsWith("saxon-")) {
                    final String value = parameters.get(name).toString();
                    name = name.replaceFirst("saxon\\-", "");
                    autobot.setOutputProperty(name, value);
                }
            }
        }

        // do the transform
        // logger.debug("SAX resolving systemIDs relative to: " +
        // templatesHandler.getSystemId());
        autobot.transform(xml, result);

    } else {
        throw new IllegalStateException("Factory doesn't implement SAXTransformerFactory");
    }
}

---

From source file:org.apache.cocoon.components.xslt.TraxProcessor.java

public TransformerHandlerAndValidity getTransformerHandlerAndValidity(Source stylesheet, XMLFilter filter)
        throws XSLTProcessorException {

    final String id = stylesheet.getURI();
    TransformerHandlerAndValidity handlerAndValidity;

    try {//from   w  w  w .  j a v a  2s .  co  m
        handlerAndValidity = getTemplates(stylesheet, id);
        if (handlerAndValidity != null) {
            if (getLogger().isDebugEnabled()) {
                getLogger().debug("Reusing Templates for " + id);
            }
            return handlerAndValidity;
        }
    } catch (Exception e) {
        throw new XSLTProcessorException("Error retrieving template", e);
    }

    TraxErrorListener errorListener = new TraxErrorListener(getLogger(), stylesheet.getURI());
    try {
        if (getLogger().isDebugEnabled()) {
            getLogger().debug("Creating new Templates for " + id);
        }

        m_factory.setErrorListener(errorListener);

        // Create a Templates ContentHandler to handle parsing of the
        // stylesheet.
        TemplatesHandler templatesHandler = m_factory.newTemplatesHandler();

        // Set the system ID for the template handler since some
        // TrAX implementations (XSLTC) rely on this in order to obtain
        // a meaningful identifier for the Templates instances.
        templatesHandler.setSystemId(id);
        if (filter != null) {
            filter.setContentHandler(templatesHandler);
        }

        if (getLogger().isDebugEnabled()) {
            getLogger().debug("Source = " + stylesheet + ", templatesHandler = " + templatesHandler);
        }

        // Initialize List for included validities
        SourceValidity validity = stylesheet.getValidity();
        if (validity != null && m_checkIncludes) {
            m_includesMap.put(id, new ArrayList());
        }

        try {
            // Process the stylesheet.
            sourceToSAX(stylesheet,
                    filter != null ? (ContentHandler) filter : (ContentHandler) templatesHandler);

            // Get the Templates object (generated during the parsing of
            // the stylesheet) from the TemplatesHandler.
            final Templates template = templatesHandler.getTemplates();

            if (null == template) {
                throw new XSLTProcessorException(
                        "Unable to create templates for stylesheet: " + stylesheet.getURI());
            }

            putTemplates(template, stylesheet, id);

            // Create transformer handler
            final TransformerHandler handler = m_factory.newTransformerHandler(template);
            handler.getTransformer().setErrorListener(new TraxErrorListener(getLogger(), stylesheet.getURI()));
            handler.getTransformer().setURIResolver(this);

            // Create aggregated validity
            AggregatedValidity aggregated = null;
            if (validity != null && m_checkIncludes) {
                List includes = (List) m_includesMap.get(id);
                if (includes != null) {
                    aggregated = new AggregatedValidity();
                    aggregated.add(validity);
                    for (int i = includes.size() - 1; i >= 0; i--) {
                        aggregated.add((SourceValidity) ((Object[]) includes.get(i))[1]);
                    }
                    validity = aggregated;
                }
            }

            // Create result
            handlerAndValidity = new MyTransformerHandlerAndValidity(handler, validity);
        } finally {
            if (m_checkIncludes)
                m_includesMap.remove(id);
        }

        return handlerAndValidity;
    } catch (Exception e) {
        Throwable realEx = errorListener.getThrowable();
        if (realEx == null)
            realEx = e;

        if (realEx instanceof RuntimeException) {
            throw (RuntimeException) realEx;
        }

        if (realEx instanceof XSLTProcessorException) {
            throw (XSLTProcessorException) realEx;
        }

        throw new XSLTProcessorException("Exception when creating Transformer from " + stylesheet.getURI(),
                realEx);
    }
}

---