net.sf.saxon.pattern.MultipleNodeKindTest Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of Saxon-HE Show documentation
The XSLT and XQuery Processor
There is a newer version: 12.5
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2013 Saxonica Limited.
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// This Source Code Form is “Incompatible With Secondary Licenses”, as defined by the Mozilla Public License, v. 2.0.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

package net.sf.saxon.pattern;

import net.sf.saxon.om.NodeInfo;
import net.sf.saxon.om.NodeName;
import net.sf.saxon.tree.tiny.TinyTree;
import net.sf.saxon.tree.util.FastStringBuffer;
import net.sf.saxon.type.*;

import java.util.LinkedList;

/**
 * An MultipleNodeKindTest is a nodetest that matches nodes belonging to any subset of possible
 * node kinds, for example element and document nodes, or attribute and namespace nodes
 */

public final class MultipleNodeKindTest extends NodeTest {

    public final static MultipleNodeKindTest PARENT_NODE =
            new MultipleNodeKindTest(UType.DOCUMENT.union(UType.ELEMENT));

    public final static MultipleNodeKindTest DOC_ELEM_ATTR =
        new MultipleNodeKindTest(UType.DOCUMENT.union(UType.ELEMENT).union(UType.ATTRIBUTE));

    UType uType;
    int nodeKindMask;

    public MultipleNodeKindTest(UType u) {
        this.uType = u;
        if (UType.DOCUMENT.overlaps(u)) {
            nodeKindMask |= 1 << Type.DOCUMENT;
        }
        if (UType.ELEMENT.overlaps(u)) {
            nodeKindMask |= 1 << Type.ELEMENT;
        }
        if (UType.ATTRIBUTE.overlaps(u)) {
            nodeKindMask |= 1 << Type.ATTRIBUTE;
        }
        if (UType.TEXT.overlaps(u)) {
            nodeKindMask |= 1 << Type.TEXT;
        }
        if (UType.COMMENT.overlaps(u)) {
            nodeKindMask |= 1 << Type.COMMENT;
        }
        if (UType.PI.overlaps(u)) {
            nodeKindMask |= 1 << Type.PROCESSING_INSTRUCTION;
        }
        if (UType.NAMESPACE.overlaps(u)) {
            nodeKindMask |= 1 << Type.NAMESPACE;
        }
    }

    /**
     * Get the corresponding {@link net.sf.saxon.type.UType}. A UType is a union of primitive item
     * types.
     *
     * @return the smallest UType that subsumes this item type
     */
    public UType getUType() {
        return uType;
    }

    /**
     * Test whether this node test is satisfied by a given node. This method is only
     * fully supported for a subset of NodeTests, because it doesn't provide all the information
     * needed to evaluate all node tests. In particular (a) it can't be used to evaluate a node
     * test of the form element(N,T) or schema-element(E) where it is necessary to know whether the
     * node is nilled, and (b) it can't be used to evaluate a node test of the form
     * document-node(element(X)). This in practice means that it is used (a) to evaluate the
     * simple node tests found in the XPath 1.0 subset used in XML Schema, and (b) to evaluate
     * node tests where the node kind is known to be an attribute.
     *
     * @param nodeKind   The kind of node to be matched
     * @param name       identifies the expanded name of the node to be matched.
     *                   The value should be null for a node with no name.
     * @param annotation The actual content type of the node
     */
    @Override
    public boolean matches(int nodeKind, NodeName name, SchemaType annotation) {
        return (nodeKindMask & (1< types = new LinkedList(uType.decompose());
        format(types, fsb);
        return fsb.toString();
    }

    private void format(LinkedList list, FastStringBuffer fsb) {
        if (list.size() == 1) {
            fsb.append(list.get(0).toItemType().toString());
        } else {
            fsb.append('(');
            fsb.append(list.removeFirst().toItemType().toString());
            fsb.append('|');
            format(list, fsb);
            fsb.append(')');
        }
    }

    /**
     * Returns a hash code value for the object.
     */

    public int hashCode() {
        return uType.hashCode();
    }

    /**
     * Generate Javascript code to test whether an item conforms to this item type
     *
     * @return a Javascript instruction or sequence of instructions, which can be used as the body
     * of a Javascript function, and which returns a boolean indication whether the value of the
     * variable "item" is an instance of this item type.
     * @param knownToBe
     */
    @Override
    public String generateJavaScriptItemTypeTest(ItemType knownToBe) {
        FastStringBuffer fsb = new FastStringBuffer(256);
        fsb.append("return SaxonJS.U.isNode(item) && (false");
        UType u = uType;
        if (UType.DOCUMENT.overlaps(u)) {
            fsb.append("||item.nodeType==9||item.nodeType==11");
        }
        if (UType.ELEMENT.overlaps(u)) {
            fsb.append("||item.nodeType==1");
        }
        if (UType.ATTRIBUTE.overlaps(u)) {
            fsb.append("||item.nodeType==2");  // TODO: Attr may not be a node
        }
        if (UType.TEXT.overlaps(u)) {
            fsb.append("||item.nodeType==3");
        }
        if (UType.COMMENT.overlaps(u)) {
            fsb.append("||item.nodeType==8");
        }
        if (UType.PI.overlaps(u)) {
            fsb.append("||item.nodeType==7");
        }
        if (UType.NAMESPACE.overlaps(u)) {
            fsb.append("||item.nodeType==13");  // TODO: this won't work
        }
        fsb.append(");");
        return fsb.toString().replace("false||", "");
    }


}