## org.exist.dom
Interface NodeSet

All Superinterfaces:
  org.w3c.dom.NodeList, Sequence

All Known Implementing Classes:
  AbstractNodeSet, NodeProxy

public interface NodeSet
extends Sequence, org.w3c.dom.NodeList

Author:
  wolf

Field Summary
`static int` `ANCESTOR`
`static int` `DESCENDANT`
`static NodeSet` `EMPTY_SET` Constant representing an empty node set.
`static int` `FOLLOWING`
`static int` `PRECEDING`

Fields inherited from interface org.exist.xquery.value.Sequence
`EMPTY_SEQUENCE`

Method Summary
`void` `add(NodeProxy proxy)` Add a new proxy object to the node set.
`void` `add(NodeProxy proxy, int sizeHint)` Add a proxy object to the node set.
`void` `addAll(NodeSet other)` Add all nodes from the given node set.
`boolean` `contains(NodeProxy proxy)` Check if this node set contains a node matching the document and node-id of the given NodeProxy object.
`boolean` `containsDoc(DocumentImpl doc)` Check if this node set contains nodes belonging to the given document.
`NodeSet` `deepIntersection(NodeSet other)` Return a new node set, containing all nodes in this node set that are contained or have descendants in the other node set.
`NodeSet` `directSelectAttribute(QName qname, int contextId)` Optimized method to select attributes.
`NodeSet` `except(NodeSet other)` Return a new node set containing all nodes from this node set except those nodes which are also contained in the argument node set.
`NodeProxy` `get(DocumentImpl doc, NodeId nodeId)`
`NodeProxy` `get(int pos)` Get the node at position pos within this node set.
`NodeProxy` `get(NodeProxy p)` Get a node from this node set matching the document and node id of the given NodeProxy.
`NodeSet` `getAncestors(int contextId, boolean includeSelf)`
`NodeSet` `getContextNodes(int contextId)` Returns all context nodes associated with the nodes in this node set.
`DocumentSet` `getDocumentSet()` Returns the set of documents from which the node items in this sequence have been selected.
`int` `getIndexType()` If all nodes in this set have an index, returns the common supertype used to build the index, e.g.
`NodeSet` `getParents(int contextId)` Return a new node set containing the parent nodes of all nodes in the current set.
`boolean` `getProcessInReverseOrder()`
`int` `getSizeHint(DocumentImpl doc)` Get a hint about how many nodes in this node set belong to the specified document.
`int` `getState()`
`boolean` `hasChanged(int previousState)`
`boolean` `hasMixedContent()`
`boolean` `hasTextIndex()`
`NodeSet` `intersection(NodeSet other)` Return a new node set, which represents the intersection of the current node set with the given node set.
`NodeSetIterator` `iterator()` Return an iterator on the nodes in this list.
`NodeProxy` `parentWithChild(DocumentImpl doc, NodeId nodeId, boolean directParent, boolean includeSelf)` Check if the node identified by its node id has an ancestor contained in this node set and return the ancestor found.
`NodeProxy` `parentWithChild(NodeProxy proxy, boolean directParent, boolean includeSelf, int level)` Check if the given node has an ancestor contained in this node set and return the ancestor found.
`NodeSet` `selectAncestorDescendant(NodeSet al, int mode, boolean includeSelf, int contextId)` Check if any descendant nodes are found within this node set for a given set of potential ancestor nodes.
`NodeSet` `selectAncestors(NodeSet descendants, boolean includeSelf, int contextId)` For a given set of potential ancestor nodes, return all ancestors having descendants in this node set.
`NodeSet` `selectFollowing(NodeSet following)`
`NodeSet` `selectFollowingSiblings(NodeSet siblings, int contextId)` Select all nodes from the passed node set, which are following siblings of the nodes in this set.
`NodeSet` `selectParentChild(NodeSet al, int mode)` Check if any child nodes are found within this node set for a given set of potential parent nodes.
`NodeSet` `selectParentChild(NodeSet al, int mode, int contextId)` Check if any child nodes are found within this node set for a given set of potential parent nodes.
`NodeSet` `selectPreceding(NodeSet preceding)`
`NodeSet` `selectPrecedingSiblings(NodeSet siblings, int contextId)` Select all nodes from the passed node set, which are preceding siblings of the nodes in this set.
`void` `setProcessInReverseOrder(boolean inReverseOrder)`
`NodeSet` `union(NodeSet other)` Return a new node set which represents the union of the current node set and the given node set.

Methods inherited from interface org.exist.xquery.value.Sequence
`add, addAll, clearContext, conversionPreference, convertTo, effectiveBooleanValue, getCardinality, getItemType, getLength, getStringValue, hasMany, hasOne, isCached, isEmpty, isPersistentSet, itemAt, iterate, removeDuplicates, setIsCached, setSelfAsContext, toJavaObject, toNodeSet, unorderedIterator`

Methods inherited from interface org.w3c.dom.NodeList
`getLength, item`

Field Detail

### ANCESTOR

    public static final int ANCESTOR

See Also:
  Constant Field Values

### DESCENDANT

    public static final int DESCENDANT

See Also:
  Constant Field Values

### PRECEDING

    public static final int PRECEDING

See Also:
  Constant Field Values

### FOLLOWING

    public static final int FOLLOWING

See Also:
  Constant Field Values

### EMPTY_SET

    public static final NodeSet EMPTY_SET

  Constant representing an empty node set.

Method Detail

### iterator

    public NodeSetIterator iterator()

  Return an iterator on the nodes in this list. The iterator returns nodes according to the internal ordering of nodes (i.e. level first), not in document- order.

### contains

    public boolean contains(NodeProxy proxy)

  Check if this node set contains a node matching the document and node-id of the given NodeProxy object.

  Parameters:
    `proxy` -

### containsDoc

    public boolean containsDoc(DocumentImpl doc)

  Check if this node set contains nodes belonging to the given document.

  Parameters:
    `doc` -

### getDocumentSet

    public DocumentSet getDocumentSet()

  Description copied from interface: `Sequence`
  Returns the set of documents from which the node items in this sequence have been selected. This is for internal use only.

  Specified by:
    `getDocumentSet` in interface `Sequence`

### add

    public void add(NodeProxy proxy)

  Add a new proxy object to the node set. Please note: node set implementations may allow duplicates.

  Parameters:
    `proxy` -

### add

    public void add(NodeProxy proxy,
                    int sizeHint)

  Add a proxy object to the node set. The sizeHint parameter gives a hint about the number of items to be expected for the current document.

  Parameters:
    `proxy` -
    `sizeHint` -

### addAll

    public void addAll(NodeSet other)

  Add all nodes from the given node set.

  Parameters:
    `other` -

### get

    public NodeProxy get(int pos)

  Get the node at position pos within this node set.

  Parameters:
    `pos` -

### get

    public NodeProxy get(NodeProxy p)

  Get a node from this node set matching the document and node id of the given NodeProxy.

  Parameters:
    `p` -

### get

    public NodeProxy get(DocumentImpl doc,
                         NodeId nodeId)

### selectParentChild

    public NodeSet selectParentChild(NodeSet al,
                                     int mode)

  Check if any child nodes are found within this node set for a given set of potential parent nodes. If mode is `DESCENDANT`, the returned node set will contain all child nodes found in this node set for each parent node. If mode is `ANCESTOR`, the returned set will contain those parent nodes, for which children have been found.

  Parameters:
    `al` - a node set containing potential parent nodes
    `mode` - selection mode

### selectParentChild

    public NodeSet selectParentChild(NodeSet al,
                                     int mode,
                                     int contextId)

  Check if any child nodes are found within this node set for a given set of potential parent nodes. If mode is `DESCENDANT`, the returned node set will contain all child nodes found in this node set for each parent node. If mode is `ANCESTOR`, the returned set will contain those parent nodes, for which children have been found.

  Parameters:
    `al` - a node set containing potential parent nodes
    `mode` - selection mode
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### selectAncestorDescendant

    public NodeSet selectAncestorDescendant(NodeSet al,
                                            int mode,
                                            boolean includeSelf,
                                            int contextId)

  Check if any descendant nodes are found within this node set for a given set of potential ancestor nodes. If mode is `DESCENDANT`, the returned node set will contain all descendant nodes found in this node set for each ancestor. If mode is `ANCESTOR`, the returned set will contain those ancestor nodes, for which descendants have been found.

  Parameters:
    `al` - a node set containing potential parent nodes
    `mode` - selection mode
    `includeSelf` - if true, check if the ancestor node itself is contained in the set of descendant nodes (descendant-or-self axis)
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### selectAncestors

    public NodeSet selectAncestors(NodeSet descendants,
                                   boolean includeSelf,
                                   int contextId)

  For a given set of potential ancestor nodes, return all ancestors having descendants in this node set.

  Parameters:
    `descendants` - node set containing potential ancestors
    `includeSelf` - if true, check if the ancestor node itself is contained in this node set (ancestor-or-self axis)
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### selectPrecedingSiblings

    public NodeSet selectPrecedingSiblings(NodeSet siblings,
                                           int contextId)

  Select all nodes from the passed node set, which are preceding siblings of the nodes in this set.

  Parameters:
    `siblings` - a node set containing potential siblings
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### selectFollowingSiblings

    public NodeSet selectFollowingSiblings(NodeSet siblings,
                                           int contextId)

  Select all nodes from the passed node set, which are following siblings of the nodes in this set.

  Parameters:
    `siblings` - a node set containing potential siblings
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### selectPreceding

    public NodeSet selectPreceding(NodeSet preceding)
                            throws XPathException

  Throws:
    `XPathException`

### selectFollowing

    public NodeSet selectFollowing(NodeSet following)
                            throws XPathException

  Throws:
    `XPathException`

### parentWithChild

    public NodeProxy parentWithChild(DocumentImpl doc,
                                     NodeId nodeId,
                                     boolean directParent,
                                     boolean includeSelf)

  Check if the node identified by its node id has an ancestor contained in this node set and return the ancestor found. If directParent is true, only immediate ancestors (parents) are considered. Otherwise the method will call itself recursively for all the node's parents. If includeSelf is true, the method returns also true if the node itself is contained in the node set.

### parentWithChild

    public NodeProxy parentWithChild(NodeProxy proxy,
                                     boolean directParent,
                                     boolean includeSelf,
                                     int level)

  Check if the given node has an ancestor contained in this node set and return the ancestor found. If directParent is true, only immediate ancestors (parents) are considered. Otherwise the method will call itself recursively for all the node's parents. If includeSelf is true, the method returns also true if the node itself is contained in the node set.

### getParents

    public NodeSet getParents(int contextId)

  Return a new node set containing the parent nodes of all nodes in the current set.

### getAncestors

    public NodeSet getAncestors(int contextId,
                                boolean includeSelf)

### directSelectAttribute

    public NodeSet directSelectAttribute(QName qname,
                                         int contextId)

  Optimized method to select attributes. Use this if the context has just one or two nodes. Attributes will be directly looked up in the persistent DOM store.

  Parameters:
    `qname` - the QName of the attribute
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### getIndexType

    public int getIndexType()

  If all nodes in this set have an index, returns the common supertype used to build the index, e.g. xs:integer or xs:string. If the nodes have different index types or no node has been indexed, returns `Type.ITEM`.

  See Also:
    `GeneralComparison`, `ValueComparison`

### hasTextIndex

    public boolean hasTextIndex()

### hasMixedContent

    public boolean hasMixedContent()

### getSizeHint

    public int getSizeHint(DocumentImpl doc)

  Get a hint about how many nodes in this node set belong to the specified document. This is just used for allocating new node sets. The information does not need to be exact. -1 is returned if the size cannot be determined (the default).

  Parameters:
    `doc` -

### intersection

    public NodeSet intersection(NodeSet other)

  Return a new node set, which represents the intersection of the current node set with the given node set.

  Parameters:
    `other` -

### deepIntersection

    public NodeSet deepIntersection(NodeSet other)

  Return a new node set, containing all nodes in this node set that are contained or have descendants in the other node set.

  Parameters:
    `other` -

### union

    public NodeSet union(NodeSet other)

  Return a new node set which represents the union of the current node set and the given node set.

  Parameters:
    `other` -

### except

    public NodeSet except(NodeSet other)

  Return a new node set containing all nodes from this node set except those nodes which are also contained in the argument node set.

  Parameters:
    `other` -

### setProcessInReverseOrder

    public void setProcessInReverseOrder(boolean inReverseOrder)

### getProcessInReverseOrder

    public boolean getProcessInReverseOrder()

### getContextNodes

    public NodeSet getContextNodes(int contextId)

  Returns all context nodes associated with the nodes in this node set.

  Parameters:
    `contextId` - used to track context nodes when evaluating predicate expressions. If contextId != `Expression.NO_CONTEXT_ID`, the current context will be added to each result of the of the selection.

### hasChanged

    public boolean hasChanged(int previousState)

### getState

    public int getState()

Copyright (C) Wolfgang Meier. All rights reserved.