RELEASE_2_1_13/src/java/org/apache/cocoon/components/xpointer/ElementPathPart.java

/*
 * 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.components.xpointer;

import org.xml.sax.SAXException;
import org.xml.sax.Attributes;
import org.xml.sax.Locator;
import org.apache.cocoon.xml.AbstractXMLPipe;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.ProcessingException;

import java.util.StringTokenizer;
import java.util.ArrayList;
import java.io.IOException;

/**
 * A custom XPointer scheme that allows to include the content of a specific element without
 * building a DOM. The element must be specified using an absolute path reference such as
 * <tt>/html/body</tt>. Namespace prefixes within these element names are supported.
 *
 * <p>This xpointer scheme will always be succesful (thus any further xpointer parts will
 * never be executed).
 *
 * <p>The scheme name for this XPointer scheme is 'elementpath' and its namespace is
 * http://apache.org/cocoon/xpointer.
 *
 * <p>See the samples for a usage example.
 */
public class ElementPathPart implements PointerPart {
    private String expression;

    public ElementPathPart(String expression) {
        this.expression = expression;
    }

    public boolean process(XPointerContext xpointerContext) throws SAXException {
        PathInclusionPipe pipe = new PathInclusionPipe(expression, xpointerContext);
        pipe.setConsumer(xpointerContext.getXmlConsumer());
        try {
            SourceUtil.toSAX(xpointerContext.getSource(), pipe);
        } catch (IOException e) {
            throw new SAXException("Exception while trying to XInclude data: " + e.getMessage(), e);
        } catch (ProcessingException e) {
            throw new SAXException("Exception while trying to XInclude data: " + e.getMessage(), e);
        }
        return true;
    }

    public static class PathInclusionPipe extends AbstractXMLPipe {
        /** The QNames that must be matched before inclusion can start. */
        private QName[] elementPath;
        /** The current element nesting level. */
        private int level;
        /** Should we currently be including? */
        private boolean include;
        /** The element nesting level since we started inclusion, used to know when to stop inclusion. */
        private int includeLevel;

        /** The element nesting level that should currently be matched. */
        private int levelToMatch;
        private boolean done;

        public PathInclusionPipe(String expression, XPointerContext xpointerContext) throws SAXException {
            // parse the expression to an array of QName objects
            ArrayList path = new ArrayList();
            StringTokenizer tokenizer = new StringTokenizer(expression, "/");
            while (tokenizer.hasMoreTokens()) {
                String token = tokenizer.nextToken();
                try {
                    path.add(QName.parse(token, xpointerContext));
                } catch (SAXException e) {
                    throw new SAXException("Error in element path xpointer expression \"" + expression + "\": " + e.getMessage());
                }
            }
            if (path.size() < 1)
                throw new SAXException("Invalid element path xpointer expression \"" + expression + "\".");

            this.elementPath = (QName[])path.toArray(new QName[path.size()]);
            this.level = -1;
            this.include = false;
            this.levelToMatch = 0;
            this.done = false;
        }

        public void startElement(String namespaceURI, String localName, String raw, Attributes a)
                throws SAXException {
            level++;

            if (include) {
                super.startElement(namespaceURI, localName, raw, a);
                return;
            }

            if (!done && level == levelToMatch && elementPath[level].matches(namespaceURI, localName)) {
                levelToMatch++;
                if (levelToMatch == elementPath.length) {
                    include = true;
                    done = true;
                    includeLevel = level;
                }
            }
        }

        public void endElement(String uri, String loc, String raw)
                throws SAXException {
            if (include && level == includeLevel)
                include = false;

            if (include)
                super.endElement(uri, loc, raw);

            level--;
        }

        public void setDocumentLocator(Locator locator) {
            if (include)
                super.setDocumentLocator(locator);
        }

        public void startDocument()
                throws SAXException {
            if (include)
                super.startDocument();
        }

        public void endDocument()
                throws SAXException {
            if (include)
                super.endDocument();
        }

        public void characters(char c[], int start, int len)
                throws SAXException {
            if (include)
                super.characters(c, start, len);
        }

        public void ignorableWhitespace(char c[], int start, int len)
                throws SAXException {
            if (include)
                super.ignorableWhitespace(c, start, len);
        }

        public void processingInstruction(String target, String data)
                throws SAXException {
            if (include)
                super.processingInstruction(target, data);
        }

        public void skippedEntity(String name)
                throws SAXException {
            if (include)
                super.skippedEntity(name);
        }

        public void startDTD(String name, String publicId, String systemId)
                throws SAXException {
            if (include)
                super.startDTD(name, publicId, systemId);
        }

        public void endDTD()
                throws SAXException {
            if (include)
                super.endDTD();
        }

        public void startEntity(String name)
                throws SAXException {
            if (include)
                super.startEntity(name);
        }

        public void endEntity(String name)
                throws SAXException {
            if (include)
                super.endEntity(name);
        }

        public void startCDATA()
                throws SAXException {
            if (include)
                super.startCDATA();
        }

        public void endCDATA()
                throws SAXException {
            if (include)
                super.endCDATA();
        }

        public void comment(char ch[], int start, int len)
                throws SAXException {
            if (include)
                super.comment(ch, start, len);
        }

        public static class QName {
            private String namespaceURI;
            private String localName;

            public QName(String namespaceURI, String localName) {
                this.namespaceURI = namespaceURI;
                this.localName = localName;
            }

            public static QName parse(String qName, XPointerContext xpointerContext) throws SAXException {
                int pos = qName.indexOf(':');
                if (pos > 0) {
                    String prefix = qName.substring(0, pos);
                    String localName = qName.substring(pos + 1);
                    String namespaceURI = xpointerContext.prefixToNamespace(prefix);
                    if (namespaceURI == null)
                        throw new SAXException("Namespace prefix \"" + prefix + "\" not declared.");
                    return new QName(prefix, localName);
                }
                return new QName("", qName);
            }

            public String getNamespaceURI() {
                return namespaceURI;
            }

            public String getLocalName() {
                return localName;
            }

            public boolean matches(String namespaceURI, String localName) {
                return this.localName.equals(localName) && this.namespaceURI.equals(namespaceURI);
            }
        }
    }
}