Uses of Class com.ximpleware.NavException (vtd-xml 2.11 API)

Packages that use NavException
com.ximpleware
com.ximpleware.xpath

Subclasses of NavException in com.ximpleware
`class`	`PilotException` This class is the base class of all the exceptions of autopilot.

Methods in com.ximpleware that throw NavException
`protected boolean`	`AutoPilot.checkNsUniqueness(int i)`
`protected int`	`VTDNav.compareNormalizedTokenString2(int offset, int len, String s)`
`protected int`	`VTDNav.compareRawTokenString(int offset, int len, String s)` Lexicographically compare a string against a token with given offset and len, entities doesn't get resolved.
`int`	`VTDNav.compareRawTokenString(int index, String s)` New in 2.0 Compare the string against the token at the given index value.
`int`	`VTDNav.compareTokens(int i1, VTDNav vn2, int i2)` New in 2.0 This method compares two VTD tokens of VTDNav objects The behavior of this method is like compare the strings corresponds to i1 and i2, meaning for text or attribute val, entities will be converted into the corresponding char, return 0 if two tokens are the identical when converted to Unicode String using toString() respectively
`protected int`	`VTDNav.compareTokenString(int offset, int len, String s)`
`int`	`VTDNav.compareTokenString(int index, String s)` New in 2.0 Compare the string against the token at the given index value.
`int`	`LocationPathExpr.computeContextSize(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Ancestor(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Ancestor2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4AncestorOrSelf(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4AncestorOrSelf2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Child(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Child2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4DDFP(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4DDFP2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4FollowingSibling(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4FollowingSibling2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Parent(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Parent2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4PrecedingSibling(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4PrecedingSibling2(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Self(Predicate p, VTDNav vn)`
`protected int`	`LocationPathExpr.computeContextSize4Self2(Predicate p, VTDNav vn)`
`boolean`	`VTDNav.contains(int index, String s)` Test whether a given token contains s. notie that this function directly operates on the byte content of the token to avoid string creation
`boolean`	`VTDNav.endsWith(int index, String s)` Test the end of token content at index i matches the content of s, notice that this is to save the string allocation cost of using String's built-in endsWidth
`boolean`	`NodeTest.eval(VTDNav vn)`
`boolean`	`NodeTest.eval2(VTDNav vn)`
`int`	`UnionExpr.evalNodeSet(VTDNav vn)`
`int`	`PathExpr.evalNodeSet(VTDNav vn)`
`int`	`LocationPathExpr.evalNodeSet(VTDNav vn)`
`int`	`FunctionalLocationPathExpr.evalNodeSet(VTDNav vn)`
`int`	`FilterExpr.evalNodeSet(VTDNav vn)`
`abstract int`	`Expr.evalNodeSet(VTDNav vn)`
`int`	`CachedExpr.evalNodeSet(VTDNav vn)`
`int`	`AutoPilot.evalXPath()` This method returns the next node in the nodeset it returns -1 if there is no more node Afer finishing evaluating, don't forget to reset the xpath
`void`	`VTDNav.fillXPathString(FastIntBuffer indexBuffer, FastIntBuffer countBuffer)`
`int`	`VTDNav.getAttrVal(String an)` Get the token index of the attribute value given an attribute name.
`int`	`VTDNav.getAttrValNS(String URL, String ln)` Get the token index of the attribute value of given URL and local name.
`long`	`VTDNav.getContentFragment()` Get content fragment returns a long encoding the offset and length of the byte segment of the content of current element, which is the byte segment between the starting tag and ending tag, -1 is returned if the current element is an empty element
`long`	`VTDNav.getElementFragment()` Get the starting offset and length of an element encoded in a long, upper 32 bits is length; lower 32 bits is offset Unit is in byte.
`ElementFragmentNs`	`VTDNav.getElementFragmentNs()` getElementFragmentNS returns a ns aware version of the element fragment encapsulated in an ElementFragment object
`int`	`VTDNav.getNormalizedStringLength(int index)` Get the string length of a token as if it is converted into a normalized UCS string
`protected long`	`VTDNav.getOffsetBeforeTail()`
`String`	`VTDNav.getPrefixString(int i)` Return the prefix of a token as a string if the token is of the type of starting tag, attribute name, if the the prefix doesn't exist, a null string is returned; otherwise a null string is returned
`int`	`VTDNav.getRawStringLength(int index)` Get the string length as if the token is converted into a UCS string (entity not resolved)
`long`	`VTDNav.getSiblingElementFragments(int i)` Return the byte offset and length of up to i sibling fragments.
`int`	`VTDNav.getStringLength(int index)` getStringLength return the string length of a token as if the token is converted into a string (entity resolved for character data and attr val)
`String`	`VTDNav.getXPathStringVal()`
`String`	`VTDNav.getXPathStringVal(short mode)` Return the String value of an Element Node
`protected String`	`VTDNav.getXPathStringVal2(int j, short mode)`
`boolean`	`VTDNav.hasAttr(String an)` Test whether current element has an attribute with the matching name. "*" will match any attribute name, therefore is a test whether there is any attribute at all if namespace is disabled, this function will not distinguish between ns declaration and attribute otherwise, ns tokens are invisible Creation date: (11/16/03 5:50:26 PM)
`boolean`	`VTDNav.hasAttrNS(String URL, String ln)` Test whether the current element has an attribute with matching namespace URL and localname.
`void`	`XMLModifier.insertAfterElement(byte[] b)` This method will first call getCurrentIndex() to get the cursor index value then insert the byte array b after the element
`void`	`XMLModifier.insertAfterElement(byte[] b, int contentOffset, int contentLen)` This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b after the element
`void`	`XMLModifier.insertAfterElement(byte[] b, long l1)` This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`void`	`XMLModifier.insertAfterElement(ElementFragmentNs ef)` Insert a namespace compensated element after cursor element
`void`	`XMLModifier.insertAfterElement(int src_encoding, byte[] b)` Insert a byte array of given encoding into the master document transcoding is done underneath to ensure the correctness of output
`void`	`XMLModifier.insertAfterElement(int src_encoding, byte[] b, int contentOffset, int contentLen)` This method will first call getCurrentIndex() to get the cursor index value then insert the transcoded array of bytes of a segment of the byte array b after the element
`void`	`XMLModifier.insertAfterElement(int src_encoding, byte[] b, long l1)` This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b (transcode into a byte array) after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`void`	`XMLModifier.insertAfterElement(String s)` This method will first call getCurrentIndex() to get the cursor index value then insert the byte value of s after the element
`void`	`XMLModifier.insertAfterElement(VTDNav vn, int contentOffset, int contentLen)` This method will first call getCurrentIndex() to get the cursor index value then insert the transcoded array of bytes of a segment of the byte array b after the element the VTDNav object is the container of the XML document in byte array
`void`	`XMLModifier.insertAfterElement(VTDNav vn, long l1)` This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`void`	`XMLModifier.insertAfterHead(byte[] b)` This method will insert byte array b after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(byte[] b, int offset, int len)` This method will insert a segment of the byte array b after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(byte[] b, long l)` This method will insert a segment of the byte array b after the head of cursor element
`void`	`XMLModifier.insertAfterHead(ElementFragmentNs ef)` This method will insert an ElementFragmentNs instance after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(int src_encoding, byte[] b)` This method will insert the transcoded representation of byte array b after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(int src_encoding, byte[] b, int offset, int length)` This method will insert the transcoded representation of a segment of the byte array b after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(int src_encoding, byte[] b, long l)` This method will insert the transcoded representation of a segment of the byte array b after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(String s)` This method will insert s' byte array representation of the string after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(VTDNav vn, int contentOffset, int contentLen)` This method will insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the head of cursor element,
`void`	`XMLModifier.insertAfterHead(VTDNav vn, long l1)` This method will insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the head of cursor element,
`void`	`XMLModifier.insertBeforeTail(byte[] b)` This method will insert byte array b right before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(byte[] b, int offset, int len)` This method will insert a segment of the byte array before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(byte[] b, long l)` This method will insert a segment of the byte array before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`void`	`XMLModifier.insertBeforeTail(ElementFragmentNs ef)` This method will insert a namespace compensated fragment before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(int src_encoding, byte[] b)` This method will insert the transcoded representation of byte array b right before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(int src_encoding, byte[] b, int offset, int length)` This method will insert the transcoded representation of a segment of byte array b right before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(int src_encoding, byte[] b, long l)` This method will insert the transcoded representation of a segment of the byte array before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`void`	`XMLModifier.insertBeforeTail(String s)` This method will insert byte content of string right before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(VTDNav vn, int contentOffset, int contentLen)` This method will insert a segment of the byte array (contained in vn, and transcode into a byte array) before the tail of cursor element,
`void`	`XMLModifier.insertBeforeTail(VTDNav vn, long l1)` This method will insert a segment of the byte array (contained in vn, and transcode into a byte array) before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset
`protected boolean`	`VTDNav.iterate_following_node()`
`protected boolean`	`VTDNav.iterate_following(String en, boolean special)` This function is called by selectElement_F in autoPilot
`protected boolean`	`VTDNav.iterate_followingNS(String URL, String ln)` This function is called by selectElementNS_F in autoPilot
`protected boolean`	`VTDNav.iterate_preceding_node(int[] a, int endIndex)`
`protected boolean`	`VTDNav.iterate_preceding(String en, int[] a, int endIndex)` This function is called by selectElement_P in autoPilot
`protected boolean`	`VTDNav.iterate_precedingNS(String URL, String ln, int[] a, int endIndex)` This function is called by selectElementNS_P in autoPilot
`boolean`	`AutoPilot.iterate()` Iterate over all the selected element nodes in document order.
`protected boolean`	`VTDNav.iterate(int dp, String en, boolean special)` This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes.
`boolean`	`AutoPilot.iterate2()`
`int`	`AutoPilot.iterateAttr()` This method is meant to be called after calling selectAttr() or selectAttrNs(), it will return the vtd index attribute name or -1 if there is none left
`protected int`	`AutoPilot.iterateAttr2()` This method implements the attribute axis for XPath
`protected int`	`AutoPilot.iterateNameSpace()` This method implements the namespace axis for XPath
`protected boolean`	`VTDNav.iterateNode(int dp)`
`protected boolean`	`VTDNav_L5.iterateNS(int dp, String URL, String ln)` This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes .
`protected boolean`	`VTDNav.iterateNS(int dp, String URL, String ln)` This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes .
`protected int`	`VTDNav.lookupNS()` Test whether the URL is defined in the scope.
`boolean`	`VTDNav.matchElement(String en)` Test if the current element matches the given name.
`boolean`	`VTDNav.matchElementNS(String URL, String ln)` Test whether the current element matches the given namespace URL and localname.
`protected boolean`	`VTDNav.matchNormalizedTokenString2(int index, String s)` Match the string against the token at the given index value.
`boolean`	`VTDNav.matchRawTokenString(int index, String s)` Match the string against the token at the given index value.
`boolean`	`VTDNav.matchTokens(int i1, VTDNav vn2, int i2)` This method matches two VTD tokens of VTDNav objects
`boolean`	`VTDNav.matchTokenString(int index, String s)` Match the string against the token at the given index value.
`double`	`VTDNav.parseDouble(int index)` Convert a vtd token into a double.
`float`	`VTDNav.parseFloat(int index)` Convert a vtd token into a float. we assume token type to be attr val or character data Creation date: (12/8/03 2:28:18 PM)
`int`	`VTDNav.parseInt(int index)` Convert a vtd token into an int.
`protected int`	`VTDNav.parseInt(int index, int radix)` Convert a vtd token into an int, with the given radix. we assume token type to be attr val or character data the first char can be either '+' or '-' Creation date: (12/16/03 1:21:20 PM)
`long`	`VTDNav.parseLong(int index)` Convert a vtd token into a long. we assume token type to be attr val or character data Creation date: (12/8/03 2:32:59 PM)
`protected long`	`VTDNav.parseLong(int index, int radix)` Convert a vtd token into a long, with the given radix. the first char can be either '+' or '-', leading and trailing will be stripped we assume token type to be attr val or character data Creation date: (12/17/03 1:51:06 PM)
`protected int`	`LocationPathExpr.process_ancestor_or_self(VTDNav vn)`
`protected int`	`LocationPathExpr.process_ancestor_or_self2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_ancestor(VTDNav vn)`
`protected int`	`LocationPathExpr.process_ancestor2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_attribute(VTDNav vn)`
`protected int`	`LocationPathExpr.process_child(VTDNav vn)` For processing node tests that are element specific
`protected int`	`LocationPathExpr.process_child2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_DDFP(VTDNav vn)`
`protected int`	`LocationPathExpr.process_DDFP2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_following_sibling(VTDNav vn)`
`protected int`	`LocationPathExpr.process_following_sibling2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_namespace(VTDNav vn)`
`protected int`	`LocationPathExpr.process_parent(VTDNav vn)`
`protected int`	`LocationPathExpr.process_parent2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_preceding_sibling(VTDNav vn)`
`protected int`	`LocationPathExpr.process_preceding_sibling2(VTDNav vn)`
`protected int`	`LocationPathExpr.process_self(VTDNav vn)`
`protected int`	`LocationPathExpr.process_self2(VTDNav vn)`
`void`	`VTDNav_L5.recoverNode(int index)` This method takes a vtd index, and recover its correspondin node position, the index can only be of node type element, document, attribute name, attribute value or character data, or CDATA
`void`	`VTDNav.recoverNode(int index)` This method takes a vtd index, and recover its correspondin node position, the index can only be of node type element, document, attribute name, attribute value or character data, or CDATA
`void`	`XMLModifier.remove()` Removes content from the master XML document It first calls getCurrentIndex() if the result is a starting tag, then the entire element referred to by the starting tag is removed If the result is an attribute name or ns node, then the corresponding attribute name/value pair is removed If the token type is one of text, CDATA or commment, then the entire node, including the starting and ending delimiting text surrounding the content, is removed
`void`	`XMLModifier.remove(long l)` Remove a byte segment from XML.
`boolean`	`VTDNav.startsWith(int index, String s)` Test the start of token content at index i matches the content of s, notice that this is to save the string allocation cost of using String's built-in startsWidth
`boolean`	`VTDNav_L5.toElement(int direction)` A generic navigation method.
`boolean`	`VTDNav.toElement(int direction)` A generic navigation method.
`boolean`	`VTDNav_L5.toElement(int direction, String en)` A generic navigation method.
`boolean`	`VTDNav.toElement(int direction, String en)` A generic navigation method.
`boolean`	`VTDNav_L5.toElementNS(int direction, String URL, String ln)` A generic navigation method with namespace support.
`boolean`	`VTDNav.toElementNS(int direction, String URL, String ln)` A generic navigation method with namespace support.
`protected boolean`	`VTDNav_L5.toNode(int dir)`
`protected boolean`	`VTDNav.toNode(int dir)`
`String`	`VTDNav.toNormalizedString(int index)` This method normalizes a token into a string value of character data and attr val in a way that resembles DOM.
`String`	`VTDNav.toNormalizedString2(int index)` (New since version 2.9) Shallow Normalization follows the rules below to normalize a token into a string #xD#xA gets converted to #xA For a character reference, append the referenced character to the normalized value.
`String`	`VTDNav.toNormalizedXPathString(int j)`
`String`	`VTDNav.toRawString(int index)` Convert a token at the given index to a String, (entities and char references not expanded).
`String`	`VTDNav.toRawString(int os, int len)` Convert a segment of XML bytes a into string, without entity resolution
`protected void`	`VTDNav.toRawString(int os, int len, StringBuffer sb)`
`protected void`	`VTDNav.toRawString(int os, int len, StringBuilder sb)`
`protected void`	`VTDNav.toRawString(StringBuilder sb, int index)`
`String`	`VTDNav.toRawStringLowerCase(int index)` Convert a token at the given index to a String, upper case chars get converted into lower case (entities and char references not expanded).
`protected String`	`VTDNav.toRawStringLowerCase(int os, int len)`
`protected void`	`VTDNav.toRawStringLowerCase(int os, int len, StringBuilder sb)`
`String`	`VTDNav.toRawStringUpperCase(int index)` Convert a token at the given index to a String, lower case chars get converted into upper case (entities and char references not expanded).
`protected String`	`VTDNav.toRawStringUpperCase(int os, int len)`
`protected void`	`VTDNav.toRawStringUpperCase(int os, int len, StringBuilder sb)`
`String`	`VTDNav.toString(int index)` Convert a token at the given index to a String, (entities and char references resolved character data and attr val).
`String`	`VTDNav.toString(int os, int len)` Convert the byte content segment (in terms of offset and length) to String (entities are resolved)
`protected void`	`VTDNav.toString(int os, int len, StringBuilder sb)`
`protected void`	`VTDNav.toString(StringBuilder sb, int index)`
`String`	`VTDNav.toStringLowerCase(int index)` Convert a token at the given index to a String and any upper case character will be converted to lower case, (entities and char references resolved for character data and attr val).
`protected String`	`VTDNav.toStringLowerCase(int os, int len)` Convert the byte content segment (in terms of offset and length) to String, upper case characters are converted to lower case
`protected void`	`VTDNav.toStringLowerCase(int os, int len, StringBuilder sb)`
`protected void`	`VTDNav.toStringLowerCase(StringBuilder sb, int index)`
`String`	`VTDNav.toStringUpperCase(int index)` Convert a token at the given index to a String and any lower case character will be converted to upper case, (entities and char references resolved character data and attr val).
`protected String`	`VTDNav.toStringUpperCase(int os, int len)` Convert the byte content segment (in terms of offset and length) to String, lower case characters are converted to upper case
`protected void`	`VTDNav.toStringUpperCase(int os, int len, StringBuilder sb)`
`protected void`	`VTDNav.toStringUpperCase(StringBuilder sb, int index)`
`protected void`	`LocationPathExpr.transition_child(VTDNav vn)`
`void`	`XMLModifier.updateElementName(String newElementName)` Replace the cursor element's name with a new name
`boolean`	`VTDNav.XPathStringVal_Contains(int j, String s)`
`boolean`	`VTDNav.XPathStringVal_EndsWith(int j, String s)`
`boolean`	`VTDNav.XPathStringVal_StartsWith(int j, String s)`

protected boolean

AutoPilot.checkNsUniqueness(int i)

protected int

VTDNav.compareNormalizedTokenString2(int offset,
                              int len,
                              String s)

protected int

VTDNav.compareRawTokenString(int offset,
                      int len,
                      String s)

Lexicographically compare a string against a token with given offset and len, entities doesn't get resolved.

int

VTDNav.compareRawTokenString(int index,
                      String s)

New in 2.0 Compare the string against the token at the given index value.

int

VTDNav.compareTokens(int i1,
              VTDNav vn2,
              int i2)

New in 2.0 This method compares two VTD tokens of VTDNav objects The behavior of this method is like compare the strings corresponds to i1 and i2, meaning for text or attribute val, entities will be converted into the corresponding char, return 0 if two tokens are the identical when converted to Unicode String using toString() respectively

protected int

VTDNav.compareTokenString(int offset,
                   int len,
                   String s)

int

VTDNav.compareTokenString(int index,
                   String s)

New in 2.0 Compare the string against the token at the given index value.

int

LocationPathExpr.computeContextSize(Predicate p,
                   VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Ancestor(Predicate p,
                            VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Ancestor2(Predicate p,
                             VTDNav vn)

protected int

LocationPathExpr.computeContextSize4AncestorOrSelf(Predicate p,
                                  VTDNav vn)

protected int

LocationPathExpr.computeContextSize4AncestorOrSelf2(Predicate p,
                                   VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Child(Predicate p,
                         VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Child2(Predicate p,
                          VTDNav vn)

protected int

LocationPathExpr.computeContextSize4DDFP(Predicate p,
                        VTDNav vn)

protected int

LocationPathExpr.computeContextSize4DDFP2(Predicate p,
                         VTDNav vn)

protected int

LocationPathExpr.computeContextSize4FollowingSibling(Predicate p,
                                    VTDNav vn)

protected int

LocationPathExpr.computeContextSize4FollowingSibling2(Predicate p,
                                     VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Parent(Predicate p,
                          VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Parent2(Predicate p,
                           VTDNav vn)

protected int

LocationPathExpr.computeContextSize4PrecedingSibling(Predicate p,
                                    VTDNav vn)

protected int

LocationPathExpr.computeContextSize4PrecedingSibling2(Predicate p,
                                     VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Self(Predicate p,
                        VTDNav vn)

protected int

LocationPathExpr.computeContextSize4Self2(Predicate p,
                         VTDNav vn)

boolean

VTDNav.contains(int index,
         String s)

Test whether a given token contains s. notie that this function directly operates on the byte content of the token to avoid string creation

boolean

VTDNav.endsWith(int index,
         String s)

Test the end of token content at index i matches the content of s, notice that this is to save the string allocation cost of using String's built-in endsWidth

boolean

NodeTest.eval(VTDNav vn)

boolean

NodeTest.eval2(VTDNav vn)

int

UnionExpr.evalNodeSet(VTDNav vn)

int

PathExpr.evalNodeSet(VTDNav vn)

int

LocationPathExpr.evalNodeSet(VTDNav vn)

int

FunctionalLocationPathExpr.evalNodeSet(VTDNav vn)

int

FilterExpr.evalNodeSet(VTDNav vn)

abstract int

Expr.evalNodeSet(VTDNav vn)

int

CachedExpr.evalNodeSet(VTDNav vn)

int

AutoPilot.evalXPath()
This method returns the next node in the nodeset it returns -1 if there is no more node Afer finishing evaluating, don't forget to reset the xpath

void

VTDNav.fillXPathString(FastIntBuffer indexBuffer,
                FastIntBuffer countBuffer)

int

VTDNav.getAttrVal(String an)
Get the token index of the attribute value given an attribute name.

int

VTDNav.getAttrValNS(String URL,
             String ln)

Get the token index of the attribute value of given URL and local name.

long

VTDNav.getContentFragment()
Get content fragment returns a long encoding the offset and length of the byte segment of the content of current element, which is the byte segment between the starting tag and ending tag, -1 is returned if the current element is an empty element

long

VTDNav.getElementFragment()
Get the starting offset and length of an element encoded in a long, upper 32 bits is length; lower 32 bits is offset Unit is in byte.

ElementFragmentNs

VTDNav.getElementFragmentNs()
getElementFragmentNS returns a ns aware version of the element fragment encapsulated in an ElementFragment object

int

VTDNav.getNormalizedStringLength(int index)
Get the string length of a token as if it is converted into a normalized UCS string

protected long

VTDNav.getOffsetBeforeTail()

String

VTDNav.getPrefixString(int i)
Return the prefix of a token as a string if the token is of the type of starting tag, attribute name, if the the prefix doesn't exist, a null string is returned; otherwise a null string is returned

int

VTDNav.getRawStringLength(int index)
Get the string length as if the token is converted into a UCS string (entity not resolved)

long

VTDNav.getSiblingElementFragments(int i)
Return the byte offset and length of up to i sibling fragments.

int

VTDNav.getStringLength(int index)
getStringLength return the string length of a token as if the token is converted into a string (entity resolved for character data and attr val)

String

VTDNav.getXPathStringVal()

String

VTDNav.getXPathStringVal(short mode)
Return the String value of an Element Node

protected String

VTDNav.getXPathStringVal2(int j,
                   short mode)

boolean

VTDNav.hasAttr(String an)
Test whether current element has an attribute with the matching name. "*" will match any attribute name, therefore is a test whether there is any attribute at all if namespace is disabled, this function will not distinguish between ns declaration and attribute otherwise, ns tokens are invisible Creation date: (11/16/03 5:50:26 PM)

boolean

VTDNav.hasAttrNS(String URL,
          String ln)

Test whether the current element has an attribute with matching namespace URL and localname.

void

XMLModifier.insertAfterElement(byte[] b)
This method will first call getCurrentIndex() to get the cursor index value then insert the byte array b after the element

void

XMLModifier.insertAfterElement(byte[] b,
                   int contentOffset,
                   int contentLen)

This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b after the element

void

XMLModifier.insertAfterElement(byte[] b,
                   long l1)

This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

void

XMLModifier.insertAfterElement(ElementFragmentNs ef)
Insert a namespace compensated element after cursor element

void

XMLModifier.insertAfterElement(int src_encoding,
                   byte[] b)

Insert a byte array of given encoding into the master document transcoding is done underneath to ensure the correctness of output

void

XMLModifier.insertAfterElement(int src_encoding,
                   byte[] b,
                   int contentOffset,
                   int contentLen)

This method will first call getCurrentIndex() to get the cursor index value then insert the transcoded array of bytes of a segment of the byte array b after the element

void

XMLModifier.insertAfterElement(int src_encoding,
                   byte[] b,
                   long l1)

This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b (transcode into a byte array) after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

void

XMLModifier.insertAfterElement(String s)
This method will first call getCurrentIndex() to get the cursor index value then insert the byte value of s after the element

void

XMLModifier.insertAfterElement(VTDNav vn,
                   int contentOffset,
                   int contentLen)

This method will first call getCurrentIndex() to get the cursor index value then insert the transcoded array of bytes of a segment of the byte array b after the element the VTDNav object is the container of the XML document in byte array

void

XMLModifier.insertAfterElement(VTDNav vn,
                   long l1)

This method will first call getCurrentIndex() to get the cursor index value then insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

void

XMLModifier.insertAfterHead(byte[] b)
This method will insert byte array b after the head of cursor element,

void

XMLModifier.insertAfterHead(byte[] b,
                int offset,
                int len)

This method will insert a segment of the byte array b after the head of cursor element,

void

XMLModifier.insertAfterHead(byte[] b,
                long l)

This method will insert a segment of the byte array b after the head of cursor element

void

XMLModifier.insertAfterHead(ElementFragmentNs ef)
This method will insert an ElementFragmentNs instance after the head of cursor element,

void

XMLModifier.insertAfterHead(int src_encoding,
                byte[] b)

This method will insert the transcoded representation of byte array b after the head of cursor element,

void

XMLModifier.insertAfterHead(int src_encoding,
                byte[] b,
                int offset,
                int length)

This method will insert the transcoded representation of a segment of the byte array b after the head of cursor element,

void

XMLModifier.insertAfterHead(int src_encoding,
                byte[] b,
                long l)

This method will insert the transcoded representation of a segment of the byte array b after the head of cursor element,

void

XMLModifier.insertAfterHead(String s)
This method will insert s' byte array representation of the string after the head of cursor element,

void

XMLModifier.insertAfterHead(VTDNav vn,
                int contentOffset,
                int contentLen)

This method will insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the head of cursor element,

void

XMLModifier.insertAfterHead(VTDNav vn,
                long l1)

This method will insert a segment of the byte array b (contained in vn, and transcode into a byte array) after the head of cursor element,

void

XMLModifier.insertBeforeTail(byte[] b)
This method will insert byte array b right before the tail of cursor element,

void

XMLModifier.insertBeforeTail(byte[] b,
                 int offset,
                 int len)

This method will insert a segment of the byte array before the tail of cursor element,

void

XMLModifier.insertBeforeTail(byte[] b,
                 long l)

This method will insert a segment of the byte array before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

void

XMLModifier.insertBeforeTail(ElementFragmentNs ef)
This method will insert a namespace compensated fragment before the tail of cursor element,

void

XMLModifier.insertBeforeTail(int src_encoding,
                 byte[] b)

This method will insert the transcoded representation of byte array b right before the tail of cursor element,

void

XMLModifier.insertBeforeTail(int src_encoding,
                 byte[] b,
                 int offset,
                 int length)

This method will insert the transcoded representation of a segment of byte array b right before the tail of cursor element,

void

XMLModifier.insertBeforeTail(int src_encoding,
                 byte[] b,
                 long l)

This method will insert the transcoded representation of a segment of the byte array before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

void

XMLModifier.insertBeforeTail(String s)
This method will insert byte content of string right before the tail of cursor element,

void

XMLModifier.insertBeforeTail(VTDNav vn,
                 int contentOffset,
                 int contentLen)

This method will insert a segment of the byte array (contained in vn, and transcode into a byte array) before the tail of cursor element,

void

XMLModifier.insertBeforeTail(VTDNav vn,
                 long l1)

This method will insert a segment of the byte array (contained in vn, and transcode into a byte array) before the tail of cursor element, l1 (a long)'s upper 32 bit is length, lower 32 bit is offset

protected boolean

VTDNav.iterate_following_node()

protected boolean

VTDNav.iterate_following(String en,
                  boolean special)

This function is called by selectElement_F in autoPilot

protected boolean

VTDNav.iterate_followingNS(String URL,
                    String ln)

This function is called by selectElementNS_F in autoPilot

protected boolean

VTDNav.iterate_preceding_node(int[] a,
                       int endIndex)

protected boolean

VTDNav.iterate_preceding(String en,
                  int[] a,
                  int endIndex)

This function is called by selectElement_P in autoPilot

protected boolean

VTDNav.iterate_precedingNS(String URL,
                    String ln,
                    int[] a,
                    int endIndex)

This function is called by selectElementNS_P in autoPilot

boolean

AutoPilot.iterate()
Iterate over all the selected element nodes in document order.

protected boolean

VTDNav.iterate(int dp,
        String en,
        boolean special)

This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes.

boolean

AutoPilot.iterate2()

int

AutoPilot.iterateAttr()
This method is meant to be called after calling selectAttr() or selectAttrNs(), it will return the vtd index attribute name or -1 if there is none left

protected int

AutoPilot.iterateAttr2()
This method implements the attribute axis for XPath

protected int

AutoPilot.iterateNameSpace()
This method implements the namespace axis for XPath

protected boolean

VTDNav.iterateNode(int dp)

protected boolean

VTDNav_L5.iterateNS(int dp,
          String URL,
          String ln)

This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes .

protected boolean

VTDNav.iterateNS(int dp,
          String URL,
          String ln)

This method is similar to getElementByName in DOM except it doesn't return the nodeset, instead it iterates over those nodes .

protected int

VTDNav.lookupNS()
Test whether the URL is defined in the scope.

boolean

VTDNav.matchElement(String en)
Test if the current element matches the given name.

boolean

VTDNav.matchElementNS(String URL,
               String ln)

Test whether the current element matches the given namespace URL and localname.

protected boolean

VTDNav.matchNormalizedTokenString2(int index,
                            String s)

Match the string against the token at the given index value.

boolean

VTDNav.matchRawTokenString(int index,
                    String s)

Match the string against the token at the given index value.

boolean

VTDNav.matchTokens(int i1,
            VTDNav vn2,
            int i2)

This method matches two VTD tokens of VTDNav objects

boolean

VTDNav.matchTokenString(int index,
                 String s)

Match the string against the token at the given index value.

double

VTDNav.parseDouble(int index)
Convert a vtd token into a double.

float

VTDNav.parseFloat(int index)
Convert a vtd token into a float. we assume token type to be attr val or character data Creation date: (12/8/03 2:28:18 PM)

int

VTDNav.parseInt(int index)
Convert a vtd token into an int.

protected int

VTDNav.parseInt(int index,
         int radix)

Convert a vtd token into an int, with the given radix. we assume token type to be attr val or character data the first char can be either '+' or '-' Creation date: (12/16/03 1:21:20 PM)

long

VTDNav.parseLong(int index)
Convert a vtd token into a long. we assume token type to be attr val or character data Creation date: (12/8/03 2:32:59 PM)

protected long

VTDNav.parseLong(int index,
          int radix)

Convert a vtd token into a long, with the given radix. the first char can be either '+' or '-', leading and trailing will be stripped we assume token type to be attr val or character data Creation date: (12/17/03 1:51:06 PM)

protected int

LocationPathExpr.process_ancestor_or_self(VTDNav vn)

protected int

LocationPathExpr.process_ancestor_or_self2(VTDNav vn)

protected int

LocationPathExpr.process_ancestor(VTDNav vn)

protected int

LocationPathExpr.process_ancestor2(VTDNav vn)

protected int

LocationPathExpr.process_attribute(VTDNav vn)

protected int

LocationPathExpr.process_child(VTDNav vn)
For processing node tests that are element specific

protected int

LocationPathExpr.process_child2(VTDNav vn)

protected int

LocationPathExpr.process_DDFP(VTDNav vn)

protected int

LocationPathExpr.process_DDFP2(VTDNav vn)

protected int

LocationPathExpr.process_following_sibling(VTDNav vn)

protected int

LocationPathExpr.process_following_sibling2(VTDNav vn)

protected int

LocationPathExpr.process_namespace(VTDNav vn)

protected int

LocationPathExpr.process_parent(VTDNav vn)

protected int

LocationPathExpr.process_parent2(VTDNav vn)

protected int

LocationPathExpr.process_preceding_sibling(VTDNav vn)

protected int

LocationPathExpr.process_preceding_sibling2(VTDNav vn)

protected int

LocationPathExpr.process_self(VTDNav vn)

protected int

LocationPathExpr.process_self2(VTDNav vn)

void

VTDNav_L5.recoverNode(int index)
This method takes a vtd index, and recover its correspondin node position, the index can only be of node type element, document, attribute name, attribute value or character data, or CDATA

void

VTDNav.recoverNode(int index)
This method takes a vtd index, and recover its correspondin node position, the index can only be of node type element, document, attribute name, attribute value or character data, or CDATA

void

XMLModifier.remove()
Removes content from the master XML document It first calls getCurrentIndex() if the result is a starting tag, then the entire element referred to by the starting tag is removed If the result is an attribute name or ns node, then the corresponding attribute name/value pair is removed If the token type is one of text, CDATA or commment, then the entire node, including the starting and ending delimiting text surrounding the content, is removed

void

XMLModifier.remove(long l)
Remove a byte segment from XML.

boolean

VTDNav.startsWith(int index,
           String s)

Test the start of token content at index i matches the content of s, notice that this is to save the string allocation cost of using String's built-in startsWidth

boolean

VTDNav_L5.toElement(int direction)
A generic navigation method.

boolean

VTDNav.toElement(int direction)
A generic navigation method.

boolean

VTDNav_L5.toElement(int direction,
          String en)

A generic navigation method.

boolean

VTDNav.toElement(int direction,
          String en)

A generic navigation method.

boolean

VTDNav_L5.toElementNS(int direction,
            String URL,
            String ln)

A generic navigation method with namespace support.

boolean

VTDNav.toElementNS(int direction,
            String URL,
            String ln)

A generic navigation method with namespace support.

protected boolean

VTDNav_L5.toNode(int dir)

protected boolean

VTDNav.toNode(int dir)

String

VTDNav.toNormalizedString(int index)
This method normalizes a token into a string value of character data and attr val in a way that resembles DOM.

String

VTDNav.toNormalizedString2(int index)
(New since version 2.9) Shallow Normalization follows the rules below to normalize a token into a string *#xD#xA gets converted to #xA *For a character reference, append the referenced character to the normalized value.

String

VTDNav.toNormalizedXPathString(int j)

String

VTDNav.toRawString(int index)
Convert a token at the given index to a String, (entities and char references not expanded).

String

VTDNav.toRawString(int os,
            int len)

Convert a segment of XML bytes a into string, without entity resolution

protected void

VTDNav.toRawString(int os,
            int len,
            StringBuffer sb)

protected void

VTDNav.toRawString(int os,
            int len,
            StringBuilder sb)

protected void

VTDNav.toRawString(StringBuilder sb,
            int index)

String

VTDNav.toRawStringLowerCase(int index)
Convert a token at the given index to a String, upper case chars get converted into lower case (entities and char references not expanded).

protected String

VTDNav.toRawStringLowerCase(int os,
                     int len)

protected void

VTDNav.toRawStringLowerCase(int os,
                     int len,
                     StringBuilder sb)

String

VTDNav.toRawStringUpperCase(int index)
Convert a token at the given index to a String, lower case chars get converted into upper case (entities and char references not expanded).

protected String

VTDNav.toRawStringUpperCase(int os,
                     int len)

protected void

VTDNav.toRawStringUpperCase(int os,
                     int len,
                     StringBuilder sb)

String

VTDNav.toString(int index)
Convert a token at the given index to a String, (entities and char references resolved character data and attr val).

String

VTDNav.toString(int os,
         int len)

Convert the byte content segment (in terms of offset and length) to String (entities are resolved)

protected void

VTDNav.toString(int os,
         int len,
         StringBuilder sb)

protected void

VTDNav.toString(StringBuilder sb,
         int index)

String

VTDNav.toStringLowerCase(int index)
Convert a token at the given index to a String and any upper case character will be converted to lower case, (entities and char references resolved for character data and attr val).

protected String

VTDNav.toStringLowerCase(int os,
                  int len)

Convert the byte content segment (in terms of offset and length) to String, upper case characters are converted to lower case

protected void

VTDNav.toStringLowerCase(int os,
                  int len,
                  StringBuilder sb)

protected void

VTDNav.toStringLowerCase(StringBuilder sb,
                  int index)

String

VTDNav.toStringUpperCase(int index)
Convert a token at the given index to a String and any lower case character will be converted to upper case, (entities and char references resolved character data and attr val).

protected String

VTDNav.toStringUpperCase(int os,
                  int len)

Convert the byte content segment (in terms of offset and length) to String, lower case characters are converted to upper case

protected void

VTDNav.toStringUpperCase(int os,
                  int len,
                  StringBuilder sb)

protected void

VTDNav.toStringUpperCase(StringBuilder sb,
                  int index)

protected void

LocationPathExpr.transition_child(VTDNav vn)

void

XMLModifier.updateElementName(String newElementName)
Replace the cursor element's name with a new name

boolean

VTDNav.XPathStringVal_Contains(int j,
                        String s)

boolean

VTDNav.XPathStringVal_EndsWith(int j,
                        String s)

boolean

VTDNav.XPathStringVal_StartsWith(int j,
                          String s)

Methods in com.ximpleware.xpath that throw NavException
`boolean`	`Step.eval(VTDNav vn)`
`boolean`	`LocationPathNode.eval(VTDNav vn)`
`boolean`	`Step.eval(VTDNav vn, Predicate p)`
`boolean`	`Step.eval2(VTDNav vn)`
`boolean`	`Step.eval2(VTDNav vn, Predicate p)`
`int`	`VariableExpr.evalNodeSet(VTDNav vn)`
`boolean`	`Step.evalPredicates(VTDNav vn)`
`boolean`	`Step.evalPredicates(VTDNav vn, Predicate p)`

Uses of Classcom.ximpleware.NavException

Uses of Class
com.ximpleware.NavException