org.esigate.parser.ParserContextImpl.java Source code

Introduction

Here is the source code for org.esigate.parser.ParserContextImpl.java

Source

/* 
 * Licensed 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.esigate.parser;

import java.io.IOException;
import java.util.Stack;

import org.apache.http.HttpResponse;
import org.esigate.HttpErrorPage;
import org.esigate.impl.DriverRequest;

/**
 * 
 * The stack of tags corresponding to the current position in the document
 * 
 * @author Francois-Xavier Bonnet
 * 
 */
class ParserContextImpl implements ParserContext {
    private final RootAdapter root;
    private final DriverRequest httpRequest;
    private final HttpResponse httpResponse;

    private final Stack<ElementInfo> stack = new Stack<ElementInfo>();

    ParserContextImpl(Appendable root, DriverRequest httpRequest, HttpResponse httpResponse) {
        this.root = new RootAdapter(root);
        this.httpRequest = httpRequest;
        this.httpResponse = httpResponse;
    }

    @Override
    public <T> T findAncestor(Class<T> type) {
        T result = null;
        for (int i = stack.size() - 1; i > -1; i--) {
            Element currentElement = stack.elementAt(i).element;
            if (type.isInstance(currentElement)) {
                result = type.cast(currentElement);
                break;
            }
        }
        // try with root
        if (result == null && type.isInstance(root.root)) {
            result = type.cast(root.root);
        }

        return result;
    }

    /** {@inheritDoc} */
    @Override
    public boolean reportError(Exception e) {
        boolean result = false;
        for (int i = stack.size() - 1; i > -1; i--) {
            Element element = stack.elementAt(i).element;
            if (element.onError(e, this)) {
                result = true;
                break;
            }
        }
        return result;
    }

    void startElement(ElementType type, Element element, String tag) throws IOException, HttpErrorPage {
        boolean skipContent = false;
        if (!stack.isEmpty()) {
            // Inherit from parent
            skipContent = stack.peek().skipContent;
        }
        if (!skipContent) {
            skipContent = !element.onTagStart(tag, this);
        }
        stack.push(new ElementInfo(type, element, skipContent));
    }

    void endElement(String tag) throws IOException, HttpErrorPage {
        ElementInfo elementInfo = stack.pop();
        if (!elementInfo.skipContent) {
            elementInfo.element.onTagEnd(tag, this);
        }
    }

    boolean isCurrentTagEnd(String tag) {
        return !stack.isEmpty() && stack.peek().type.isEndTag(tag);
    }

    /** Writes characters into current writer. */
    public void characters(CharSequence cs) throws IOException {
        characters(cs, 0, cs.length());
    }

    /** Writes characters into current writer. */
    void characters(CharSequence csq, int start, int end) throws IOException {
        getCurrent().characters(csq, start, end);
    }

    @Override
    public Element getCurrent() {
        Element result = root;
        if (!stack.isEmpty()) {
            result = stack.peek().element;
        }
        return result;
    }

    @Override
    public DriverRequest getHttpRequest() {
        return this.httpRequest;
    }

    private static class ElementInfo {
        private final ElementType type;
        private final Element element;
        private final boolean skipContent;

        public ElementInfo(ElementType type, Element element, boolean skipContent) {
            this.type = type;
            this.element = element;
            this.skipContent = skipContent;
        }
    }

    private static class RootAdapter implements Element {
        private final Appendable root;

        public RootAdapter(Appendable root) {
            this.root = root;
        }

        @Override
        public boolean onTagStart(String tag, ParserContext ctx) {
            // Nothing to do, this is the root tag
            return true;
        }

        @Override
        public void onTagEnd(String tag, ParserContext ctx) {
            // Nothing to do, this is the root tag
        }

        @Override
        public boolean onError(Exception e, ParserContext ctx) {
            return false;
        }

        @Override
        public void characters(CharSequence csq, int start, int end) throws IOException {
            this.root.append(csq, start, end);
        }

    }

    @Override
    public HttpResponse getHttpResponse() {
        return this.httpResponse;
    }
}