Open Source Repository

Home /commons-jxpath/commons-jxpath-1.3 | Repository Home


org/apache/commons/jxpath/ri/compiler/Expression.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.commons.jxpath.ri.compiler;

import org.apache.commons.jxpath.NodeSet;
import org.apache.commons.jxpath.Pointer;
import org.apache.commons.jxpath.ri.EvalContext;
import org.apache.commons.jxpath.ri.model.NodePointer;
import org.apache.commons.jxpath.ri.QName;
import org.apache.commons.jxpath.util.ValueUtils;

import java.util.Collections;
import java.util.Iterator;
import java.util.Locale;

/**
 * Common superclass for several types of nodes in the parse tree. Provides
 * APIs for optimization of evaluation of expressions.  Specifically, an
 * expression only needs to executed once during the evaluation of an xpath
 * if that expression is context-independent.  Expression.isContextDependent()
 * provides that hint.
 *
 @author Dmitri Plotnikov
 @version $Revision: 652845 $ $Date: 2008-05-02 12:46:46 -0500 (Fri, 02 May 2008) $
 */
public abstract class Expression {

    /** zero */
    protected static final Double ZERO = new Double(0);

    /** one */
    protected static final Double ONE = new Double(1);

    /** NaN */
    protected static final Double NOT_A_NUMBER = new Double(Double.NaN);

    private boolean contextDependencyKnown = false;
    private boolean contextDependent;

    /**
     * Returns true if this expression should be re-evaluated
     * each time the current position in the context changes.
     @return boolean
     */
    public synchronized boolean isContextDependent() {
        if (!contextDependencyKnown) {
            contextDependent = computeContextDependent();
            contextDependencyKnown = true;
        }
        return contextDependent;
    }

    /**
     * Implemented by subclasses and result is cached by isContextDependent()
     @return calculated context-dependentness as boolean
     */
    public abstract boolean computeContextDependent();

    /**
     * Evaluates the expression. If the result is a node set, returns
     * the first element of the node set.
     @param context evaluation context
     @return Object
     */
    public abstract Object computeValue(EvalContext context);

    /**
     * Evaluates the expression. If the result is a node set, returns
     * the first element of the node set.
     @param context evaluation context
     @return Object
     */
    public abstract Object compute(EvalContext context);

    /**
     * Iterate over the values from the specified context.
     @param context evaluation context
     @return value Iterator
     */
    public Iterator iterate(EvalContext context) {
        Object result = compute(context);
        if (result instanceof EvalContext) {
            return new ValueIterator((EvalContextresult);
        }
        if (result instanceof NodeSet) {
            return new ValueIterator(((NodeSetresult).getPointers().iterator());
        }
        return ValueUtils.iterate(result);
    }

    /**
     * Iterate over the pointers from the specified context.
     @param context evaluation context
     @return pointer Iterator
     */
    public Iterator iteratePointers(EvalContext context) {
        Object result = compute(context);
        if (result == null) {
            return Collections.EMPTY_LIST.iterator();
        }
        if (result instanceof EvalContext) {
            return (EvalContextresult;
        }
        if (result instanceof NodeSet) {
            return new PointerIterator(((NodeSetresult).getPointers().iterator(),
                    new QName(null, "value"),
                    context.getRootContext().getCurrentNodePointer().getLocale());
        }
        return new PointerIterator(ValueUtils.iterate(result),
                new QName(null, "value"),
                context.getRootContext().getCurrentNodePointer().getLocale());
    }

    /**
     * Pointer iterator
     */
    public static class PointerIterator implements Iterator {
        private Iterator iterator;
        private QName qname;
        private Locale locale;

        //to what method does the following comment refer?
        /**
         * Create a new PointerIterator
         @param it underlying Iterator
         @param qname name
         @param locale Locale
         @deprecated Use the method that takes a NamespaceManager
         */
        public PointerIterator(Iterator it, QName qname, Locale locale) {
            this.iterator = it;
            this.qname = qname;
            this.locale = locale;
        }

        public boolean hasNext() {
            return iterator.hasNext();
        }

        public Object next() {
            Object o = iterator.next();
            return instanceof Pointer ? o : NodePointer.newNodePointer(qname, o, locale);
        }

        /**
         * Unsupported.
         */
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    /**
     * Value Iterator
     */
    public static class ValueIterator implements Iterator {
        private Iterator iterator;

        /**
         * Create a new ValueIterator.
         @param it underlying Iterator, may contain pointers
         */
        public ValueIterator(Iterator it) {
            this.iterator = it;
        }

        public boolean hasNext() {
            return iterator.hasNext();
        }

        public Object next() {
            Object o = iterator.next();
            return instanceof Pointer ? ((Pointero).getValue() : o;
        }

        /**
         * Unsupported.
         */
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }
}