/**
* Get the value of a node as a string.
*
* @param n Node to be converted to a string. May be null.
* @return value of n as a string, or an empty string if n is null.
*/
public String toString(org.w3c.dom.Node n) {
// %REVIEW% You can't get much uglier than this...
int nodeHandle = getDTMHandleFromNode(n);
DTM dtm = getDTM(nodeHandle);
XMLString strVal = dtm.getStringValue(nodeHandle);
return strVal.toString();
}
/**
* Compares this string to the specified object. The result is <code>true</code> if and only if
* the argument is not <code>null</code> and is a <code>String</code> object that represents the
* same sequence of characters as this object.
*
* @param obj2 the object to compare this <code>String</code> against.
* @return <code>true</code> if the <code>String </code>are equal; <code>false</code> otherwise.
* @see java.lang.String#compareTo(java.lang.String)
* @see java.lang.String#equalsIgnoreCase(java.lang.String)
*/
public boolean equals(XMLString obj2) {
if (obj2 != null) {
if (!obj2.hasString()) {
return obj2.equals(str());
} else {
return str().equals(obj2.toString());
}
}
return false;
}
/**
* Execute the first argument expression that is expected to return a number. If the argument is
* null, then get the number value from the current context node.
*
* @param xctxt Runtime XPath context.
* @return The number value of the first argument, or the number value of the current context node
* if the first argument is null.
* @throws javax.xml.transform.TransformerException if an error occurs while executing the
* argument expression.
*/
protected double getArg0AsNumber(XPathContext xctxt)
throws javax.xml.transform.TransformerException {
if (null == m_arg0) {
int currentNode = xctxt.getCurrentNode();
if (DTM.NULL == currentNode) return 0;
else {
DTM dtm = xctxt.getDTM(currentNode);
XMLString str = dtm.getStringValue(currentNode);
return str.toDouble();
}
} else return m_arg0.execute(xctxt).num();
}
/**
* Compares two strings lexicographically.
*
* @param xstr the <code>String</code> to be compared.
* @return the value <code>0</code> if the argument string is equal to this string; a value less
* than <code>0</code> if this string is lexicographically less than the string argument; and
* a value greater than <code>0</code> if this string is lexicographically greater than the
* string argument.
* @exception java.lang.NullPointerException if <code>anotherString</code> is <code>null</code>.
*/
public int compareTo(XMLString xstr) {
int len1 = this.length();
int len2 = xstr.length();
int n = Math.min(len1, len2);
int i = 0;
int j = 0;
while (n-- != 0) {
char c1 = this.charAt(i);
char c2 = xstr.charAt(j);
if (c1 != c2) {
return c1 - c2;
}
i++;
j++;
}
return len1 - len2;
}
/**
* Tests if this string starts with the specified prefix beginning a specified index.
*
* @param prefix the prefix.
* @param toffset where to begin looking in the string.
* @return <code>true</code> if the character sequence represented by the argument is a prefix of
* the substring of this object starting at index <code>toffset</code>; <code>false</code>
* otherwise. The result is <code>false</code> if <code>toffset</code> is negative or greater
* than the length of this <code>String</code> object; otherwise the result is the same as the
* result of the expression
* <pre>
* this.subString(toffset).startsWith(prefix)
* </pre>
*
* @exception java.lang.NullPointerException if <code>prefix</code> is <code>null</code>.
*/
public boolean startsWith(XMLString prefix, int toffset) {
int to = toffset;
int tlim = this.length();
int po = 0;
int pc = prefix.length();
// Note: toffset might be near -1>>>1.
if ((toffset < 0) || (toffset > tlim - pc)) {
return false;
}
while (--pc >= 0) {
if (this.charAt(to) != prefix.charAt(po)) {
return false;
}
to++;
po++;
}
return true;
}
/**
* Convert a string to a double -- Allowed input is in fixed notation ddd.fff.
*
* @return A double value representation of the string, or return Double.NaN if the string can not
* be converted.
*/
public double toDouble() {
/* XMLCharacterRecognizer.isWhiteSpace(char c) methods treats the following
* characters as white space characters.
* ht - horizontal tab, nl - newline , cr - carriage return and sp - space
* trim() methods by default also takes care of these white space characters
* So trim() method is used to remove leading and trailing white spaces.
*/
XMLString s = trim();
double result = Double.NaN;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c != '-' && c != '.' && (c < 0X30 || c > 0x39)) {
// The character is not a '-' or a '.' or a digit
// then return NaN because something is wrong.
return result;
}
}
try {
result = Double.parseDouble(s.toString());
} catch (NumberFormatException e) {
}
return result;
}
/**
* Returns the index within this string of the first occurrence of the specified substring. The
* integer returned is the smallest value <i>k</i> such that:
*
* <blockquote>
*
* <pre>
* this.startsWith(str, <i>k</i>)
* </pre>
*
* </blockquote>
*
* is <code>true</code>.
*
* @param str any string.
* @return if the string argument occurs as a substring within this object, then the index of the
* first character of the first such substring is returned; if it does not occur as a
* substring, <code>-1</code> is returned.
* @exception java.lang.NullPointerException if <code>str</code> is <code>null</code>.
*/
public int indexOf(XMLString str) {
return str().indexOf(str.toString());
}
