XmlDataTreeCursorImpl (webMethods Java API Reference)

java.lang.Object
- com.wm.xmldata.XmlDataTreeCursorImpl

All Implemented Interfaces:

XmlDataCursor, XmlDataTreeCursor
```
public class XmlDataTreeCursorImpl
extends java.lang.Object
implements XmlDataTreeCursor
```
Methods that allow a Java program to easily move about the XML infoset when encoded as XmlData.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`XmlDataTreeCursor`	`copyCursor()`
`int`	`count()` Returns the number of items stored at the current cursor position.
`int`	`currentIndex()` Returns the index of the current-item when the current-object is an object containing repeating values.
`IData`	`data()` Returns the IData for which this cursor is defined.
`boolean`	`deleteBackward()` Deletes the current-item and positions the cursor on the previous item.
`boolean`	`deleteForward()` Deletes the current-item and positions the cursor on the next item.
`boolean`	`deleteItem(int... index)` Delete the specified item.
`boolean`	`deleteObject()` Removes the tag-object-pair (single value or array of repeating values) from the current position.
`int`	`depth()` Returns the stacked cursor depth.
`void`	`destroy()` Release any resources associated with the current cursor.
`boolean`	`first()` Positions the cursor at the first tag-object-pair.
`boolean`	`first(XmlDataContentTag key)` Positions the cursor on the first tag-object-pair with the specified tag and returns true.
`boolean`	`firstChild()` Positions this cursor on the first child of the current-value.
`boolean`	`firstItem()` Positions this cursor on the first item.
`boolean`	`firstPartial(XmlDataContentTag key)` Positions the cursor on the first tag-object-pair with a tag that partially matches the specified tag.
`XmlDataContentTag`	`getAnyTag(int... index)` The behavior is similar to `XmlDataCursor.getAnyTag(int...)` except that an omitted index references the current-item rather than the first and only item content.
`XmlDataAttributeTag[]`	`getAttributeNames(int... index)` The behavior is similar to `XmlDataCursor.getAttributeNames(int...)` except that an omitted index references the current-item rather than the first and only item content.
`IData`	`getAttributes(int... index)` The behavior is similar to `XmlDataCursor.getAttributes(int...)` except that an omitted index references the current-item rather than the first and only item content.
`java.lang.String`	`getAttributeValue(XmlDataAttributeTag attribute, int... index)` The behavior is similar to `XmlDataCursor.getAttributeValue(XmlDataAttributeTag, int...)` except that an omitted index references the current-item rather than the first and only item content.
`java.lang.Object`	`getComplexValueContent(int... index)` The behavior is similar to `XmlDataCursor.getComplexValueContent(int...)` except that an omitted index references the current-item content rather than the first and only item content.
`java.lang.Object`	`getContent(int... index)` The behavior is similar to `XmlDataCursor.getContent(int...)` except that an omitted index references the current-item content rather than the first and only item content.
`java.lang.String`	`getInstanceProp(java.lang.String name, int... optionalIndex)` The behavior is similar to `XmlDataCursor.getInstanceProp(String, int...)` except that an omitted index references the current-item rather than the first and only item content.
`java.lang.Object`	`getItem(int... index)` The behavior is similar to `XmlDataCursor.getItem(int...)` except that an omitted index references the current-item rather than the first and only item.
`java.lang.String`	`getNamespaceDecl(java.lang.String prefix, int... optionalIndex)` The behavior is similar to `XmlDataCursor.getNamespaceDecl(String, int...)` except that an omitted index references the current-item rather than the first and only item content.
`IData`	`getNamespaceDecls(int... optionalIndex)` The behavior is similar to `XmlDataCursor.getNamespaceDecls(int...)` except that an omitted index references the current-item rather than the first and only item content.
`java.lang.Object`	`getObject()` Returns the current-object, the object stored at the current-position.
`XmlDataContentTag`	`getTag()` Returns the current-tag as a parsed-tag.
`java.lang.Object`	`getValue(int... index)` The behavior is similar to `XmlDataCursor.getValue(int...)` except that an omitted index references the current-item value rather than the first and only item value.
`XmlDataCursor`	`getValueCursor(int... index)` Returns an XmlDataCursor positioned on the first child of the specified value in the current-object.
`XmlDataContentTag`	`getValueTag(int... index)` The behavior is similar to `XmlDataCursor.getValueTag(int...)` except that an omitted index references the current-item value-tag rather than the first and only item's value-tag.
`boolean`	`hasAttributes(int... index)` The behavior is exactly like `XmlDataCursor.hasAttributes(int...)` except that an omitted index references the current-item value rather than the first and only item value.
`void`	`home()` The cursor becomes unpositioned as if newly created.
`void`	`insertItemAfter(java.lang.Object value)` Inserts an item after the current-item in a repeating value.
`void`	`insertItemAfter(java.lang.Object item, int index)` Inserts an item after the specified index into the array of repeating values at the current-position.
`void`	`insertItemBefore(java.lang.Object value)` Inserts an item before the current-item in a repeating value.
`void`	`insertItemBefore(java.lang.Object value, int index)` Inserts an item before the specified index into the array of repeating values at the current-position.
`void`	`insertObjectAfter(XmlDataContentTag tag, java.lang.Object value)` Inserts a tag-object-pair after the current-position.
`void`	`insertObjectBefore(XmlDataContentTag tag, java.lang.Object value)` Inserts a tag-object-pair before the current-position.
`void`	`insertValueAfter(XmlDataContentTag tag, java.lang.Object value)` Inserts a value and value-tag after the current-item.
`void`	`insertValueAfter(XmlDataContentTag tag, java.lang.Object value, int index)` Inserts a value into an array of repeating values at the current-position, after the specified index.
`void`	`insertValueBefore(XmlDataContentTag tag, java.lang.Object value)` Inserts a value and value-tag before the current-item.
`void`	`insertValueBefore(XmlDataContentTag tag, java.lang.Object value, int index)` Inserts a value into an array of repeating values at the current-position, before the specified index.
`boolean`	`isAny()` Determines if the current-tag is an any-tag.
`boolean`	`isComplexValue(int... index)` The behavior is similar to `XmlDataCursor.isComplexValue(int...)` except that an omitted index references the current-item.
`boolean`	`isEmpty(int... index)` The behavior is similar to `XmlDataCursor.isEmpty(int...)` except that an omitted index references the current-item.
`boolean`	`isGroup()` Determines if the current-tag is a group-tag.
`boolean`	`isGroupValue(int... index)` The behavior is similar to `XmlDataCursor.isGroupValue(int...)` except that an omitted index references the current-item.
`boolean`	`isHome()` Indicates whether the cursor is unpositioned.
`boolean`	`isRecast()` Indicates if automatic recast is in effect.
`boolean`	`isRepeating()` Determines if the current-object is a repeating value.
`boolean`	`isSimpleValue(int... index)` The behavior is similar to `XmlDataCursor.isSimpleValue(int...)` except that an omitted index references the current-item.
`boolean`	`isSubstitution()` Determines if the current-tag is a substitution-tag
`boolean`	`isTop()` Determines if the XmlDataTreeCursor is positioned somewhere in the top level.
`boolean`	`last()` Positions the cursor at the last tag-object-pair.
`boolean`	`last(XmlDataContentTag key)` Positions the cursor on the last occurrence of the last tag-object-pairg with the specified tag and return true.
`boolean`	`lastChild()` Positions this cursor on the last child value of the current-value.
`boolean`	`lastItem()` Positions this cursor on the last item.
`boolean`	`lastPartial(XmlDataContentTag key)` Positiosn the cursor on the last tag-object-pair with a tag that partially matches the specified tag.
`XmlDataTreeCursor`	`newCursor(IData data)` Creates a new XmlDataCuror instances from an existing cursor factory.
`boolean`	`next()` Positions the cursor on the next tag-object-pair.
`boolean`	`next(XmlDataContentTag key)` Positiona the cursor on the next tag-object-pair that has the specified tag and returns true.
`java.lang.Integer`	`nextInOrder()` Positions this cursor to the next in-order item.
`boolean`	`nextItem()` Positions this cursor on the next item.
`boolean`	`nextItem(XmlDataContentTag key)` Positions this cursor on the next item with the specified tag.
`boolean`	`nextPartial(XmlDataContentTag key)` Positions the cursor on the next tag-object-pair with a tag that partially matches the specified tag.
`boolean`	`nextValueTag(XmlDataContentTag key)` Positions this cursor on the next item with a value-tag that matches the search tag.
`boolean`	`parent()` Moves the XmlDataTreeCursor up one level by popping the top-level cursor from the internal stack of cursor.
`boolean`	`previous()` Positions the cursor on the previous tag-object-pair.
`boolean`	`previous(XmlDataContentTag key)` Positions the cursor on the previous tag-object-pair with the specified tag and return true.
`java.lang.Integer`	`previousInOrder()` Positions the cursor to the previous in-order item.
`boolean`	`previousItem()` Positions this cursor on the previous item.
`boolean`	`previousItem(XmlDataContentTag key)` Positions this cursor on the previous item with the specified tag.
`boolean`	`previousPartial(XmlDataContentTag key)` Positions the cursor on the previous tag-object-pair with a tag that partially matches the specified tag.
`boolean`	`previousValueTag(XmlDataContentTag key)` Positions this cursor the previous item with a value-tag that matches the search tag.
`void`	`recast(boolean mode)` Indicates whether existing String[] or IData[] arrays for repeating values should be automatically recreated as an Object[] when the inserted or set value type doesn't match the type of the repeating item array that is already present.
`boolean`	`removeAttribute(XmlDataAttributeTag attribute, int... index)` Removes the specified attribute.
`void`	`setAnyTag(XmlDataContentTag tag, int... index)` The behavior is similar to `XmlDataCursor.setAnyTag(XmlDataContentTag, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setAttributes(IData attributes, int... index)` The behavior is similar to `XmlDataCursor.setAttributes(IData, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setAttributeValue(XmlDataAttributeTag attribute, java.lang.String value, int... index)` The behavior is similar to `XmlDataCursor.setAttributeValue(XmlDataAttributeTag, String, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setComplexValueContent(java.lang.Object data, int... index)` The behavior is exactly the same `XmlDataCursor.setComplexValueContent(java.lang.Object, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setContent(java.lang.Object data, int... index)` The behavior is exactly the same `XmlDataCursor.setContent(java.lang.Object, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setIndex(int index)` Establishes the current-item in repeating values.
`void`	`setInstanceProp(java.lang.String name, java.lang.String value, int... index)` Sets an XML instance property (xsi attribute) on the current item.
`void`	`setItem(java.lang.Object object, int... index)` The behavior is similar to `XmlDataCursor.setItem(java.lang.Object, int...)` except that an omitted index always accesses the current-item rather than the first and only item.
`void`	`setNamespaceDecl(java.lang.String prefix, java.lang.String uri, int... index)` The behavior is similar to `XmlDataCursor.setNamespaceDecl(String, String, int...)` except that an omitted index always references the current-item rather the first and only item.
`void`	`setNamespaceDecls(IData nsDecls, int... index)` The behavior is similar to `XmlDataCursor.setNamespaceDecls(IData, int...)` except that an omitted index always references the current-item rather the first and only item.
`void`	`setObject(java.lang.Object value)` Sets the object stored at the current cursor position ( a value or array of repeating values).
`void`	`setTag(XmlDataContentTag tag)` Sets the tag of the current tag-object pair.
`void`	`setValue(java.lang.Object object, int... index)` The behavior is similar to `XmlDataCursor.setValue(java.lang.Object, int...)` except that an omitted index always accesses the current-item value rather than the first and only item value.
`void`	`setValueTag(XmlDataContentTag key, int... index)` The behavior is similar to `XmlDataCursor.setValueTag(com.wm.xmldata.XmlDataContentTag, int...)` except that an omitted index always accesses the current-item;s value-tag rather than the first and only item's value-tag.
`void`	`top()` Positions the TreeCursor on the top-level and destroys all intervening cursors.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Method Detail
  - copyCursor
```
public XmlDataTreeCursor copyCursor()
```
    Specified by:
    
    copyCursor in interface XmlDataCursor
    
    Returns:
    
    a copy of this cursor
  - count
```
public int count()
```
    Description copied from interface: XmlDataCursor
    
    Returns the number of items stored at the current cursor position. Items are either values or indirect-items. For a tag with repeating values (an array), the length of the array is returned. For a non-repeating value, 1 is returned. if the cursor is unpositioned, 0 is returned.
    
    Specified by:
    
    count in interface XmlDataCursor
    
    Returns:
    
    number of values held by the current item.
  - currentIndex
```
public int currentIndex()
```
    Description copied from interface: XmlDataTreeCursor
    
    Returns the index of the current-item when the current-object is an object containing repeating values. For a non-repeating value, the index is always zero (because there is only 1 item).
    
    Specified by:
    
    currentIndex in interface XmlDataTreeCursor
    
    Returns:
    
    int value of the current-index. An unpositioned cursor returns -1.
  - data
```
public IData data()
```
    Description copied from interface: XmlDataCursor
    
    Returns the IData for which this cursor is defined.
    
    Specified by:
    
    data in interface XmlDataCursor
    
    Returns:
    
    the IData instance for which this cursor was obtained.
  - deleteItem
```
public boolean deleteItem(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    Delete the specified item. This method's behavior is similar to XmlDataCursor.deleteItem(int...) except that an omitted index results in current-item deletion.
    
    Specified by:
    
    deleteItem in interface XmlDataCursor
    
    Specified by:
    
    deleteItem in interface XmlDataTreeCursor
    
    Parameters:
    
    index - optional offset (starting at zero) into the array of repeating values are present
    
    Returns:
    
    true if cursor is positioned on the next item after deletion
  - deleteBackward
```
public boolean deleteBackward()
```
    Description copied from interface: XmlDataTreeCursor
    
    Deletes the current-item and positions the cursor on the previous item. If the first item of the current-object is being deleted, the cursor is positioned on the last or only item of the previous object. If there is no previous object, the cursor becomes unpositioned. Returns false if there are no more previous items and leaves the cursor unpositioned.
    
    Specified by:
    
    deleteBackward in interface XmlDataTreeCursor
    
    Returns:
    
    true if more items remain in the backward direction
  - deleteForward
```
public boolean deleteForward()
```
    Description copied from interface: XmlDataTreeCursor
    
    Deletes the current-item and positions the cursor on the next item. If the last item of the current-object is being deleted, the cursor is positioned on the first or only item of the next object. If there is no next object, the cursor becomes unpositioned.
    
    Specified by:
    
    deleteForward in interface XmlDataTreeCursor
    
    Returns:
    
    true if more items remain in the forward direction
  - deleteObject
```
public boolean deleteObject()
```
    Description copied from interface: XmlDataCursor
    
    Removes the tag-object-pair (single value or array of repeating values) from the current position. If there are tags following the current position, the cursor is positioned on the next tag and true is returned. If there is no next tag, the cursor is positioned on the previous tag and false is returned. If there are no remaining tags, the cursor is unpositioned and false is returned. This behavior is similar to legacy IDataCursor delete() behavior.
    
    Specified by:
    
    deleteObject in interface XmlDataCursor
    
    Returns:
    
    true if cursor is positioned on the next item after deletion
  - depth
```
public int depth()
```
    Description copied from interface: XmlDataTreeCursor
    
    Returns the stacked cursor depth. Initially zero. For every invocation of XmlDataTreeCursor.firstChild() or XmlDataTreeCursor.lastChild() that returns true, the depth increases by one. For every invocation of XmlDataTreeCursor.parent() that returns true, the depth decreases by one.
    
    Specified by:
    
    depth in interface XmlDataTreeCursor
    
    Returns:
    
    the number of stacked cursors (not counting the current cursor)
  - destroy
```
public void destroy()
```
    Description copied from interface: XmlDataCursor
    
    Release any resources associated with the current cursor. The cursor becomes unpositioned and no longer has any content.
    
    Specified by:
    
    destroy in interface XmlDataCursor
  - first
```
public boolean first()
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor at the first tag-object-pair. Objects are either values paired with element-tags, group-values paired with group-tags, any-items paired with any-tags, or substitution-items paired with substitution-tags. If there is no first tag-object-pair, the cursor remains unpositioned.
    
    Specified by:
    
    first in interface XmlDataCursor
    
    Returns:
    
    true if there is a first item
  - first
```
public boolean first(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the first tag-object-pair with the specified tag and returns true. Otherwise return false and leaves the cursor unchanged.
    
    Specified by:
    
    first in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if item is found
  - firstPartial
```
public boolean firstPartial(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the first tag-object-pair with a tag that partially matches the specified tag. Otherwise returns false and leave the cursor unchanged. For purposes of comparison, the particle-ids of the tags are ignored during comparison in order to find the first occurrence regardless of its particle-id. It is as if the home() method is invoked and then the next() method is invoked until the condition tag.getPartialName().equals(cursor.getTag().getPartialName()) is satisfied.
    
    Specified by:
    
    firstPartial in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if item is found
  - firstChild
```
public boolean firstChild()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the first child of the current-value. Only group-values and complex-values with group-value content have children. If the current-value does not contain a child, (for example it contains a String or an empty IData), false is returned and the cursor position remains unchanged. If the current-value has one or more children, the current-cursor is pushed onto a stack and a new cursor is positioned on the first child item. If it is necessary to obtain a cursor on empty content, consider method XmlDataCursor.getValueCursor(int...).
    
    Specified by:
    
    firstChild in interface XmlDataTreeCursor
    
    Returns:
    
    true if the current-value has children
  - firstItem
```
public boolean firstItem()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the first item. The current-item becomes the first tag-object-pair. If the first object is an array (repeating values), the cursor is positioned on first item in the array by setting the current-index to zero. In other words, the first item is the first member of a repeating values Object array. If the first object is not an array, then the first item is simply the first object.
    
    Specified by:
    
    firstItem in interface XmlDataTreeCursor
    
    Returns:
    
    true if there is a first item.
  - getAnyTag
```
public XmlDataContentTag getAnyTag(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getAnyTag(int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getAnyTag in interface XmlDataCursor
    
    Specified by:
    
    getAnyTag in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    the content of the complex value
    
    See Also:
    
    XmlDataCursor.getAttributeNames(int...)
  - getAttributeNames
```
public XmlDataAttributeTag[] getAttributeNames(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getAttributeNames(int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getAttributeNames in interface XmlDataCursor
    
    Specified by:
    
    getAttributeNames in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    array of XmlDataAttributeTags
    
    See Also:
    
    XmlDataCursor.getAttributeNames(int...)
  - getAttributes
```
public IData getAttributes(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getAttributes(int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getAttributes in interface XmlDataCursor
    
    Specified by:
    
    getAttributes in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    the IData associated with the *attributes tag, the attribute definitions
    
    See Also:
    
    XmlDataCursor.getAttributes(int...)
  - getAttributeValue
```
public java.lang.String getAttributeValue(XmlDataAttributeTag attribute,
                                          int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getAttributeValue(XmlDataAttributeTag, int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getAttributeValue in interface XmlDataCursor
    
    Specified by:
    
    getAttributeValue in interface XmlDataTreeCursor
    
    Parameters:
    
    attribute - the tag of the attribute XmlDataAttributeTag)
    
    index - the index of the repeating value
    
    Returns:
    
    the attribute value
    
    See Also:
    
    XmlDataCursor.getAttributeValue(XmlDataAttributeTag, int...)
  - getContent
```
public java.lang.Object getContent(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getContent(int...) except that an omitted index references the current-item content rather than the first and only item content.
    
    Specified by:
    
    getContent in interface XmlDataCursor
    
    Specified by:
    
    getContent in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    the content of the requested item; content is always either simple content (a String) or group content (i.e. an IData of tag/object pairs)
    
    See Also:
    
    XmlDataCursor.getContent(int...)
  - getComplexValueContent
```
public java.lang.Object getComplexValueContent(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getComplexValueContent(int...) except that an omitted index references the current-item content rather than the first and only item content.
    
    Specified by:
    
    getComplexValueContent in interface XmlDataCursor
    
    Specified by:
    
    getComplexValueContent in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    the content of the complex value
    
    See Also:
    
    XmlDataCursor.getComplexValueContent(int...)
  - getInstanceProp
```
public java.lang.String getInstanceProp(java.lang.String name,
                                        int... optionalIndex)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getInstanceProp(String, int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getInstanceProp in interface XmlDataCursor
    
    Specified by:
    
    getInstanceProp in interface XmlDataTreeCursor
    
    Parameters:
    
    name - the name of the xsi property (e.g. nil, type)
    
    optionalIndex - the index of the repeating value
    
    Returns:
    
    the value of the specified instance property
    
    See Also:
    
    XmlDataCursor.getInstanceProp(String, int...)
  - getItem
```
public java.lang.Object getItem(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getItem(int...) except that an omitted index references the current-item rather than the first and only item.
    
    Specified by:
    
    getItem in interface XmlDataCursor
    
    Specified by:
    
    getItem in interface XmlDataTreeCursor
    
    Parameters:
    
    index - offset into the repeating content array (if repeating content is present)
    
    Returns:
    
    the requested item
    
    See Also:
    
    XmlDataCursor.getItem(int...)
  - getNamespaceDecl
```
public java.lang.String getNamespaceDecl(java.lang.String prefix,
                                         int... optionalIndex)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getNamespaceDecl(String, int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getNamespaceDecl in interface XmlDataCursor
    
    Specified by:
    
    getNamespaceDecl in interface XmlDataTreeCursor
    
    Parameters:
    
    prefix - the prefix
    
    optionalIndex - the index of the repeating value
    
    Returns:
    
    the value of the specified prefix
    
    See Also:
    
    XmlDataCursor.getNamespaceDecl(String, int...)
  - getNamespaceDecls
```
public IData getNamespaceDecls(int... optionalIndex)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getNamespaceDecls(int...) except that an omitted index references the current-item rather than the first and only item content.
    
    Specified by:
    
    getNamespaceDecls in interface XmlDataCursor
    
    Specified by:
    
    getNamespaceDecls in interface XmlDataTreeCursor
    
    Parameters:
    
    optionalIndex - the index of the repeating value
    
    Returns:
    
    the IData containing the namespace declarations
    
    See Also:
    
    XmlDataCursor.getNamespaceDecls(int...)
  - getTag
```
public XmlDataContentTag getTag()
```
    Description copied from interface: XmlDataCursor
    
    Returns the current-tag as a parsed-tag. The tag will be either an XmlDataElementTag, an XmlDataAnyTag, an XmlDataGroupTag, or an XmlDataSubstitutionTag. An exception is thrown if the cursor is not positioned.
    
    Specified by:
    
    getTag in interface XmlDataCursor
    
    Returns:
    
    One of the XmlDataContentTags mentioned above.
  - getObject
```
public java.lang.Object getObject()
```
    Description copied from interface: XmlDataCursor
    
    Returns the current-object, the object stored at the current-position. If repeating values are present, then the entire array is returned. It is an error if the cursor is unpositioned. Normally, getObject will return a String, String[], IData, IData[], or Object[]. If the current-tag is an element-tag, a value or array of values is returned; if the the current-tag is a group-tag, a group-value or array of group-values is returned; if the current-tag is an any-tag, an any-item or array of any-items is returned; if the current-tag is a substitution-tag, a substitution-item or an array of substitution-items is returned.
    
    Specified by:
    
    getObject in interface XmlDataCursor
    
    Returns:
    
    object stored at current cursor position
  - getValue
```
public java.lang.Object getValue(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getValue(int...) except that an omitted index references the current-item value rather than the first and only item value.
    
    Specified by:
    
    getValue in interface XmlDataCursor
    
    Specified by:
    
    getValue in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content
    
    Returns:
    
    the requested item value (which is the item itself, or the value if it is an indirect item)
    
    See Also:
    
    XmlDataCursor.getValue(int...)
  - getValueCursor
```
public XmlDataCursor getValueCursor(int... index)
```
    Description copied from interface: XmlDataCursor
    
    Returns an XmlDataCursor positioned on the first child of the specified value in the current-object. If the current value is not a group-value or a complex-value with non-repeating top-level group content, a null is returned. If the value is an empty XmlData, the returned cursor is in home state.
    
    Specified by:
    
    getValueCursor in interface XmlDataCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    an XmlDataCursor positioned on the first child of the current value.
  - getValueTag
```
public XmlDataContentTag getValueTag(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.getValueTag(int...) except that an omitted index references the current-item value-tag rather than the first and only item's value-tag.
    
    Specified by:
    
    getValueTag in interface XmlDataCursor
    
    Specified by:
    
    getValueTag in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index of the repeating value
    
    Returns:
    
    the item value-tag
    
    See Also:
    
    XmlDataCursor.getValueTag(int...)
  - hasAttributes
```
public boolean hasAttributes(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is exactly like XmlDataCursor.hasAttributes(int...) except that an omitted index references the current-item value rather than the first and only item value.
    
    Specified by:
    
    hasAttributes in interface XmlDataCursor
    
    Specified by:
    
    hasAttributes in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content (or no index for the current-item)
    
    Returns:
    
    true if the specified item has attributes
    
    See Also:
    
    XmlDataCursor.hasAttributes(int...)
  - home
```
public void home()
```
    Description copied from interface: XmlDataCursor
    
    The cursor becomes unpositioned as if newly created.
    
    Specified by:
    
    home in interface XmlDataCursor
  - insertItemAfter
```
public void insertItemAfter(java.lang.Object value)
```
    Description copied from interface: XmlDataTreeCursor
    
    Inserts an item after the current-item in a repeating value. An item may be either a value or an indirect-item. The item must be compatible with the current-tag. When the current-item is an element or a group, this method behaves exactly like XmlDataTreeCursor.insertValueAfter(XmlDataContentTag, Object) and the item is treated like a value. If the current-tag is a substitution-tag, a properly formatted substitution-item must be provided. If the current-tag is an any-tag, a properly formatted any-item must be provided. This method is unlike XmlDataTreeCursor.insertValueAfter(XmlDataContentTag, Object) because that method creates an indirect-item from a value while this method expects an indirect-item that has already been created. This method differs from XmlDataCursor.insertItemAfter(Object, int) because an index is not required. When no index is specified the current-index is used.
    
    Specified by:
    
    insertItemAfter in interface XmlDataTreeCursor
    
    Parameters:
    
    value - the item to insert
  - insertItemAfter
```
public void insertItemAfter(java.lang.Object item,
                            int index)
```
    Description copied from interface: XmlDataCursor
    
    Inserts an item after the specified index into the array of repeating values at the current-position. An index of -1 causes the item to be appended to the end of the array. Otherwise, the index must be a number between 0 and the length of the array minus 1. An item may be either a value or an indirect-item. When the current-tag is a substitution-tag, the value must be a substitution-item. When the current-tag is an any-tag, the value must be an an any-item. These items may be created, for example, using XmlData.createSubstitutionItem(XmlDataElementTag, Object) or XmlData.createAnyItem(XmlDataContentTag, Object). If the current-object is a scalar, it is promoted to an array prior to insertion of the new item. If the cursor has recast set to true, the new array is an Object[].
    
    Specified by:
    
    insertItemAfter in interface XmlDataCursor
    
    Parameters:
    
    item - the scalar value inserted (must be simple-value, group-value, complex-value, or indirect-item)
    
    index - The insert position after which the value is inserted
  - insertObjectAfter
```
public void insertObjectAfter(XmlDataContentTag tag,
                              java.lang.Object value)
```
    Description copied from interface: XmlDataCursor
    
    Inserts a tag-object-pair after the current-position. The object may be a value, an indirect-item, or a list of values or indirect-items. The tag and values must be compatible. For example, a group-tag may only have a group-value or an array of group-values, a substitution-tag must have a substitution-item or array of substitution-items, etc.
    
    Specified by:
    
    insertObjectAfter in interface XmlDataCursor
    
    Parameters:
    
    tag - the tag of the tag/object pair to be inserted before the current cursor position
    
    value - the item or array of repeating values that is inserted (must be String, String[], IData, IData[], or Object[])
  - insertObjectBefore
```
public void insertObjectBefore(XmlDataContentTag tag,
                               java.lang.Object value)
```
    Description copied from interface: XmlDataCursor
    
    Inserts a tag-object-pair before the current-position. The object may be a value, an indirect-item, or a list of values or indirect-items. The tag and values must be compatible. For example, a group-tag may only have a group-value or an array of group-values, a substitution-tag must have a substitution-item or array of substitution-items, etc.
    
    Specified by:
    
    insertObjectBefore in interface XmlDataCursor
    
    Parameters:
    
    tag - the tag of the tag/object pair to be inserted before the current cursor position
    
    value - the item or array of repeating values that is inserted (must be String, String[], IData, IData[], or Object[])
  - insertItemBefore
```
public void insertItemBefore(java.lang.Object value)
```
    Description copied from interface: XmlDataTreeCursor
    
    Inserts an item before the current-item in a repeating value. An item may be either a value or an indirect-item. The item must be compatible with the current-tag. When the current-item is an element or a group, this method behaves exactly like XmlDataTreeCursor.insertValueBefore(XmlDataContentTag, Object) and the item is treated like a value. If the current-tag is a substitution-tag, a properly formatted substitution-item must be provided. If the current-tag is an any-tag, a properly formatted any-item must be provided. This method is unlike XmlDataTreeCursor.insertValueBefore(XmlDataContentTag, Object) because that method creates an indirect-item from a value while this method expects an indirect-item that has already been created. This method differs from XmlDataCursor.insertItemBefore(Object, int) because an index is not required. When no index is specified the current-index is used.
    
    Specified by:
    
    insertItemBefore in interface XmlDataTreeCursor
    
    Parameters:
    
    value - the item to insert
  - insertItemBefore
```
public void insertItemBefore(java.lang.Object value,
                             int index)
```
    Description copied from interface: XmlDataCursor
    
    Inserts an item before the specified index into the array of repeating values at the current-position. An index == array.length adds to end. An index of -1 inserted the values before the last value. An item may be either a value or an indirect-item. When the current-tag is a substitution-tag, the value must be a substitution-item. When the current current-tag is an any-tag, the value must be an an any-item. These item may be created, for example, using XmlData.createSubstitutionItem(XmlDataElementTag, Object) or XmlData.createAnyItem(XmlDataContentTag, Object). If the current-object is a scalar, it is promoted to an array prior to insertion of the new item. If the cursor has recast set to true, the new array is an Object[].
    
    Specified by:
    
    insertItemBefore in interface XmlDataCursor
    
    Parameters:
    
    value - the scalar value inserted (must be simple-value, group-value, complex-value, or indirect-item)
    
    index - the index position before which the value is inserted
  - insertValueAfter
```
public void insertValueAfter(XmlDataContentTag tag,
                             java.lang.Object value)
```
    Description copied from interface: XmlDataTreeCursor
    
    Inserts a value and value-tag after the current-item. For element-tags and group-tags, this method inserts the value directly into the repeating value array and the value-tag is not used and may be null. If a tag is specified, it must match the current-tag. For substitution-tags and any-tags, an indirect-item is created from the value-tag and value and is inserted into the repeating values after the current-index. This method is an extension beyond XmlDataCursor.insertValueAfter(XmlDataContentTag, Object, int) because this method allows insertion without specifying an index (the current index is used). XmlDataCursor does not support insertAfter without an index.
    
    Specified by:
    
    insertValueAfter in interface XmlDataTreeCursor
    
    Parameters:
    
    tag - the tag used to construct the indirect-item (or null if not needed)
    
    value - the value used directly for elements and groups or the value used to construct the indirect-item
  - insertValueAfter
```
public void insertValueAfter(XmlDataContentTag tag,
                             java.lang.Object value,
                             int index)
```
    Description copied from interface: XmlDataCursor
    
    Inserts a value into an array of repeating values at the current-position, after the specified index. An index of -1 causes the item to be appended to the end of the array. Otherwise, the index must be a number between 0 and the length of the array minus 1. If the current-tag is an element-tag or group-tag, the value is inserted directly into the repeating value array at the specified offset. The content-tag is irrelevant (for groups and elements) and may be null. If not null, it must match the current tag. If the current-tag is a substitution-tag or an any-tag, a substitution-item or any-item is created from the content-tag and value, and inserted into the repeating values at the specified index offset. If the current Object is a scalar, it is promoted to an array prior to insertion of the new item. If the cursor has recast set to true, the new array is an Object[].
    
    Specified by:
    
    insertValueAfter in interface XmlDataCursor
    
    Parameters:
    
    tag - the name of the repeating value for indirect-items (may be null if current tag is an element and group)
    
    value - the value to insert (if the current tag is an any tag and the content tag is a substitution tag, value must be a substitution value).
    
    index - the index of the repeating item
  - insertValueBefore
```
public void insertValueBefore(XmlDataContentTag tag,
                              java.lang.Object value)
```
    Description copied from interface: XmlDataTreeCursor
    
    Inserts a value and value-tag before the current-item. For element-tags and group-tags, this method inserts the value directly into the repeating value array and the value-tag is not used and may be null. If a tag is specified, it must match the current-tag. For substitution-tags and any-tags, an indirect-item is created from the value-tag and value and is inserted into the repeating value before the current-index . This method is an extension beyond XmlDataCursor.insertValueBefore(XmlDataContentTag, Object, int) because this method allows insert without specifying an index (the current index is used). XmlDataCursor does not support insertAfter without an index.
    
    Specified by:
    
    insertValueBefore in interface XmlDataTreeCursor
    
    Parameters:
    
    tag - the tag used to construct the indirect-item (or null if not needed)
    
    value - the value used directly for elements and groups or the value used to construct the indirect-item
  - insertValueBefore
```
public void insertValueBefore(XmlDataContentTag tag,
                              java.lang.Object value,
                              int index)
```
    Description copied from interface: XmlDataCursor
    
    Inserts a value into an array of repeating values at the current-position, before the specified index. If the current-tag is an element-tag or group-tag, the value is inserted directly into the repeating value array at the specified offset. The content-tag is irrelevant (for groups and elements) and may be null. If not null, it must match the current tag. If the current-tag is a substitution-tag or an any-tag, a substitution-item or any-item is created from the content-tag tag and value, and inserted into the repeating values before the specified index offset. If the current Object is a scalar it is promoted to an array prior to insertion of the new item. If the cursor has recast set to true, the new array is an Object[].
    
    Specified by:
    
    insertValueBefore in interface XmlDataCursor
    
    Parameters:
    
    tag - the tag of the value for indirect-items (may be null if current tag is an element and group tag)
    
    value - the value to insert (if the current tag is an any tag and the content tag is a substitution tag, value must be a substitution value).
    
    index - the index of the repeating item
  - isAny
```
public boolean isAny()
```
    Description copied from interface: XmlDataCursor
    
    Determines if the current-tag is an any-tag.
    
    Specified by:
    
    isAny in interface XmlDataCursor
    
    Returns:
    
    true if the current item has an XmlDataAnyTag tag
  - isComplexValue
```
public boolean isComplexValue(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.isComplexValue(int...) except that an omitted index references the current-item.
    
    Specified by:
    
    isComplexValue in interface XmlDataCursor
    
    Specified by:
    
    isComplexValue in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content (or no index for the current-item)
    
    Returns:
    
    true if the specified item is a complex-value.
  - isEmpty
```
public boolean isEmpty(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.isEmpty(int...) except that an omitted index references the current-item.
    
    Specified by:
    
    isEmpty in interface XmlDataCursor
    
    Specified by:
    
    isEmpty in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content (or no index for the current-item)
    
    Returns:
    
    true if the specified item is empty.
    
    See Also:
    
    XmlDataCursor.isEmpty(int...)
  - isGroup
```
public boolean isGroup()
```
    Description copied from interface: XmlDataCursor
    
    Determines if the current-tag is a group-tag.
    
    Specified by:
    
    isGroup in interface XmlDataCursor
    
    Returns:
    
    true if the current item has an XmlDataGroupTag tag
    
    See Also:
    
    XmlDataContentTag.isGroup()
  - isGroupValue
```
public boolean isGroupValue(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.isGroupValue(int...) except that an omitted index references the current-item.
    
    Specified by:
    
    isGroupValue in interface XmlDataCursor
    
    Specified by:
    
    isGroupValue in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content (or no index for the current-item)
    
    Returns:
    
    true if the specified item is a group-value.
    
    See Also:
    
    XmlData.isGroupValue(Object)
  - isHome
```
public boolean isHome()
```
    Description copied from interface: XmlDataCursor
    
    Indicates whether the cursor is unpositioned.
    
    Specified by:
    
    isHome in interface XmlDataCursor
    
    Returns:
    
    true if the cursor is unpositioned
  - isRecast
```
public boolean isRecast()
```
    Description copied from interface: XmlDataCursor
    
    Indicates if automatic recast is in effect.
    
    Specified by:
    
    isRecast in interface XmlDataCursor
    
    Returns:
    
    true if it is in effect
  - isRepeating
```
public boolean isRepeating()
```
    Description copied from interface: XmlDataCursor
    
    Determines if the current-object is a repeating value. True is returned in the current-object is array (by convention, zero-length arrays are not allowed). False is returned if the current-object is not an array.
    
    Specified by:
    
    isRepeating in interface XmlDataCursor
    
    Returns:
    
    true if current-object contains a repeating value
  - isSimpleValue
```
public boolean isSimpleValue(int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.isSimpleValue(int...) except that an omitted index references the current-item.
    
    Specified by:
    
    isSimpleValue in interface XmlDataCursor
    
    Specified by:
    
    isSimpleValue in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the offset into repeating content (or no index for the current-item)
    
    Returns:
    
    true if the specified item is a simple-value.
  - isSubstitution
```
public boolean isSubstitution()
```
    Description copied from interface: XmlDataCursor
    
    Determines if the current-tag is a substitution-tag
    
    Specified by:
    
    isSubstitution in interface XmlDataCursor
    
    Returns:
    
    true if the current-object has an substitution-tag
  - isTop
```
public boolean isTop()
```
    Description copied from interface: XmlDataTreeCursor
    
    Determines if the XmlDataTreeCursor is positioned somewhere in the top level.
    
    Specified by:
    
    isTop in interface XmlDataTreeCursor
    
    Returns:
    
    true if the TreeCursor is position on a top-level entry
  - last
```
public boolean last()
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor at the last tag-object-pair. Objects are either values paired with element-tags, group-values paired with group-tags, any-items paired with any-tags, or substitution-items paired with substitution-tags. If there is no last tag-object-pair, the cursor remains unpositioned.
    
    Specified by:
    
    last in interface XmlDataCursor
    
    Returns:
    
    true if there is a last value
  - last
```
public boolean last(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the last occurrence of the last tag-object-pairg with the specified tag and return true. Otherwise return false and leave the cursor unchanged.
    
    Specified by:
    
    last in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if tag is found
  - lastPartial
```
public boolean lastPartial(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positiosn the cursor on the last tag-object-pair with a tag that partially matches the specified tag. Otherwise return false and leave the cursor unchanged. For purposes of comparison, the particle-ids of the tags are ignored during comparison in order to find the last occurrence regardless of its particle-id. It is as if the last() method is invoked and then the previous() method is invoked until the condition tag.getPartialName().equals(cursor.getTag().getPartialName()) is satisfied.
    
    Specified by:
    
    lastPartial in interface XmlDataCursor
    
    Parameters:
    
    key - the XmlDataContentTag to be searched
    
    Returns:
    
    true if tag is found
  - lastChild
```
public boolean lastChild()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the last child value of the current-value. Only group-values and complex-values with group-value content have children. If the current-value does not contain a child, (for example it contains a String or an empty IData), false is returned and cursor position remains unchanged. If the current-value has one or more children, the current-cursor is pushed onto a stack and a new cursor is positioned on the last child item. If it is necessary to obtain a cursor on empty content, consider method XmlDataCursor.getValueCursor(int...).
    
    Specified by:
    
    lastChild in interface XmlDataTreeCursor
    
    Returns:
    
    true if the current-value has children
  - lastItem
```
public boolean lastItem()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the last item. The current-item becomes the last tag-object-pair. If the last object is an array (repeating values), the cursor is positioned on the last item in the array by setting the current-index to the length of the array minus one.
    
    Specified by:
    
    lastItem in interface XmlDataTreeCursor
    
    Returns:
    
    true if positioned to the last item.
  - newCursor
```
public XmlDataTreeCursor newCursor(IData data)
```
    Description copied from interface: XmlDataCursor
    
    Creates a new XmlDataCuror instances from an existing cursor factory.
    
    Specified by:
    
    newCursor in interface XmlDataCursor
    
    Parameters:
    
    data - an existing IData who's cursor factory is used to create a new XmlDataCursor instance.
    
    Returns:
    
    a new cursor using the same factory that create this cursor.
  - next
```
public boolean next()
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the next tag-object-pair. Returns false if there is no next pair and the cursor remains unchanged.
    
    Specified by:
    
    next in interface XmlDataCursor
    
    Returns:
    
    true if there is a next tag-object pair.
  - next
```
public boolean next(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positiona the cursor on the next tag-object-pair that has the specified tag and returns true. Otherwise returns false and leaves the cursor unchanged.
    
    Specified by:
    
    next in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if tag is found
  - nextPartial
```
public boolean nextPartial(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the next tag-object-pair with a tag that partially matches the specified tag. Otherwise returns false and leavse the cursor unchanged. For purposes of comparison, the particle-ids of the tags are ignored during comparison in order to find the next occurrence regardless of its particle-id. It is as if the next() method is invoked until the condition tag.getPartialName().equals(cursor.getTag().getPartialName()) is satisfied.
    
    Specified by:
    
    nextPartial in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if item is found
  - nextInOrder
```
public java.lang.Integer nextInOrder()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor to the next in-order item. If there is no next item (at the current tree level), the cursor is positioned on the first item in the parent's next item. If the cursor is unpositioned, the cursor is positioned on the first item in the XmlData infoset tree.
    
    Specified by:
    
    nextInOrder in interface XmlDataTreeCursor
    
    Returns:
    
    the change in tree depth (or null if there is no next in order)
  - nextItem
```
public boolean nextItem()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the next item. When more than one item is associated with the current-tag, the current-index is incremented. If the current-index is at the last repeating value or here are no repeating values, the cursor is positioned on the next tag-object-pair. If the new tag-value-pair contains repeating values, the current-index is set to zero. If there is no next item, the cursor remains unchanged.
    
    Specified by:
    
    nextItem in interface XmlDataTreeCursor
    
    Returns:
    
    true if there is a next item
  - nextItem
```
public boolean nextItem(XmlDataContentTag key)
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the next item with the specified tag. The match is based on the current-tag. For example, if a substitution-item is present, the match comparison is performed against the substitution-tag. When repeating values are present and the search tag matches the current-tag, only the current-index is advanced and the current-position remains unchanged (unless already positioned on the last item of a repeating value). In order to find the next item based on the item's value-tag, which is probably more typical, use the XmlDataTreeCursor.nextValueTag(XmlDataContentTag) method. The tag match is based on the partial-name (it does not include the particle-id).
    
    Specified by:
    
    nextItem in interface XmlDataTreeCursor
    
    Parameters:
    
    key - the tag that is compared to item tags
    
    Returns:
    
    true if the item is found
  - nextValueTag
```
public boolean nextValueTag(XmlDataContentTag key)
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the next item with a value-tag that matches the search tag. For normal elements, this is the same as XmlDataTreeCursor.nextItem(XmlDataContentTag). However, for any-items and substitution-items, the XmlDataTreeCursor.nextItem()'s value-tag is used for comparison. This method is more easily used for a general search than the XmlDataTreeCursor.nextItem(XmlDataContentTag) method because the user can search without concern for whether the items are normal elements or indirect-items. The tag match is based on the partial-name (it does not include the particle-id).
    
    Specified by:
    
    nextValueTag in interface XmlDataTreeCursor
    
    Parameters:
    
    key - the tag which is compared to item value-tags
    
    Returns:
    
    true if the the next matching item is found
  - parent
```
public boolean parent()
```
    Description copied from interface: XmlDataTreeCursor
    
    Moves the XmlDataTreeCursor up one level by popping the top-level cursor from the internal stack of cursor. Returns false if already at the top level. Destroys the current cursor before moving up one level. If XmlDataTreeCursor.firstChild() or XmlDataTreeCursor.lastChild() had never been invoked on this cursor, the parent() method will always return false.
    
    Specified by:
    
    parent in interface XmlDataTreeCursor
    
    Returns:
    
    true if the current-item has a parent. If already at top, no action is performed and false is returned.
  - previous
```
public boolean previous()
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the previous tag-object-pair. Returns false if there is no previous item and the cursor remains unchanged.
    
    Specified by:
    
    previous in interface XmlDataCursor
    
    Returns:
    
    true if there is a previous item
  - previous
```
public boolean previous(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the previous tag-object-pair with the specified tag and return true. Otherwise returns false and leaves the cursor unchanged.
    
    Specified by:
    
    previous in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if item is found
  - previousPartial
```
public boolean previousPartial(XmlDataContentTag key)
```
    Description copied from interface: XmlDataCursor
    
    Positions the cursor on the previous tag-object-pair with a tag that partially matches the specified tag. Otherwise returns false and leave the cursor unchanged. For purposes of comparison, the particle-ids of the tags are ignored during comparison in order to find the previous occurrence regardless of its particle-id. It is as if the previous() method is invoked until the condition tag.getPartialName().equals(cursor.getTag().getPartialName()) is satisfied.
    
    Specified by:
    
    previousPartial in interface XmlDataCursor
    
    Parameters:
    
    key - the searched content-tag
    
    Returns:
    
    true if item is found
  - previousInOrder
```
public java.lang.Integer previousInOrder()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions the cursor to the previous in-order item. If there is no previous item, the cursor is positioned on the last child in the parent's previous item. If the cursor is unpositioned, the cursor is positioned on the last item in the XmlData infoset tree.
    
    Specified by:
    
    previousInOrder in interface XmlDataTreeCursor
    
    Returns:
    
    the change in tree depth (or null if there is no previous item)
  - previousItem
```
public boolean previousItem()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the previous item. When more than one item is associated with the current-tag, the current-index is decremented. If the current-index is already zero or here are no repeating values, the cursor is positioned on the previous tag-object pair. If the new tag-value-pair contains repeating values, the current-index is set to the index of the last value. If there are no repeating values, the current-index is set to zero. If there is no previous item, the cursor remains unchanged.
    
    Specified by:
    
    previousItem in interface XmlDataTreeCursor
    
    Returns:
    
    true if there is a previous value
  - previousItem
```
public boolean previousItem(XmlDataContentTag key)
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor on the previous item with the specified tag. The match is based on the current-tag. For example, if a substitution-item is present, the match comparison is performed against the substitution-tag. When repeating values are present and the search tag matches the current-tag, only the current-index is advanced and the current-position remains unchanged (unless already positioned on the first item of a repeating value). In order to find the previous item based on the item's value-tag, which is probably more typical, use the XmlDataTreeCursor.previousValueTag(XmlDataContentTag) method. The tag match is based on the partial-name (it does not include the particle-id).
    
    Specified by:
    
    previousItem in interface XmlDataTreeCursor
    
    Parameters:
    
    key - the raw tag
    
    Returns:
    
    true if the item is found
  - previousValueTag
```
public boolean previousValueTag(XmlDataContentTag key)
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions this cursor the previous item with a value-tag that matches the search tag. For normal elements, this is the same as XmlDataTreeCursor.previousItem(XmlDataContentTag). However, for any-items and substitution-items the XmlDataTreeCursor.previousItem()'s value-tag is used for comparison. This method is more easily used for a general search than XmlDataTreeCursor.previousItem(XmlDataContentTag) because the user can search without concern for whether the items are normal elements or indirect-items. The tag match is based on the partial-name (it does not include the particle-id).
    
    Specified by:
    
    previousValueTag in interface XmlDataTreeCursor
    
    Parameters:
    
    key - the tag which is compared
    
    Returns:
    
    true if the the previous matching item is found
  - recast
```
public void recast(boolean mode)
```
    Description copied from interface: XmlDataCursor
    
    Indicates whether existing String[] or IData[] arrays for repeating values should be automatically recreated as an Object[] when the inserted or set value type doesn't match the type of the repeating item array that is already present. This is typically set true when inserting values into an infoset that was created without a document type template and therefore contains Object[]s rather than String[] and IData[]s.
    
    Specified by:
    
    recast in interface XmlDataCursor
    
    Parameters:
    
    mode - true causes automatic recast; default is false
  - removeAttribute
```
public boolean removeAttribute(XmlDataAttributeTag attribute,
                               int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    Removes the specified attribute. The behavior is similar to XmlDataCursor.removeAttribute(XmlDataAttributeTag, int...) except that an omitted index references the current-item.
    
    Specified by:
    
    removeAttribute in interface XmlDataCursor
    
    Specified by:
    
    removeAttribute in interface XmlDataTreeCursor
    
    Parameters:
    
    attribute - an XmlDataAttributeTag naming the attribute
    
    index - the offset of the element is a repeating value; an omitted index references the current-item
    
    Returns:
    
    true if the attribute existed
    
    See Also:
    
    XmlDataCursor.removeAttribute(XmlDataAttributeTag, int...)
  - setAnyTag
```
public void setAnyTag(XmlDataContentTag tag,
                      int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setAnyTag(XmlDataContentTag, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setAnyTag in interface XmlDataCursor
    
    Specified by:
    
    setAnyTag in interface XmlDataTreeCursor
    
    Parameters:
    
    tag - the tag used to set the ncName and namespace of the anyItem at the current cursor.
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor.setAnyTag(XmlDataContentTag, int...), XmlDataCursor.setAnyTag(XmlDataContentTag, int...)
  - setAttributes
```
public void setAttributes(IData attributes,
                          int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setAttributes(IData, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setAttributes in interface XmlDataCursor
    
    Specified by:
    
    setAttributes in interface XmlDataTreeCursor
    
    Parameters:
    
    attributes - an IData containing attribute-tag/value pairs.
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor.setAnyTag(XmlDataContentTag, int...), XmlDataCursor.setAttributes(IData, int...)
  - setAttributeValue
```
public void setAttributeValue(XmlDataAttributeTag attribute,
                              java.lang.String value,
                              int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setAttributeValue(XmlDataAttributeTag, String, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setAttributeValue in interface XmlDataCursor
    
    Specified by:
    
    setAttributeValue in interface XmlDataTreeCursor
    
    Parameters:
    
    attribute - an XmlDataAttributeTag
    
    value - the value to set (must be a String)
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor.setAnyTag(XmlDataContentTag, int...), XmlDataCursor.setAttributeValue(XmlDataAttributeTag, String, int...)
  - setComplexValueContent
```
public void setComplexValueContent(java.lang.Object data,
                                   int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is exactly the same XmlDataCursor.setComplexValueContent(java.lang.Object, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setComplexValueContent in interface XmlDataCursor
    
    Specified by:
    
    setComplexValueContent in interface XmlDataTreeCursor
    
    Parameters:
    
    data - the item content
    
    index - optional offset when repeating values are present
    
    See Also:
    
    XmlDataCursor.setComplexValueContent(Object, int...)
  - setContent
```
public void setContent(java.lang.Object data,
                       int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is exactly the same XmlDataCursor.setContent(java.lang.Object, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setContent in interface XmlDataCursor
    
    Specified by:
    
    setContent in interface XmlDataTreeCursor
    
    Parameters:
    
    data - the item content
    
    index - optional offset when repeating values are present
    
    See Also:
    
    XmlDataCursor.setContent(Object, int...)
  - setIndex
```
public void setIndex(int index)
```
    Description copied from interface: XmlDataTreeCursor
    
    Establishes the current-item in repeating values. The cursor must be positioned. It is an error to set the index when the cursor is unpositioned.
    
    Specified by:
    
    setIndex in interface XmlDataTreeCursor
    
    Parameters:
    
    index - the index specifying the current-item
  - setInstanceProp
```
public void setInstanceProp(java.lang.String name,
                            java.lang.String value,
                            int... index)
```
    Description copied from interface: XmlDataCursor
    
    Sets an XML instance property (xsi attribute) on the current item. If the current item has repeating values, an index is required.
    
    Specified by:
    
    setInstanceProp in interface XmlDataCursor
    
    Specified by:
    
    setInstanceProp in interface XmlDataTreeCursor
    
    Parameters:
    
    name - the name of the property(e.g. 'nil')
    
    value - the value of the property (e.g. 'true')
    
    index - the offset index into repeating values
  - setNamespaceDecl
```
public void setNamespaceDecl(java.lang.String prefix,
                             java.lang.String uri,
                             int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setNamespaceDecl(String, String, int...) except that an omitted index always references the current-item rather the first and only item.
    
    Specified by:
    
    setNamespaceDecl in interface XmlDataCursor
    
    Specified by:
    
    setNamespaceDecl in interface XmlDataTreeCursor
    
    Parameters:
    
    prefix - the prefix for which the namespace is established
    
    uri - the uri assigned to the prefix
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor, XmlDataCursor.setNamespaceDecls(IData, int...)
  - setNamespaceDecls
```
public void setNamespaceDecls(IData nsDecls,
                              int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setNamespaceDecls(IData, int...) except that an omitted index always references the current-item rather the first and only item.
    
    Specified by:
    
    setNamespaceDecls in interface XmlDataCursor
    
    Specified by:
    
    setNamespaceDecls in interface XmlDataTreeCursor
    
    Parameters:
    
    nsDecls - an IData containing prefixes and URIs
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor, XmlDataCursor.setNamespaceDecls(IData, int...)
  - setItem
```
public void setItem(java.lang.Object object,
                    int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setItem(java.lang.Object, int...) except that an omitted index always accesses the current-item rather than the first and only item.
    
    Specified by:
    
    setItem in interface XmlDataCursor
    
    Specified by:
    
    setItem in interface XmlDataTreeCursor
    
    Parameters:
    
    object - the item that replaces the current-item
    
    index - the position in the list of repeating values to be set. When index is not specified, the current-item is replaced.
    
    See Also:
    
    XmlDataCursor, XmlDataCursor.setItem(Object, int...)
  - setObject
```
public void setObject(java.lang.Object value)
```
    Description copied from interface: XmlDataCursor
    
    Sets the object stored at the current cursor position ( a value or array of repeating values). It is an error if the cursor is unpositioned. The Object must be a String, an IData, a String[], an IData[], or an Object[].
    
    Specified by:
    
    setObject in interface XmlDataCursor
    
    Parameters:
    
    value - the offset to be stored at the current element.
  - setTag
```
public void setTag(XmlDataContentTag tag)
```
    Description copied from interface: XmlDataCursor
    
    Sets the tag of the current tag-object pair. The tag must be either an XmlDataElementTag, an XmlDataAnyTag, an XmlDataGroupTag, or an XmlDataSubstitutionTag. The tag must be compatible with the current value. A group tag can only be assigned to an item with IData content. An any tag can only be assigned to an item with content in the any format. An element tag may not be assigned to content that is in the any or substitution head format.
    
    Specified by:
    
    setTag in interface XmlDataCursor
    
    Parameters:
    
    tag - is one of the XmlDataContentTags mentioned above.
  - setValue
```
public void setValue(java.lang.Object object,
                     int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setValue(java.lang.Object, int...) except that an omitted index always accesses the current-item value rather than the first and only item value.
    
    Specified by:
    
    setValue in interface XmlDataCursor
    
    Specified by:
    
    setValue in interface XmlDataTreeCursor
    
    Parameters:
    
    object - the item value that replaces the current-item value
    
    index - the position in the list of repeating item values to be set. When index is not specified, the current-item value is replaced.
    
    See Also:
    
    XmlDataCursor.setValue(Object, int...)
  - setValueTag
```
public void setValueTag(XmlDataContentTag key,
                        int... index)
```
    Description copied from interface: XmlDataTreeCursor
    
    The behavior is similar to XmlDataCursor.setValueTag(com.wm.xmldata.XmlDataContentTag, int...) except that an omitted index always accesses the current-item;s value-tag rather than the first and only item's value-tag.
    
    Specified by:
    
    setValueTag in interface XmlDataCursor
    
    Specified by:
    
    setValueTag in interface XmlDataTreeCursor
    
    Parameters:
    
    key - the tag assigned to the current value
    
    index - the offset into the repeating value array
    
    See Also:
    
    XmlDataCursor.setValueTag(XmlDataContentTag, int...)
  - top
```
public void top()
```
    Description copied from interface: XmlDataTreeCursor
    
    Positions the TreeCursor on the top-level and destroys all intervening cursors.
    
    Specified by:
    
    top in interface XmlDataTreeCursor
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class XmlDataTreeCursorImpl

Method Summary

Methods inherited from class java.lang.Object

Method Detail

copyCursor

count

currentIndex

data

deleteItem

deleteBackward

deleteForward

deleteObject

depth

destroy

first

first

firstPartial

firstChild

firstItem

getAnyTag

getAttributeNames

getAttributes

getAttributeValue

getContent

getComplexValueContent

getInstanceProp

getItem

getNamespaceDecl

getNamespaceDecls

getTag

getObject

getValue

getValueCursor

getValueTag

hasAttributes

home

insertItemAfter

insertItemAfter

insertObjectAfter

insertObjectBefore

insertItemBefore

insertItemBefore

insertValueAfter

insertValueAfter

insertValueBefore

insertValueBefore

isAny

isComplexValue

isEmpty

isGroup

isGroupValue

isHome

isRecast

isRepeating

isSimpleValue

isSubstitution

isTop

last

last

lastPartial

lastChild

lastItem

newCursor

next

next

nextPartial

nextInOrder

nextItem

nextItem

nextValueTag

parent

previous

previous

previousPartial

previousInOrder

previousItem

previousItem

previousValueTag

recast

removeAttribute