XPathExpression.hpp

Go to the documentation of this file.

/*
 * 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.
 */
#if !defined(XPATHEXPRESSION_HEADER_GUARD_1357924680)
#define XPATHEXPRESSION_HEADER_GUARD_1357924680
 
 
 
// Base header file.  Must be first.
#include <xalanc/XPath/XPathDefinitions.hpp>
 
 
 
#include <xalanc/Include/XalanVector.hpp>
 
 
 
#include <iosfwd>
 
 
 
#include <xalanc/XalanDOM/XalanDOMString.hpp>
 
 
 
#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/PrintWriter.hpp>
 
 
 
#include <xalanc/XPath/XToken.hpp>
#include <xalanc/XPath/XalanXPathException.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
using xercesc::MemoryManager;
 
 
 
class XALAN_XPATH_EXPORT XPathExpression
{
public:
 
    typedef std::ostream         OstreamType;
 
    typedef XalanVector<int>                    OpCodeMapType;
    typedef XalanVector<XToken>                 TokenQueueType;
 
    typedef OpCodeMapType::value_type           OpCodeMapValueType;
    typedef OpCodeMapValueType                  OpCodeMapSizeType;
 
    typedef XalanVector<OpCodeMapValueType>     OpCodeMapValueVectorType;
 
    typedef XalanVector<double>                 NumberLiteralValueVectorType;
 
#define XALAN_XPATH_EXPRESSION_USE_ITERATORS
 
#if defined(XALAN_XPATH_EXPRESSION_USE_ITERATORS)
    typedef OpCodeMapType::const_iterator   OpCodeMapPositionType;
#else
    typedef OpCodeMapSizeType               OpCodeMapPositionType;
#endif
    typedef OpCodeMapType::difference_type  OpCodeMapDifferenceType;
    typedef TokenQueueType::value_type      TokenQueueValueType;
    typedef int                             TokenQueueSizeType;
    typedef TokenQueueSizeType              TokenQueuePositionType;
 
    /**
     * List of operations codes.
     *
     * Code for the descriptions of the operations codes:
     * [UPPER CASE] indicates a literal value,
     * [lower case] is a description of a value,
     *      ([length] always indicates the length of the operation,
     *       including the operations code and the length integer.)
     * {UPPER CASE} indicates the given production,
     * {description} is the description of a new production,
     *      (For instance, {boolean expression} means some expression 
     *       that should be resolved to a boolean.)
     *  * means that it occurs zero or more times,
     *  + means that it occurs one or more times,
     *  ? means that it is optional.
     *
     * returns: indicates what the production should return.
     */
    enum eOpCodes
    {
        /**
         * [ELEMWILDCARD]
         * Means ELEMWILDCARD ("*"), used instead 
         * of string index in some places.
         */
        eELEMWILDCARD = -3,
 
        /**
         * [EMPTY]
         * Empty slot to indicate NULL.
         */
        eEMPTY = -2,
 
        /**
         * [ENDOP]
         * Some operators may like to have a terminator.
         */
        eENDOP = -1,
 
        /**
         * [OP_XPATH]
         * [length]
         *  {expression}
         * 
         * returns: 
         *  XNodeSet
         *  XNumber
         *  XString
         *  XBoolean
         *  XRTree
         *  XObject
         */
        eOP_XPATH = 1,
 
        /**
         * [OP_OR]
         * [length]
         *  {boolean expression}
         *  {boolean expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_OR = 2,
 
        /**
         * [OP_AND]
         * [length]
         *  {boolean expression}
         *  {boolean expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_AND = 3,
 
        /**
         * [OP_NOTEQUALS]
         * [length]
         *  {expression}
         *  {expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_NOTEQUALS = 4,
 
        /**
         * [OP_EQUALS]
         * [length]
         *  {expression}
         *  {expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_EQUALS = 5,
 
        /**
         * [OP_LTE] (less-than-or-equals)
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_LTE = 6,
 
        /**
         * [OP_LT] (less-than)
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_LT = 7,
 
        /**
         * [OP_GTE] (greater-than-or-equals)
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_GTE = 8,
 
        /**
         * [OP_GT] (greater-than)
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: 
         *  XBoolean
         */
        eOP_GT = 9,
 
        /**
         * [OP_PLUS]
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: 
         *  XNumber
         */
        eOP_PLUS = 10,
 
        /**
         * [OP_MINUS]
         * [length]
         *  {number expression}
         *  {number expression}
         * 
         * returns: