| Methods Summary |
|---|
| public void | appendToFsb(com.sun.org.apache.xml.internal.utils.FastStringBuffer fsb)Cast result object to a string.
// %OPT% !!! FSB has to be updated to take partial fsb's for append.
fsb.append(str());
|
| public char | charAt(int index)Returns the character at the specified index. An index ranges
from 0 to length() - 1. The first character
of the sequence is at index 0, the next at index
1, and so on, as for array indexing.
return fsb().charAt(m_start + index);
|
| public int | compareTo(com.sun.org.apache.xml.internal.utils.XMLString xstr)Compares two strings lexicographically.
int len1 = m_length;
int len2 = xstr.length();
int n = Math.min(len1, len2);
FastStringBuffer fsb = fsb();
int i = m_start;
int j = 0;
while (n-- != 0)
{
char c1 = fsb.charAt(i);
char c2 = xstr.charAt(j);
if (c1 != c2)
{
return c1 - c2;
}
i++;
j++;
}
return len1 - len2;
|
| public int | compareToIgnoreCase(com.sun.org.apache.xml.internal.utils.XMLString xstr)Compares two strings lexicographically, ignoring case considerations.
This method returns an integer whose sign is that of
this.toUpperCase().toLowerCase().compareTo(
str.toUpperCase().toLowerCase()).
Note that this method does not take locale into account,
and will result in an unsatisfactory ordering for certain locales.
The java.text package provides collators to allow
locale-sensitive ordering.
int len1 = m_length;
int len2 = xstr.length();
int n = Math.min(len1, len2);
FastStringBuffer fsb = fsb();
int i = m_start;
int j = 0;
while (n-- != 0)
{
char c1 = Character.toLowerCase(fsb.charAt(i));
char c2 = Character.toLowerCase(xstr.charAt(j));
if (c1 != c2)
{
return c1 - c2;
}
i++;
j++;
}
return len1 - len2;
|
| public com.sun.org.apache.xml.internal.utils.XMLString | concat(java.lang.String str)Concatenates the specified string to the end of this string.
// %OPT% Make an FSB here?
return new XString(str().concat(str));
|
| public void | dispatchAsComment(org.xml.sax.ext.LexicalHandler lh)Directly call the
comment method on the passed LexicalHandler for the
string-value.
fsb().sendSAXComment(lh, m_start, m_length);
|
| public void | dispatchCharactersEvents(org.xml.sax.ContentHandler ch)Directly call the
characters method on the passed ContentHandler for the
string-value. Multiple calls to the
ContentHandler's characters methods may well occur for a single call to
this method.
fsb().sendSAXcharacters(ch, m_start, m_length);
|
| public boolean | equals(com.sun.org.apache.xml.internal.utils.XMLString obj2)Compares this string to the specified object.
The result is true if and only if the argument is not
null and is a String object that represents
the same sequence of characters as this object.
if (this == obj2)
{
return true;
}
int n = m_length;
if (n == obj2.length())
{
FastStringBuffer fsb = fsb();
int i = m_start;
int j = 0;
while (n-- != 0)
{
if (fsb.charAt(i) != obj2.charAt(j))
{
return false;
}
i++;
j++;
}
return true;
}
return false;
|
| public boolean | equals(com.sun.org.apache.xpath.internal.objects.XObject obj2)Tell if two objects are functionally equal.
if (this == obj2)
{
return true;
}
if(obj2.getType() == XObject.CLASS_NUMBER)
return obj2.equals(this);
String str = obj2.str();
int n = m_length;
if (n == str.length())
{
FastStringBuffer fsb = fsb();
int i = m_start;
int j = 0;
while (n-- != 0)
{
if (fsb.charAt(i) != str.charAt(j))
{
return false;
}
i++;
j++;
}
return true;
}
return false;
|
| public boolean | equals(java.lang.String anotherString)Tell if two objects are functionally equal.
int n = m_length;
if (n == anotherString.length())
{
FastStringBuffer fsb = fsb();
int i = m_start;
int j = 0;
while (n-- != 0)
{
if (fsb.charAt(i) != anotherString.charAt(j))
{
return false;
}
i++;
j++;
}
return true;
}
return false;
|
| public boolean | equals(java.lang.Object obj2)Compares this string to the specified object.
The result is true if and only if the argument is not
null and is a String object that represents
the same sequence of characters as this object.
if (null == obj2)
return false;
if(obj2 instanceof XNumber)
return obj2.equals(this);
// In order to handle the 'all' semantics of
// nodeset comparisons, we always call the
// nodeset function.
else if (obj2 instanceof XNodeSet)
return obj2.equals(this);
else if (obj2 instanceof XStringForFSB)
return equals((XMLString) this);
else
return equals(obj2.toString());
|
| public boolean | equalsIgnoreCase(java.lang.String anotherString)Compares this String to another String,
ignoring case considerations. Two strings are considered equal
ignoring case if they are of the same length, and corresponding
characters in the two strings are equal ignoring case.
return (m_length == anotherString.length())
? str().equalsIgnoreCase(anotherString) : false;
|
| public com.sun.org.apache.xml.internal.utils.XMLString | fixWhiteSpace(boolean trimHead, boolean trimTail, boolean doublePunctuationSpaces)Conditionally trim all leading and trailing whitespace in the specified String.
All strings of white space are
replaced by a single space character (#x20), except spaces after punctuation which
receive double spaces if doublePunctuationSpaces is true.
This function may be useful to a formatter, but to get first class
results, the formatter should probably do it's own white space handling
based on the semantics of the formatting object.
int end = m_length + m_start;
char[] buf = new char[m_length];
FastStringBuffer fsb = fsb();
boolean edit = false;
/* replace S to ' '. and ' '+ -> single ' '. */
int d = 0;
boolean pres = false;
for (int s = m_start; s < end; s++)
{
char c = fsb.charAt(s);
if (isSpace(c))
{
if (!pres)
{
if (' " != c)
{
edit = true;
}
buf[d++] = ' ";
if (doublePunctuationSpaces && (d != 0))
{
char prevChar = buf[d - 1];
if (!((prevChar == '.") || (prevChar == '!")
|| (prevChar == '?")))
{
pres = true;
}
}
else
{
pres = true;
}
}
else
{
edit = true;
pres = true;
}
}
else
{
buf[d++] = c;
pres = false;
}
}
if (trimTail && 1 <= d && ' " == buf[d - 1])
{
edit = true;
d--;
}
int start = 0;
if (trimHead && 0 < d && ' " == buf[0])
{
edit = true;
start++;
}
XMLStringFactory xsf = XMLStringFactoryImpl.getFactory();
return edit ? xsf.newstr(buf, start, d - start) : this;
|
| public com.sun.org.apache.xml.internal.utils.FastStringBuffer | fsb()Cast result object to a string.
return ((FastStringBuffer) m_obj);
|
| public void | getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)Copies characters from this string into the destination character
array.
// %OPT% Need to call this on FSB when it is implemented.
// %UNTESTED% (I don't think anyone calls this yet?)
int n = srcEnd - srcBegin;
if (n > m_length)
n = m_length;
if (n > (dst.length - dstBegin))
n = (dst.length - dstBegin);
int end = srcBegin + m_start + n;
int d = dstBegin;
FastStringBuffer fsb = fsb();
for (int i = srcBegin + m_start; i < end; i++)
{
dst[d++] = fsb.charAt(i);
}
|
| public boolean | hasString()Tell if this object contains a java String object.
return (null != m_strCache);
|
| public int | hashCode()Returns a hashcode for this string. The hashcode for a
String object is computed as
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
using int arithmetic, where s[i] is the
ith character of the string, n is the length of
the string, and ^ indicates exponentiation.
(The hash value of the empty string is zero.)
// Commenting this out because in JDK1.1.8 and VJ++
// we don't match XMLStrings. Defaulting to the super
// causes us to create a string, but at this point
// this only seems to get called in key processing.
// Maybe we can live with it?
/*
int h = m_hash;
if (h == 0)
{
int off = m_start;
int len = m_length;
FastStringBuffer fsb = fsb();
for (int i = 0; i < len; i++)
{
h = 31 * h + fsb.charAt(off);
off++;
}
m_hash = h;
}
*/
return super.hashCode(); // h;
|
| public int | indexOf(int ch)Returns the index within this string of the first occurrence of the
specified character. If a character with value ch occurs
in the character sequence represented by this String
object, then the index of the first such occurrence is returned --
that is, the smallest value k such that:
this.charAt(k) == ch
is true. If no such character occurs in this string,
then -1 is returned.
return indexOf(ch, 0);
|
| public int | indexOf(int ch, int fromIndex)Returns the index within this string of the first occurrence of the
specified character, starting the search at the specified index.
If a character with value ch occurs in the character
sequence represented by this String object at an index
no smaller than fromIndex, then the index of the first
such occurrence is returned--that is, the smallest value k
such that:
(this.charAt(k) == ch) && (k >= fromIndex)
is true. If no such character occurs in this string at or after
position fromIndex, then -1 is returned.
There is no restriction on the value of fromIndex. If it
is negative, it has the same effect as if it were zero: this entire
string may be searched. If it is greater than the length of this
string, it has the same effect as if it were equal to the length of
this string: -1 is returned.
int max = m_start + m_length;
FastStringBuffer fsb = fsb();
if (fromIndex < 0)
{
fromIndex = 0;
}
else if (fromIndex >= m_length)
{
// Note: fromIndex might be near -1>>>1.
return -1;
}
for (int i = m_start + fromIndex; i < max; i++)
{
if (fsb.charAt(i) == ch)
{
return i - m_start;
}
}
return -1;
|
| private static boolean | isSpace(char ch)Returns whether the specified ch conforms to the XML 1.0 definition
of whitespace. Refer to
the definition of S for details.
return XMLCharacterRecognizer.isWhiteSpace(ch); // Take the easy way out for now.
|
| public int | length()Returns the length of this string.
return m_length;
|
| public java.lang.Object | object()Since this object is incomplete without the length and the offset, we
have to convert to a string when this function is called.
return str();
|
| public boolean | startsWith(com.sun.org.apache.xml.internal.utils.XMLString prefix, int toffset)Tests if this string starts with the specified prefix beginning
a specified index.
FastStringBuffer fsb = fsb();
int to = m_start + toffset;
int tlim = m_start + m_length;
int po = 0;
int pc = prefix.length();
// Note: toffset might be near -1>>>1.
if ((toffset < 0) || (toffset > m_length - pc))
{
return false;
}
while (--pc >= 0)
{
if (fsb.charAt(to) != prefix.charAt(po))
{
return false;
}
to++;
po++;
}
return true;
|
| public boolean | startsWith(com.sun.org.apache.xml.internal.utils.XMLString prefix)Tests if this string starts with the specified prefix.
return startsWith(prefix, 0);
|
| public java.lang.String | str()Cast result object to a string.
if (null == m_strCache)
{
m_strCache = fsb().getString(m_start, m_length);
// strCount++;
//
// RuntimeException e = new RuntimeException("Bad! Bad!");
// java.io.CharArrayWriter writer = new java.io.CharArrayWriter();
// java.io.PrintWriter pw = new java.io.PrintWriter(writer);
//
// e.printStackTrace(pw);
//
// String str = writer.toString();
//
// str = str.substring(0, 600);
//
// if (null == xtable.get(str))
// {
// xtable.put(str, str);
// System.out.println(str);
// }
// System.out.println("strCount: " + strCount);
// throw e;
// e.printStackTrace();
// System.exit(-1);
}
return m_strCache;
|
| public com.sun.org.apache.xml.internal.utils.XMLString | substring(int beginIndex)Returns a new string that is a substring of this string. The
substring begins with the character at the specified index and
extends to the end of this string.
Examples:
"unhappy".substring(2) returns "happy"
"Harbison".substring(3) returns "bison"
"emptiness".substring(9) returns "" (an empty string)
int len = m_length - beginIndex;
if (len <= 0)
return XString.EMPTYSTRING;
else
{
int start = m_start + beginIndex;
return new XStringForFSB(fsb(), start, len);
}
|
| public com.sun.org.apache.xml.internal.utils.XMLString | substring(int beginIndex, int endIndex)Returns a new string that is a substring of this string. The
substring begins at the specified beginIndex and
extends to the character at index endIndex - 1.
Thus the length of the substring is endIndex-beginIndex.
int len = endIndex - beginIndex;
if (len > m_length)
len = m_length;
if (len <= 0)
return XString.EMPTYSTRING;
else
{
int start = m_start + beginIndex;
return new XStringForFSB(fsb(), start, len);
}
|
| public double | toDouble()Convert a string to a double -- Allowed input is in fixed
notation ddd.fff.
%OPT% CHECK PERFORMANCE against generating a Java String and
converting it to double. The advantage of running in native
machine code -- perhaps even microcode, on some systems -- may
more than make up for the cost of allocating and discarding the
additional object. We need to benchmark this.
%OPT% More importantly, we need to decide whether we _care_ about
the performance of this operation. Does XString.toDouble constitute
any measurable percentage of our typical runtime? I suspect not!
if(m_length == 0)
return Double.NaN;
int i;
char c;
String valueString = fsb().getString(m_start,m_length);
// The following are permitted in the Double.valueOf, but not by the XPath spec:
// - a plus sign
// - The use of e or E to indicate exponents
// - trailing f, F, d, or D
// See function comments; not sure if this is slower than actually doing the
// conversion ourselves (as was before).
for (i=0;i<m_length;i++)
if (!XMLCharacterRecognizer.isWhiteSpace(valueString.charAt(i)))
break;
if (valueString.charAt(i) == '-")
i++;
for (;i<m_length;i++) {
c = valueString.charAt(i);
if (c != '." && (c < '0" || c > '9"))
break;
}
for (;i<m_length;i++)
if (!XMLCharacterRecognizer.isWhiteSpace(valueString.charAt(i)))
break;
if (i != m_length)
return Double.NaN;
try {
return new Double(valueString).doubleValue();
} catch (NumberFormatException nfe) {
// This should catch double periods, empty strings.
return Double.NaN;
}
|
| public com.sun.org.apache.xml.internal.utils.XMLString | trim()Removes white space from both ends of this string.
return fixWhiteSpace(true, true, false);
|
