| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.cocoon.transformation; |
| |
| import org.apache.avalon.framework.activity.Disposable; |
| import org.apache.avalon.framework.configuration.Configurable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.parameters.Parameters; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.avalon.framework.service.Serviceable; |
| |
| import org.apache.cocoon.ProcessingException; |
| import org.apache.cocoon.environment.Context; |
| import org.apache.cocoon.environment.ObjectModelHelper; |
| import org.apache.cocoon.environment.Request; |
| import org.apache.cocoon.environment.Response; |
| import org.apache.cocoon.environment.SourceResolver; |
| import org.apache.cocoon.transformation.helpers.ParametersRecorder; |
| import org.apache.cocoon.transformation.helpers.TextRecorder; |
| import org.apache.cocoon.util.ClassUtils; |
| import org.apache.cocoon.util.TraxErrorHandler; |
| import org.apache.cocoon.xml.AttributesImpl; |
| import org.apache.cocoon.xml.ImmutableAttributesImpl; |
| import org.apache.cocoon.xml.IncludeXMLConsumer; |
| import org.apache.cocoon.xml.SaxBuffer; |
| import org.apache.cocoon.xml.XMLConsumer; |
| import org.apache.cocoon.xml.XMLUtils; |
| import org.apache.cocoon.xml.dom.DOMBuilder; |
| |
| import org.apache.excalibur.source.SourceParameters; |
| import org.apache.excalibur.xml.sax.XMLizable; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DocumentFragment; |
| import org.w3c.dom.Node; |
| import org.xml.sax.Attributes; |
| import org.xml.sax.ContentHandler; |
| import org.xml.sax.Locator; |
| import org.xml.sax.SAXException; |
| import org.xml.sax.ext.LexicalHandler; |
| |
| import javax.xml.transform.TransformerFactory; |
| import javax.xml.transform.sax.SAXTransformerFactory; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Stack; |
| |
| /** |
| * This class is the basis for all transformers. It provides various useful |
| * methods and hooks for implementing own custom transformers. |
| * |
| * <p>The basic behaviour of each transformer consists of the following four |
| * parts:</p> |
| * <ul> |
| * <li>Listen for specific events with a given namespace</li> |
| * <li>Collect information via these events</li> |
| * <li>Process the information</li> |
| * <li>Create new events from the processed information</li> |
| * </ul> |
| * |
| * <p>For all these four purposes the AbstractSAXTransformer offers some |
| * powerful methods and hooks:</p> |
| * |
| * <h3>Namespace handling</h3> |
| * By setting the instance variable namespaceURI to the namespace the |
| * events are filtered and only events with this namespace are send to |
| * the two hooks: <code>startTransformingElement</code> and |
| * <code>endTransformingElement</code>. It is possible to override the default |
| * namespace for the transformer by specifying the parameter "namespaceURI" |
| * in the pipeline. This avoids possible namespace collisions. |
| * |
| * <h3>Recording of information</h3> |
| * There are several methods for recording information, e.g. startRecording(), |
| * startTextRecording() etc. These methods collect information from the xml |
| * stream for further processing. |
| * |
| * <h3>Creating new events</h3> |
| * New events can be easily created with the <code>sendEvents()</code> |
| * method, the <code>sendStartElementEvent()</code> methods, the |
| * <code>sendEndElementEvent()</code> method or the |
| * <code>sendTextEvent()</code> method. |
| * |
| * <h3>Initialization</h3> |
| * Before the document is processed the <code>setupTransforming</code> hook |
| * is invoked. |
| * |
| * @author <a href="mailto:cziegeler@s-und-n.de">Carsten Ziegeler</a> |
| * @version $Id$ |
| */ |
| public abstract class AbstractSAXTransformer extends AbstractTransformer |
| implements Serviceable, Configurable, Disposable { |
| |
| /** |
| * Empty immutable attributes (for performance). Use them |
| * whenever creating an element with no attributes. |
| */ |
| protected static final Attributes EMPTY_ATTRIBUTES = XMLUtils.EMPTY_ATTRIBUTES; |
| |
| /** |
| * The trax <code>TransformerFactory</code> used by this transformer. |
| */ |
| private SAXTransformerFactory tfactory; |
| |
| /** |
| * Controlls SAX event handling. |
| * If set to true all whitespace events are ignored. |
| */ |
| protected boolean ignoreWhitespaces; |
| |
| /** |
| * Controlls SAX event handling. |
| * If set to true all characters events containing only whitespaces |
| * are ignored. |
| */ |
| protected boolean ignoreEmptyCharacters; |
| |
| /** |
| * Controlls SAX event handling. |
| * If this is incremented all events are not forwarded to the next |
| * pipeline component, but the hooks are still called. |
| */ |
| protected int ignoreEventsCount; |
| |
| /** |
| * Controlls SAX event handling. |
| * If this is greater than zero, the hooks are not called. Attention, |
| * make sure, that you decrement this counter properly as your hooks are |
| * not called anymore! |
| */ |
| protected int ignoreHooksCount; |
| |
| /** |
| * The namespace used by the transformer for the SAX events filtering. |
| * This either equals to the {@link #defaultNamespaceURI} or to the value |
| * set by the <code>namespaceURI</code> sitemap parameter for the pipeline. |
| * Must never be null. |
| */ |
| protected String namespaceURI; |
| |
| /** |
| * This is the default namespace used by the transformer. |
| * Implementations should set its value in the constructor. |
| * Must never be null. |
| */ |
| protected String defaultNamespaceURI; |
| |
| /** |
| * A stack for collecting information. |
| * The stack is important for collection information especially when |
| * the tags can be nested. |
| */ |
| protected final Stack stack = new Stack(); |
| |
| /** |
| * The stack of current used recorders |
| */ |
| protected final Stack recorderStack = new Stack(); |
| |
| /** |
| * The current Request object |
| */ |
| protected Request request; |
| |
| /** |
| * The current Response object |
| */ |
| protected Response response; |
| |
| /** |
| * The current Context object |
| */ |
| protected Context context; |
| |
| /** |
| * The current objectModel of the environment |
| */ |
| protected Map objectModel; |
| |
| /** |
| * The parameters specified in the sitemap |
| */ |
| protected Parameters parameters; |
| |
| /** |
| * The source attribute specified in the sitemap |
| */ |
| protected String source; |
| |
| /** |
| * The Avalon ServiceManager for getting Components |
| */ |
| protected ServiceManager manager; |
| |
| /** |
| * The SourceResolver for this request |
| */ |
| protected SourceResolver resolver; |
| |
| /** |
| * Are we already initialized for the current request? |
| */ |
| private boolean isInitialized; |
| |
| /** |
| * Empty attributes (for performance). This can be used |
| * do create own attributes, but make sure to clean them |
| * afterwords. |
| * @deprecated Use {@link AbstractSAXTransformer#EMPTY_ATTRIBUTES}. |
| */ |
| protected Attributes emptyAttributes = EMPTY_ATTRIBUTES; |
| |
| /** |
| * The namespaces and their prefixes |
| */ |
| private final List namespaces = new ArrayList(5); |
| |
| /** |
| * The current prefix for our namespace |
| */ |
| private String ourPrefix; |
| |
| // |
| // Lifecycle |
| // |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.framework.service.Serviceable#service(ServiceManager) |
| */ |
| public void service(ServiceManager manager) throws ServiceException { |
| this.manager = manager; |
| } |
| |
| /* (non-Javadoc) |
| * @see Configurable#configure(Configuration) |
| */ |
| public void configure(Configuration configuration) throws ConfigurationException { |
| String tFactoryClass = configuration.getChild("transformer-factory").getValue(null); |
| if (tFactoryClass != null) { |
| try { |
| this.tfactory = (SAXTransformerFactory) ClassUtils.newInstance(tFactoryClass); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Using transformer factory " + tFactoryClass); |
| } |
| } catch (Exception e) { |
| throw new ConfigurationException("Cannot load transformer factory " + tFactoryClass, e); |
| } |
| } else { |
| // Standard TrAX behaviour |
| this.tfactory = (SAXTransformerFactory) TransformerFactory.newInstance(); |
| } |
| tfactory.setErrorListener(new TraxErrorHandler(getLogger())); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.cocoon.sitemap.SitemapModelComponent#setup(SourceResolver, Map, String, Parameters) |
| */ |
| public void setup(SourceResolver resolver, |
| Map objectModel, |
| String src, |
| Parameters params) |
| throws ProcessingException, SAXException, IOException { |
| |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Setup resolver=" + resolver + |
| ", objectModel=" + objectModel + |
| ", src=" + src + |
| ", parameters=" + params); |
| } |
| |
| // defaultNamespaceURI should never be null |
| if (this.defaultNamespaceURI == null) { |
| this.defaultNamespaceURI = ""; |
| } |
| this.objectModel = objectModel; |
| |
| this.request = ObjectModelHelper.getRequest(objectModel); |
| this.response = ObjectModelHelper.getResponse(objectModel); |
| this.context = ObjectModelHelper.getContext(objectModel); |
| this.resolver = resolver; |
| this.parameters = params; |
| this.source = src; |
| this.isInitialized = false; |
| |
| // get the current namespace |
| this.namespaceURI = params.getParameter("namespaceURI", |
| this.defaultNamespaceURI); |
| |
| this.ignoreHooksCount = 0; |
| this.ignoreEventsCount = 0; |
| this.ignoreWhitespaces = true; |
| this.ignoreEmptyCharacters = false; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.avalon.excalibur.pool.Recyclable#recycle() |
| */ |
| public void recycle() { |
| this.namespaceURI = null; |
| this.objectModel = null; |
| this.request = null; |
| this.response = null; |
| this.context = null; |
| this.resolver = null; |
| this.stack.clear(); |
| this.recorderStack.clear(); |
| this.parameters = null; |
| this.source = null; |
| this.namespaces.clear(); |
| this.ourPrefix = null; |
| |
| super.recycle(); |
| } |
| |
| public void dispose() { |
| this.manager = null; |
| } |
| |
| // |
| // SAX ContentHandler methods |
| // |
| |
| /** |
| * Process the SAX event. |
| * @see ContentHandler#setDocumentLocator |
| */ |
| public void setDocumentLocator(Locator locator) { |
| if (this.ignoreEventsCount == 0) { |
| super.setDocumentLocator(locator); |
| } |
| } |
| |
| /** |
| * Process the SAX event. A new document is processed. The hook method |
| * {@link #setupTransforming} is invoked. |
| * @see ContentHandler#startDocument |
| */ |
| public void startDocument() |
| throws SAXException { |
| if (!this.isInitialized) { |
| try { |
| setupTransforming(); |
| } catch (ProcessingException e) { |
| throw new SAXException("ProcessingException: " + e, e); |
| } catch (IOException e) { |
| throw new SAXException("IOException: " + e, e); |
| } |
| this.isInitialized = true; |
| } |
| |
| if (this.ignoreEventsCount == 0) { |
| super.startDocument(); |
| } |
| } |
| |
| /** |
| * Process the SAX event. The processing of the document is finished. |
| * @see org.xml.sax.ContentHandler#endDocument |
| */ |
| public void endDocument() |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.endDocument(); |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see org.xml.sax.ContentHandler#startPrefixMapping |
| */ |
| public void startPrefixMapping(String prefix, String uri) |
| throws SAXException { |
| if (prefix != null) { |
| this.namespaces.add(new String[] {prefix, uri}); |
| } |
| if (namespaceURI.equals(uri)) { |
| this.ourPrefix = prefix; |
| } |
| if (this.ignoreEventsCount == 0) { |
| super.startPrefixMapping(prefix, uri); |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see org.xml.sax.ContentHandler#endPrefixMapping |
| */ |
| public void endPrefixMapping(String prefix) |
| throws SAXException { |
| |
| if (prefix != null) { |
| // Find and remove the namespace prefix |
| boolean found = false; |
| for (int i = this.namespaces.size() - 1; i >= 0; i--) { |
| final String[] prefixAndUri = (String[]) this.namespaces.get(i); |
| if (prefixAndUri[0].equals(prefix)) { |
| this.namespaces.remove(i); |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| throw new SAXException("Namespace for prefix '" + prefix + "' not found."); |
| } |
| |
| if (prefix.equals(this.ourPrefix)) { |
| // Reset our current prefix |
| this.ourPrefix = null; |
| |
| // Now search if we have a different prefix for our namespace |
| for (int i = this.namespaces.size() - 1; i >= 0; i--) { |
| final String[] prefixAndUri = (String[]) this.namespaces.get(i); |
| if (namespaceURI.equals(prefixAndUri[1])) { |
| this.ourPrefix = prefixAndUri[0]; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (this.ignoreEventsCount == 0) { |
| super.endPrefixMapping(prefix); |
| } |
| } |
| |
| /** |
| * Process the SAX event. The namespace of the event is checked. |
| * If it is the defined namespace for this transformer, |
| * the {@link #startTransformingElement} hook is called. |
| * @see org.xml.sax.ContentHandler#startElement |
| */ |
| public void startElement(String uri, |
| String name, |
| String raw, |
| Attributes attr) |
| throws SAXException { |
| if (namespaceURI.equals(uri) && ignoreHooksCount == 0) { |
| // this is our namespace: |
| try { |
| startTransformingElement(uri, name, raw, attr); |
| } catch (ProcessingException e) { |
| throw new SAXException("ProcessingException: " + e, e); |
| } catch (IOException e) { |
| throw new SAXException("IOException occured during processing: " + e, e); |
| } |
| } else { |
| if (ignoreEventsCount == 0) { |
| super.startElement(uri, name, raw, attr); |
| } |
| } |
| } |
| |
| /** |
| * Process the SAX event. The namespace of the event is checked. |
| * If it is the defined namespace for this transformer, |
| * the {@link #endTransformingElement} hook is called. |
| * @see org.xml.sax.ContentHandler#endElement |
| */ |
| public void endElement(String uri, String name, String raw) |
| throws SAXException { |
| if (namespaceURI.equals(uri) && this.ignoreHooksCount == 0) { |
| // this is our namespace: |
| try { |
| endTransformingElement(uri, name, raw); |
| } catch (ProcessingException e) { |
| throw new SAXException("ProcessingException: " + e, e); |
| } catch (IOException e) { |
| throw new SAXException("IOException occured during processing: " + e, e); |
| } |
| } else { |
| if (ignoreEventsCount == 0) { |
| super.endElement(uri, name, raw); |
| } |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see org.xml.sax.ContentHandler#characters |
| */ |
| public void characters(char[] p0, int p1, int p2) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| if (this.ignoreEmptyCharacters) { |
| String value = new String(p0, p1, p2); |
| if (value.trim().length() > 0) { |
| super.characters(p0, p1, p2); |
| } |
| } else { |
| super.characters(p0, p1, p2); |
| } |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see org.xml.sax.ContentHandler#ignorableWhitespace |
| */ |
| public void ignorableWhitespace(char[] p0, int p1, int p2) |
| throws SAXException { |
| if (ignoreWhitespaces == false && ignoreEventsCount == 0) { |
| super.ignorableWhitespace(p0, p1, p2); |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see ContentHandler#processingInstruction |
| */ |
| public void processingInstruction(String target, String data) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.processingInstruction(target, data); |
| } |
| } |
| |
| /** |
| * Process the SAX event. |
| * @see ContentHandler#skippedEntity |
| */ |
| public void skippedEntity(String name) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.skippedEntity(name); |
| } |
| } |
| |
| // |
| // SAX LexicalHandler methods |
| // |
| |
| /** |
| * @see LexicalHandler#startDTD |
| */ |
| public void startDTD(String name, String public_id, String system_id) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.startDTD(name, public_id, system_id); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#endDTD |
| */ |
| public void endDTD() throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.endDTD(); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#startEntity |
| */ |
| public void startEntity (String name) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.startEntity(name); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#endEntity |
| */ |
| public void endEntity (String name) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.endEntity(name); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#startCDATA |
| */ |
| public void startCDATA() throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.startCDATA(); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#endCDATA |
| */ |
| public void endCDATA() throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.endCDATA(); |
| } |
| } |
| |
| /** |
| * @see LexicalHandler#comment |
| */ |
| public void comment(char ary[], int start, int length) |
| throws SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.comment(ary, start, length); |
| } |
| } |
| |
| |
| /* |
| * Recording of events. |
| * With this method all events are not forwarded to the next component in the pipeline. |
| * They are recorded to create a document fragment. |
| */ |
| |
| private LexicalHandler originalLexicalHandler; |
| private ContentHandler originalContentHandler; |
| |
| /** |
| * Add a new recorder to the recording chain. |
| * Do not invoke this method directly. |
| */ |
| protected void addRecorder(XMLConsumer recorder) { |
| if (this.recorderStack.empty()) { |
| // redirect if first (top) recorder |
| this.originalLexicalHandler = this.lexicalHandler; |
| this.originalContentHandler = this.contentHandler; |
| } |
| setContentHandler(recorder); |
| setLexicalHandler(recorder); |
| this.recorderStack.push(recorder); |
| } |
| |
| /** |
| * Remove a recorder from the recording chain. |
| * Do not invoke this method directly. |
| */ |
| protected Object removeRecorder() { |
| Object recorder = this.recorderStack.pop(); |
| if (this.recorderStack.empty() == true) { |
| // undo redirect if no recorder any more |
| setContentHandler(originalContentHandler); |
| setLexicalHandler(originalLexicalHandler); |
| this.originalLexicalHandler = null; |
| this.originalContentHandler = null; |
| } else { |
| XMLConsumer next = (XMLConsumer) recorderStack.peek(); |
| setContentHandler(next); |
| setLexicalHandler(next); |
| } |
| |
| return recorder; |
| } |
| |
| /** |
| * Start recording of SAX events. |
| * All incoming events are recorded and not forwarded. The resulting |
| * XMLizable can be obtained by the matching {@link #endSAXRecording} call. |
| * @since 2.1.5 |
| */ |
| public void startSAXRecording() |
| throws SAXException { |
| addRecorder(new SaxBuffer()); |
| sendStartPrefixMapping(); |
| } |
| |
| /** |
| * Stop recording of SAX events. |
| * This method returns the resulting XMLizable. |
| * @since 2.1.5 |
| */ |
| public XMLizable endSAXRecording() |
| throws SAXException { |
| sendEndPrefixMapping(); |
| return (XMLizable) removeRecorder(); |
| } |
| |
| /** |
| * Start recording of a text. |
| * No events forwarded, and all characters events |
| * are collected into a string. |
| */ |
| public void startTextRecording() |
| throws SAXException { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Start text recording"); |
| } |
| addRecorder(new TextRecorder()); |
| sendStartPrefixMapping(); |
| } |
| |
| /** |
| * Stop recording of text and return the recorded information. |
| * @return The String, trimmed. |
| */ |
| public String endTextRecording() |
| throws SAXException { |
| sendEndPrefixMapping(); |
| |
| TextRecorder recorder = (TextRecorder) removeRecorder(); |
| String text = recorder.getText(); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("End text recording. Text=" + text); |
| } |
| return text; |
| } |
| |
| /** |
| * Start recording of serialized xml |
| * All events are converted to an xml string which can be retrieved by |
| * endSerializedXMLRecording. |
| * @param format The format for the serialized output. If <CODE>null</CODE> |
| * is specified, the default format is used. |
| */ |
| public void startSerializedXMLRecording(Properties format) |
| throws SAXException { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Start serialized XML recording. Format=" + format); |
| } |
| this.stack.push(format == null? XMLUtils.createPropertiesForXML(false): format); |
| startSAXRecording(); |
| } |
| |
| /** |
| * Return the serialized xml string. |
| * @return A string containing the recorded xml information, formatted by |
| * the properties passed to the corresponding startSerializedXMLRecording(). |
| */ |
| public String endSerializedXMLRecording() |
| throws SAXException, ProcessingException { |
| XMLizable xml = endSAXRecording(); |
| String text = XMLUtils.serialize(xml, (Properties) this.stack.pop()); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("End serialized XML recording. XML=" + text); |
| } |
| return text; |
| } |
| |
| /** |
| * Start recording of parameters. |
| * All events are not forwarded and the incoming xml is converted to |
| * parameters. Each toplevel node is a parameter and its text subnodes |
| * form the value. |
| * The Parameters can eiter be retrieved by endParametersRecording(). |
| */ |
| public void startParametersRecording() |
| throws SAXException { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Start parameters recording"); |
| } |
| addRecorder(new ParametersRecorder()); |
| sendStartPrefixMapping(); |
| } |
| |
| /** |
| * End recording of parameters |
| * If source is null a new parameters object is created, otherwise |
| * the parameters are added to this object. |
| * @param source An optional parameters object. |
| * @return The object containing all parameters. |
| */ |
| public SourceParameters endParametersRecording(Parameters source) |
| throws SAXException { |
| sendEndPrefixMapping(); |
| |
| ParametersRecorder recorder = (ParametersRecorder) this.removeRecorder(); |
| SourceParameters parameters = recorder.getParameters(source); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("End parameters recording. Parameters=" + parameters); |
| } |
| return parameters; |
| } |
| |
| /** |
| * End recording of parameters |
| * If source is null a new parameters object is created, otherwise |
| * the parameters are added to this object. |
| * @param source An optional parameters object. |
| * @return The object containing all parameters. |
| */ |
| public SourceParameters endParametersRecording(SourceParameters source) |
| throws SAXException { |
| sendEndPrefixMapping(); |
| |
| ParametersRecorder recorder = (ParametersRecorder) removeRecorder(); |
| SourceParameters parameters = recorder.getParameters(source); |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("End parameters recording. Parameters=" + parameters); |
| } |
| return parameters; |
| } |
| |
| /** |
| * Start DOM DocumentFragment recording. |
| * All incoming events are recorded and not forwarded. The resulting |
| * DocumentFragment can be obtained by the matching {@link #endRecording} call. |
| */ |
| public void startRecording() |
| throws SAXException { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("Start recording"); |
| } |
| DOMBuilder builder = new DOMBuilder(this.tfactory); |
| addRecorder(builder); |
| builder.startDocument(); |
| builder.startElement("", "cocoon", "cocoon", EMPTY_ATTRIBUTES); |
| sendStartPrefixMapping(); |
| } |
| |
| /** |
| * Stop DOM DocumentFragment recording. |
| * This method returns the resulting DocumentFragment, normalized. |
| */ |
| public DocumentFragment endRecording() |
| throws SAXException { |
| sendEndPrefixMapping(); |
| |
| DOMBuilder builder = (DOMBuilder) removeRecorder(); |
| builder.endElement("", "cocoon", "cocoon"); |
| builder.endDocument(); |
| |
| // Create Document Fragment |
| final Document doc = builder.getDocument(); |
| final DocumentFragment fragment = doc.createDocumentFragment(); |
| final Node root = doc.getDocumentElement(); |
| |
| // Remove empty text nodes and collapse neighbouring text nodes |
| root.normalize(); |
| |
| // Move all nodes into the fragment |
| boolean space = true; |
| while (root.hasChildNodes()) { |
| Node child = root.getFirstChild(); |
| root.removeChild(child); |
| |
| // Leave out leading whitespace nodes |
| // FIXME: Why leading spaces are trimmed at all? Why not trailing spaces? |
| if (space && child.getNodeType() == Node.TEXT_NODE |
| && child.getNodeValue().trim().length() == 0) { |
| continue; |
| } |
| space = false; |
| |
| fragment.appendChild(child); |
| } |
| |
| if (getLogger().isDebugEnabled()) { |
| Object serializedXML = null; |
| try { |
| serializedXML = fragment == null? "null": XMLUtils.serializeNode(fragment, XMLUtils.createPropertiesForXML(false)); |
| } catch (ProcessingException ignore) { |
| serializedXML = fragment; |
| } |
| getLogger().debug("End recording. Fragment=" + serializedXML); |
| } |
| |
| return fragment; |
| } |
| |
| // |
| // Hooks |
| // |
| |
| /** |
| * Setup the transformation of an xml document. |
| * This method is called just before the transformation (sending of sax events) |
| * starts. It should be used to initialize setup parameter depending on the |
| * object modell. |
| */ |
| public void setupTransforming() |
| throws IOException, ProcessingException, SAXException { |
| if (getLogger().isDebugEnabled()) { |
| getLogger().debug("setupTransforming"); |
| } |
| this.stack.clear(); |
| this.recorderStack.clear(); |
| this.ignoreWhitespaces = true; |
| this.ignoreEmptyCharacters = false; |
| } |
| |
| /** |
| * Start processing elements of our namespace. |
| * This hook is invoked for each sax event with our namespace. |
| * @param uri The namespace of the element. |
| * @param name The local name of the element. |
| * @param raw The qualified name of the element. |
| * @param attr The attributes of the element. |
| */ |
| public void startTransformingElement(String uri, |
| String name, |
| String raw, |
| Attributes attr) |
| throws ProcessingException, IOException, SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.startElement(uri, name, raw, attr); |
| } |
| } |
| |
| /** |
| * Start processing elements of our namespace. |
| * This hook is invoked for each sax event with our namespace. |
| * @param uri The namespace of the element. |
| * @param name The local name of the element. |
| * @param raw The qualified name of the element. |
| */ |
| public void endTransformingElement(String uri, |
| String name, |
| String raw) |
| throws ProcessingException, IOException, SAXException { |
| if (this.ignoreEventsCount == 0) { |
| super.endElement(uri, name, raw); |
| } |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The characters event for the given text is send to the next |
| * component in the current pipeline. |
| * @param text The string containing the information. |
| */ |
| public void sendTextEvent(String text) |
| throws SAXException { |
| characters(text.toCharArray(), 0, text.length()); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The startElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has no namespace and no attributes |
| * @param localname The name of the event. |
| */ |
| public void sendStartElementEvent(String localname) |
| throws SAXException { |
| startElement("", localname, localname, EMPTY_ATTRIBUTES); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The startElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has the namespace of the transformer, |
| * but not attributes |
| * @param localname The name of the event. |
| */ |
| public void sendStartElementEventNS(String localname) |
| throws SAXException { |
| startElement(this.namespaceURI, |
| localname, this.ourPrefix + ':' + localname, EMPTY_ATTRIBUTES); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The startElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has no namespace. |
| * @param localname The name of the event. |
| * @param attr The Attributes of the element |
| */ |
| public void sendStartElementEvent(String localname, Attributes attr) |
| throws SAXException { |
| startElement("", localname, localname, attr); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The startElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has the namespace of the transformer. |
| * @param localname The name of the event. |
| * @param attr The Attributes of the element |
| */ |
| public void sendStartElementEventNS(String localname, Attributes attr) |
| throws SAXException { |
| startElement(this.namespaceURI, |
| localname, this.ourPrefix + ':' + localname, attr); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The endElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has no namespace. |
| * @param localname The name of the event. |
| */ |
| public void sendEndElementEvent(String localname) |
| throws SAXException { |
| endElement("", localname, localname); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The endElement event for the given element is send |
| * to the next component in the current pipeline. |
| * The element has the namespace of the transformer. |
| * @param localname The name of the event. |
| */ |
| public void sendEndElementEventNS(String localname) |
| throws SAXException { |
| endElement(this.namespaceURI, |
| localname, this.ourPrefix + ':' + localname); |
| } |
| |
| /** |
| * Send SAX events to the next pipeline component. |
| * The node is parsed and the events are send to |
| * the next component in the pipeline. |
| * @param node The tree to be included. |
| */ |
| public void sendEvents(Node node) |
| throws SAXException { |
| IncludeXMLConsumer.includeNode(node, this, this); |
| } |
| |
| /** |
| * Send SAX events for the <code>SourceParameters</code>. |
| * For each parametername/value pair an element is |
| * created with the name of the parameter and the content |
| * of this element is the value. |
| */ |
| public void sendParametersEvents(SourceParameters pars) |
| throws SAXException { |
| |
| if (pars != null) { |
| Iterator names = pars.getParameterNames(); |
| while (names.hasNext()) { |
| final String currentName = (String)names.next(); |
| Iterator values = pars.getParameterValues(currentName); |
| while (values.hasNext()) { |
| final String currentValue = (String)values.next(); |
| sendStartElementEvent(currentName); |
| sendTextEvent(currentValue); |
| sendEndElementEvent(currentName); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Send all start prefix mapping events to the current content handler |
| */ |
| protected void sendStartPrefixMapping() |
| throws SAXException { |
| final int l = this.namespaces.size(); |
| for (int i = 0; i < l; i++) { |
| String[] prefixAndUri = (String[]) this.namespaces.get(i); |
| super.contentHandler.startPrefixMapping(prefixAndUri[0], prefixAndUri[1]); |
| } |
| } |
| |
| /** |
| * Send all end prefix mapping events to the current content handler |
| */ |
| protected void sendEndPrefixMapping() |
| throws SAXException { |
| final int l = this.namespaces.size(); |
| for (int i = 0; i < l; i++) { |
| String[] prefixAndUri = (String[]) this.namespaces.get(i); |
| super.contentHandler.endPrefixMapping(prefixAndUri[0]); |
| } |
| } |
| |
| /** |
| * Find prefix mapping for the given namespace URI. |
| * @return Prefix mapping or null if no prefix defined |
| */ |
| protected String findPrefixMapping(String uri) { |
| final int l = this.namespaces.size(); |
| for (int i = 0; i < l; i++) { |
| String[] prefixAndUri = (String[]) this.namespaces.get(i); |
| if (prefixAndUri[1].equals(uri)) { |
| return prefixAndUri[0]; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Helper method to get a modifiable attribute set. |
| */ |
| protected AttributesImpl getMutableAttributes(Attributes a) { |
| if ( a instanceof AttributesImpl && !(a instanceof ImmutableAttributesImpl)) { |
| return (AttributesImpl)a; |
| } |
| return new AttributesImpl(a); |
| } |
| } |
