XMLStringDefault


1   /*
2    * Copyright 1999-2004 The Apache Software Foundation.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  /*
17   * $Id: XMLStringDefault.java,v 1.3 2004/02/17 04:21:14 minchau Exp $
18   */
19  package org.apache.xml.utils;
20  
21  import java.util.Locale  ;
22  
23  /**
24   * The default implementation of the XMLString interface,
25   * which is just a simple wrapper of a String object.
26   */
27  public class XMLStringDefault implements XMLString
28  {
29  
30    private String   m_str;
31    
32    /**
33     * Create a XMLStringDefault object from a String
34     */
35    public XMLStringDefault(String   str)
36    {
37      m_str = str;
38    }
39    
40    /**
41     * Directly call the
42     * characters method on the passed ContentHandler for the
43     * string-value. Multiple calls to the
44     * ContentHandler's characters methods may well occur for a single call to
45     * this method.
46     *
47     * @param ch A non-null reference to a ContentHandler.
48     *
49     * @throws org.xml.sax.SAXException
50     */
51    public void dispatchCharactersEvents(org.xml.sax.ContentHandler   ch)
52      throws org.xml.sax.SAXException  
53    {
54    }
55  
56    /**
57     * Directly call the
58     * comment method on the passed LexicalHandler for the
59     * string-value.
60     *
61     * @param lh A non-null reference to a LexicalHandler.
62     *
63     * @throws org.xml.sax.SAXException
64     */
65    public void dispatchAsComment(org.xml.sax.ext.LexicalHandler   lh)
66      throws org.xml.sax.SAXException  
67    {
68    }
69      
70    /**
71     * Conditionally trim all leading and trailing whitespace in the specified String.
72     * All strings of white space are
73     * replaced by a single space character (#x20), except spaces after punctuation which
74     * receive double spaces if doublePunctuationSpaces is true.
75     * This function may be useful to a formatter, but to get first class
76     * results, the formatter should probably do it's own white space handling
77     * based on the semantics of the formatting object.
78     * 
79     * @param   trimHead    Trim leading whitespace?
80     * @param   trimTail    Trim trailing whitespace?
81     * @param   doublePunctuationSpaces    Use double spaces for punctuation?
82     * @return              The trimmed string.
83     */
84    public XMLString fixWhiteSpace(boolean trimHead,
85                                   boolean trimTail,
86                                   boolean doublePunctuationSpaces)
87    {
88      return new XMLStringDefault(m_str.trim());
89    }
90  
91    /**
92     * Returns the length of this string.
93     *
94     * @return  the length of the sequence of characters represented by this
95     *          object.
96     */
97    public int length()
98    {
99      return m_str.length();
100   }
101 
102   /**
103    * Returns the character at the specified index. An index ranges
104    * from <code>0</code> to <code>length() - 1</code>. The first character
105    * of the sequence is at index <code>0</code>, the next at index
106    * <code>1</code>, and so on, as for array indexing.
107    *
108    * @param      index   the index of the character.
109    * @return     the character at the specified index of this string.
110    *             The first character is at index <code>0</code>.
111    * @exception  IndexOutOfBoundsException  if the <code>index</code>
112    *             argument is negative or not less than the length of this
113    *             string.
114    */
115   public char charAt(int index)
116   {
117     return m_str.charAt(index);
118   }
119 
120   /**
121    * Copies characters from this string into the destination character
122    * array.
123    *
124    * @param      srcBegin   index of the first character in the string
125    *                        to copy.
126    * @param      srcEnd     index after the last character in the string
127    *                        to copy.
128    * @param      dst        the destination array.
129    * @param      dstBegin   the start offset in the destination array.
130    * @exception IndexOutOfBoundsException If any of the following
131    *            is true:
132    *            <ul><li><code>srcBegin</code> is negative.
133    *            <li><code>srcBegin</code> is greater than <code>srcEnd</code>
134    *            <li><code>srcEnd</code> is greater than the length of this
135    *                string
136    *            <li><code>dstBegin</code> is negative
137    *            <li><code>dstBegin+(srcEnd-srcBegin)</code> is larger than
138    *                <code>dst.length</code></ul>
139    * @exception NullPointerException if <code>dst</code> is <code>null</code>
140    */
141   public void getChars(int srcBegin, int srcEnd, char dst[],
142                                 int dstBegin)
143   {
144     int destIndex = dstBegin;
145     for (int i = srcBegin; i < srcEnd; i++)
146     {
147       dst[destIndex++] = m_str.charAt(i);
148     }
149   }
150                                 
151   /**
152    * Compares this string to the specified object.
153    * The result is <code>true</code> if and only if the argument is not
154    * <code>null</code> and is a <code>String</code> object that represents
155    * the same sequence of characters as this object.
156    *
157    * @param   anObject   the object to compare this <code>String</code>
158    *                     against.
159    * @return  <code>true</code> if the <code>String </code>are equal;
160    *          <code>false</code> otherwise.
161    * @see     java.lang.String#compareTo(java.lang.String)
162    * @see     java.lang.String#equalsIgnoreCase(java.lang.String)
163    */
164   public boolean equals(XMLString anObject)
165   {
166     return m_str.equals(anObject.toString());
167   }
168 
169 
170   /**
171    * Compares this string to the specified object.
172    * The result is <code>true</code> if and only if the argument is not
173    * <code>null</code> and is a <code>String</code> object that represents
174    * the same sequence of characters as this object.
175    *
176    * @param   anObject   the object to compare this <code>String</code>
177    *                     against.
178    * @return  <code>true</code> if the <code>String </code>are equal;
179    *          <code>false</code> otherwise.
180    * @see     java.lang.String#compareTo(java.lang.String)
181    * @see     java.lang.String#equalsIgnoreCase(java.lang.String)
182    */
183   public boolean equals(Object   anObject)
184   {
185     return m_str.equals(anObject);
186   }
187 
188   /**
189    * Compares this <code>String</code> to another <code>String</code>,
190    * ignoring case considerations.  Two strings are considered equal
191    * ignoring case if they are of the same length, and corresponding
192    * characters in the two strings are equal ignoring case.
193    *
194    * @param   anotherString   the <code>String</code> to compare this
195    *                          <code>String</code> against.
196    * @return  <code>true</code> if the argument is not <code>null</code>
197    *          and the <code>String</code>s are equal,
198    *          ignoring case; <code>false</code> otherwise.
199    * @see     #equals(Object)
200    * @see     java.lang.Character#toLowerCase(char)
201    * @see java.lang.Character#toUpperCase(char)
202    */
203   public boolean equalsIgnoreCase(String   anotherString)
204   {
205     return m_str.equalsIgnoreCase(anotherString);
206   }
207 
208   /**
209    * Compares two strings lexicographically.
210    *
211    * @param   anotherString   the <code>String</code> to be compared.
212    * @return  the value <code>0</code> if the argument string is equal to
213    *          this string; a value less than <code>0</code> if this string
214    *          is lexicographically less than the string argument; and a
215    *          value greater than <code>0</code> if this string is
216    *          lexicographically greater than the string argument.
217    * @exception java.lang.NullPointerException if <code>anotherString</code>
218    *          is <code>null</code>.
219    */
220   public int compareTo(XMLString anotherString)
221   {
222     return m_str.compareTo(anotherString.toString());
223   }
224 
225   /**
226    * Compares two strings lexicographically, ignoring case considerations.
227    * This method returns an integer whose sign is that of
228    * <code>this.toUpperCase().toLowerCase().compareTo(
229    * str.toUpperCase().toLowerCase())</code>.
230    * <p>
231    * Note that this method does <em>not</em> take locale into account,
232    * and will result in an unsatisfactory ordering for certain locales.
233    * The java.text package provides <em>collators</em> to allow
234    * locale-sensitive ordering.
235    *
236    * @param   str   the <code>String</code> to be compared.
237    * @return  a negative integer, zero, or a positive integer as the
238    *          the specified String is greater than, equal to, or less
239    *          than this String, ignoring case considerations.
240    * @see     java.text.Collator#compare(String, String)
241    * @since   1.2
242    */
243   public int compareToIgnoreCase(XMLString str)
244   {
245     return m_str.compareToIgnoreCase(str.toString());
246   }
247 
248   /**
249    * Tests if this string starts with the specified prefix beginning
250    * a specified index.
251    *
252    * @param   prefix    the prefix.
253    * @param   toffset   where to begin looking in the string.
254    * @return  <code>true</code> if the character sequence represented by the
255    *          argument is a prefix of the substring of this object starting
256    *          at index <code>toffset</code>; <code>false</code> otherwise.
257    *          The result is <code>false</code> if <code>toffset</code> is
258    *          negative or greater than the length of this
259    *          <code>String</code> object; otherwise the result is the same
260    *          as the result of the expression
261    *          <pre>
262    *          this.subString(toffset).startsWith(prefix)
263    *          </pre>
264    * @exception java.lang.NullPointerException if <code>prefix</code> is
265    *          <code>null</code>.
266    */
267   public boolean startsWith(String   prefix, int toffset)
268   {
269     return m_str.startsWith(prefix, toffset);
270   }
271 
272   /**
273    * Tests if this string starts with the specified prefix beginning
274    * a specified index.
275    *
276    * @param   prefix    the prefix.
277    * @param   toffset   where to begin looking in the string.
278    * @return  <code>true</code> if the character sequence represented by the
279    *          argument is a prefix of the substring of this object starting
280    *          at index <code>toffset</code>; <code>false</code> otherwise.
281    *          The result is <code>false</code> if <code>toffset</code> is
282    *          negative or greater than the length of this
283    *          <code>String</code> object; otherwise the result is the same
284    *          as the result of the expression
285    *          <pre>
286    *          this.subString(toffset).startsWith(prefix)
287    *          </pre>
288    * @exception java.lang.NullPointerException if <code>prefix</code> is
289    *          <code>null</code>.
290    */
291   public boolean startsWith(XMLString prefix, int toffset)
292   {
293     return m_str.startsWith(prefix.toString(), toffset);
294   }
295 
296   /**
297    * Tests if this string starts with the specified prefix.
298    *
299    * @param   prefix   the prefix.
300    * @return  <code>true</code> if the character sequence represented by the
301    *          argument is a prefix of the character sequence represented by
302    *          this string; <code>false</code> otherwise.
303    *          Note also that <code>true</code> will be returned if the
304    *          argument is an empty string or is equal to this
305    *          <code>String</code> object as determined by the
306    *          {@link #equals(Object)} method.
307    * @exception java.lang.NullPointerException if <code>prefix</code> is
308    *          <code>null</code>.
309    * @since   JDK1. 0
310    */
311   public boolean startsWith(String   prefix)
312   {
313     return m_str.startsWith(prefix);
314   }
315 
316   /**
317    * Tests if this string starts with the specified prefix.
318    *
319    * @param   prefix   the prefix.
320    * @return  <code>true</code> if the character sequence represented by the
321    *          argument is a prefix of the character sequence represented by
322    *          this string; <code>false</code> otherwise.
323    *          Note also that <code>true</code> will be returned if the
324    *          argument is an empty string or is equal to this
325    *          <code>String</code> object as determined by the
326    *          {@link #equals(Object)} method.
327    * @exception java.lang.NullPointerException if <code>prefix</code> is
328    *          <code>null</code>.
329    * @since   JDK1. 0
330    */
331   public boolean startsWith(XMLString prefix)
332   {
333     return m_str.startsWith(prefix.toString());
334   }
335 
336   /**
337    * Tests if this string ends with the specified suffix.
338    *
339    * @param   suffix   the suffix.
340    * @return  <code>true</code> if the character sequence represented by the
341    *          argument is a suffix of the character sequence represented by
342    *          this object; <code>false</code> otherwise. Note that the
343    *          result will be <code>true</code> if the argument is the
344    *          empty string or is equal to this <code>String</code> object
345    *          as determined by the {@link #equals(Object)} method.
346    * @exception java.lang.NullPointerException if <code>suffix</code> is
347    *          <code>null</code>.
348    */
349   public boolean endsWith(String   suffix)
350   {
351     return m_str.endsWith(suffix);
352   }
353 
354   /**
355    * Returns a hashcode for this string. The hashcode for a
356    * <code>String</code> object is computed as
357    * <blockquote><pre>
358    * s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
359    * </pre></blockquote>
360    * using <code>int</code> arithmetic, where <code>s[i]</code> is the
361    * <i>i</i>th character of the string, <code>n</code> is the length of
362    * the string, and <code>^</code> indicates exponentiation.
363    * (The hash value of the empty string is zero.)
364    *
365    * @return  a hash code value for this object.
366    */
367   public int hashCode()
368   {
369     return m_str.hashCode();
370   }
371 
372   /**
373    * Returns the index within this string of the first occurrence of the
374    * specified character. If a character with value <code>ch</code> occurs
375    * in the character sequence represented by this <code>String</code>
376    * object, then the index of the first such occurrence is returned --
377    * that is, the smallest value <i>k</i> such that:
378    * <blockquote><pre>
379    * this.charAt(<i>k</i>) == ch
380    * </pre></blockquote>
381    * is <code>true</code>. If no such character occurs in this string,
382    * then <code>-1</code> is returned.
383    *
384    * @param   ch   a character.
385    * @return  the index of the first occurrence of the character in the
386    *          character sequence represented by this object, or
387    *          <code>-1</code> if the character does not occur.
388    */
389   public int indexOf(int ch)
390   {
391     return m_str.indexOf(ch);
392   }
393 
394   /**
395    * Returns the index within this string of the first occurrence of the
396    * specified character, starting the search at the specified index.
397    * <p>
398    * If a character with value <code>ch</code> occurs in the character
399    * sequence represented by this <code>String</code> object at an index
400    * no smaller than <code>fromIndex</code>, then the index of the first
401    * such occurrence is returned--that is, the smallest value <i>k</i>
402    * such that:
403    * <blockquote><pre>
404    * (this.charAt(<i>k</i>) == ch) && (<i>k</i> >= fromIndex)
405    * </pre></blockquote>
406    * is true. If no such character occurs in this string at or after
407    * position <code>fromIndex</code>, then <code>-1</code> is returned.
408    * <p>
409    * There is no restriction on the value of <code>fromIndex</code>. If it
410    * is negative, it has the same effect as if it were zero: this entire
411    * string may be searched. If it is greater than the length of this
412    * string, it has the same effect as if it were equal to the length of
413    * this string: <code>-1</code> is returned.
414    *
415    * @param   ch          a character.
416    * @param   fromIndex   the index to start the search from.
417    * @return  the index of the first occurrence of the character in the
418    *          character sequence represented by this object that is greater
419    *          than or equal to <code>fromIndex</code>, or <code>-1</code>
420    *          if the character does not occur.
421    */
422   public int indexOf(int ch, int fromIndex)
423   {
424     return m_str.indexOf(ch, fromIndex);
425   }
426 
427   /**
428    * Returns the index within this string of the last occurrence of the
429    * specified character. That is, the index returned is the largest
430    * value <i>k</i> such that:
431    * <blockquote><pre>
432    * this.charAt(<i>k</i>) == ch
433    * </pre></blockquote>
434    * is true.
435    * The String is searched backwards starting at the last character.
436    *
437    * @param   ch   a character.
438    * @return  the index of the last occurrence of the character in the
439    *          character sequence represented by this object, or
440    *          <code>-1</code> if the character does not occur.
441    */
442   public int lastIndexOf(int ch)
443   {
444     return m_str.lastIndexOf(ch);
445   }
446 
447   /**
448    * Returns the index within this string of the last occurrence of the
449    * specified character, searching backward starting at the specified
450    * index. That is, the index returned is the largest value <i>k</i>
451    * such that:
452    * <blockquote><pre>
453    * this.charAt(k) == ch) && (k <= fromIndex)
454    * </pre></blockquote>
455    * is true.
456    *
457    * @param   ch          a character.
458    * @param   fromIndex   the index to start the search from. There is no
459    *          restriction on the value of <code>fromIndex</code>. If it is
460    *          greater than or equal to the length of this string, it has
461    *          the same effect as if it were equal to one less than the
462    *          length of this string: this entire string may be searched.
463    *          If it is negative, it has the same effect as if it were -1:
464    *          -1 is returned.
465    * @return  the index of the last occurrence of the character in the
466    *          character sequence represented by this object that is less
467    *          than or equal to <code>fromIndex</code>, or <code>-1</code>
468    *          if the character does not occur before that point.
469    */
470   public int lastIndexOf(int ch, int fromIndex)
471   {
472     return m_str.lastIndexOf(ch, fromIndex);
473   }
474 
475   /**
476    * Returns the index within this string of the first occurrence of the
477    * specified substring. The integer returned is the smallest value
478    * <i>k</i> such that:
479    * <blockquote><pre>
480    * this.startsWith(str, <i>k</i>)
481    * </pre></blockquote>
482    * is <code>true</code>.
483    *
484    * @param   str   any string.
485    * @return  if the string argument occurs as a substring within this
486    *          object, then the index of the first character of the first
487    *          such substring is returned; if it does not occur as a
488    *          substring, <code>-1</code> is returned.
489    * @exception java.lang.NullPointerException if <code>str</code> is
490    *          <code>null</code>.
491    */
492   public int indexOf(String   str)
493   {
494     return m_str.indexOf(str);
495   }
496 
497   /**
498    * Returns the index within this string of the first occurrence of the
499    * specified substring. The integer returned is the smallest value
500    * <i>k</i> such that:
501    * <blockquote><pre>
502    * this.startsWith(str, <i>k</i>)
503    * </pre></blockquote>
504    * is <code>true</code>.
505    *
506    * @param   str   any string.
507    * @return  if the string argument occurs as a substring within this
508    *          object, then the index of the first character of the first
509    *          such substring is returned; if it does not occur as a
510    *          substring, <code>-1</code> is returned.
511    * @exception java.lang.NullPointerException if <code>str</code> is
512    *          <code>null</code>.
513    */
514   public int indexOf(XMLString str)
515   {
516     return m_str.indexOf(str.toString());
517   }
518 
519   /**
520    * Returns the index within this string of the first occurrence of the
521    * specified substring, starting at the specified index. The integer
522    * returned is the smallest value <i>k</i> such that:
523    * <blockquote><pre>
524    * this.startsWith(str, <i>k</i>) && (<i>k</i> >= fromIndex)
525    * </pre></blockquote>
526    * is <code>true</code>.
527    * <p>
528    * There is no restriction on the value of <code>fromIndex</code>. If
529    * it is negative, it has the same effect as if it were zero: this entire
530    * string may be searched. If it is greater than the length of this
531    * string, it has the same effect as if it were equal to the length of
532    * this string: <code>-1</code> is returned.
533    *
534    * @param   str         the substring to search for.
535    * @param   fromIndex   the index to start the search from.
536    * @return  If the string argument occurs as a substring within this
537    *          object at a starting index no smaller than
538    *          <code>fromIndex</code>, then the index of the first character
539    *          of the first such substring is returned. If it does not occur
540    *          as a substring starting at <code>fromIndex</code> or beyond,
541    *          <code>-1</code> is returned.
542    * @exception java.lang.NullPointerException if <code>str</code> is
543    *          <code>null</code>
544    */
545   public int indexOf(String   str, int fromIndex)
546   {
547     return m_str.indexOf(str, fromIndex);
548   }
549 
550   /**
551    * Returns the index within this string of the rightmost occurrence
552    * of the specified substring.  The rightmost empty string "" is
553    * considered to occur at the index value <code>this.length()</code>.
554    * The returned index is the largest value <i>k</i> such that
555    * <blockquote><pre>
556    * this.startsWith(str, k)
557    * </pre></blockquote>
558    * is true.
559    *
560    * @param   str   the substring to search for.
561    * @return  if the string argument occurs one or more times as a substring
562    *          within this object, then the index of the first character of
563    *          the last such substring is returned. If it does not occur as
564    *          a substring, <code>-1</code> is returned.
565    * @exception java.lang.NullPointerException  if <code>str</code> is
566    *          <code>null</code>.
567    */
568   public int lastIndexOf(String   str)
569   {
570     return m_str.lastIndexOf(str);
571   }
572 
573   /**
574    * Returns the index within this string of the last occurrence of
575    * the specified substring.
576    *
577    * @param   str         the substring to search for.
578    * @param   fromIndex   the index to start the search from. There is no
579    *          restriction on the value of fromIndex. If it is greater than
580    *          the length of this string, it has the same effect as if it
581    *          were equal to the length of this string: this entire string
582    *          may be searched. If it is negative, it has the same effect
583    *          as if it were -1: -1 is returned.
584    * @return  If the string argument occurs one or more times as a substring
585    *          within this object at a starting index no greater than
586    *          <code>fromIndex</code>, then the index of the first character of
587    *          the last such substring is returned. If it does not occur as a
588    *          substring starting at <code>fromIndex</code> or earlier,
589    *          <code>-1</code> is returned.
590    * @exception java.lang.NullPointerException if <code>str</code> is
591    *          <code>null</code>.
592    */
593   public int lastIndexOf(String   str, int fromIndex)
594   {
595     return m_str.lastIndexOf(str, fromIndex);
596   }
597 
598   /**
599    * Returns a new string that is a substring of this string. The
600    * substring begins with the character at the specified index and
601    * extends to the end of this string. <p>
602    * Examples:
603    * <blockquote><pre>
604    * "unhappy".substring(2) returns "happy"
605    * "Harbison".substring(3) returns "bison"
606    * "emptiness".substring(9) returns "" (an empty string)
607    * </pre></blockquote>
608    *
609    * @param      beginIndex   the beginning index, inclusive.
610    * @return     the specified substring.
611    * @exception  IndexOutOfBoundsException  if
612    *             <code>beginIndex</code> is negative or larger than the
613    *             length of this <code>String</code> object.
614    */
615   public XMLString substring(int beginIndex)
616   {
617     return new XMLStringDefault(m_str.substring(beginIndex));
618   }
619 
620   /**
621    * Returns a new string that is a substring of this string. The
622    * substring begins at the specified <code>beginIndex</code> and
623    * extends to the character at index <code>endIndex - 1</code>.
624    * Thus the length of the substring is <code>endIndex-beginIndex</code>.
625    *
626    * @param      beginIndex   the beginning index, inclusive.
627    * @param      endIndex     the ending index, exclusive.
628    * @return     the specified substring.
629    * @exception  IndexOutOfBoundsException  if the
630    *             <code>beginIndex</code> is negative, or
631    *             <code>endIndex</code> is larger than the length of
632    *             this <code>String</code> object, or
633    *             <code>beginIndex</code> is larger than
634    *             <code>endIndex</code>.
635    */
636   public XMLString substring(int beginIndex, int endIndex)
637   {
638     return new XMLStringDefault(m_str.substring(beginIndex, endIndex));
639   }
640 
641   /**
642    * Concatenates the specified string to the end of this string.
643    *
644    * @param   str   the <code>String</code> that is concatenated to the end
645    *                of this <code>String</code>.
646    * @return  a string that represents the concatenation of this object's
647    *          characters followed by the string argument's characters.
648    * @exception java.lang.NullPointerException if <code>str</code> is
649    *          <code>null</code>.
650    */
651   public XMLString concat(String   str)
652   {
653     return new XMLStringDefault(m_str.concat(str));
654   }
655 
656   /**
657    * Converts all of the characters in this <code>String</code> to lower
658    * case using the rules of the given <code>Locale</code>.
659    *
660    * @param locale use the case transformation rules for this locale
661    * @return the String, converted to lowercase.
662    * @see     java.lang.Character#toLowerCase(char)
663    * @see     java.lang.String#toUpperCase(Locale)
664    */
665   public XMLString toLowerCase(Locale   locale)
666   {
667     return new XMLStringDefault(m_str.toLowerCase(locale));
668   }
669 
670   /**
671    * Converts all of the characters in this <code>String</code> to lower
672    * case using the rules of the default locale, which is returned
673    * by <code>Locale.getDefault</code>.
674    * <p>
675    *
676    * @return  the string, converted to lowercase.
677    * @see     java.lang.Character#toLowerCase(char)
678    * @see     java.lang.String#toLowerCase(Locale)
679    */
680   public XMLString toLowerCase()
681   {
682     return new XMLStringDefault(m_str.toLowerCase());
683   }
684 
685   /**
686    * Converts all of the characters in this <code>String</code> to upper
687    * case using the rules of the given locale.
688    * @param locale use the case transformation rules for this locale
689    * @return the String, converted to uppercase.
690    * @see     java.lang.Character#toUpperCase(char)
691    * @see     java.lang.String#toLowerCase(Locale)
692    */
693   public XMLString toUpperCase(Locale   locale)
694   {
695     return new XMLStringDefault(m_str.toUpperCase(locale));
696   }
697 
698   /**
699    * Converts all of the characters in this <code>String</code> to upper
700    * case using the rules of the default locale, which is returned
701    * by <code>Locale.getDefault</code>.
702    *
703    * <p>
704    * If no character in this string has a different uppercase version,
705    * based on calling the <code>toUpperCase</code> method defined by
706    * <code>Character</code>, then the original string is returned.
707    * <p>
708    * Otherwise, this method creates a new <code>String</code> object
709    * representing a character sequence identical in length to the
710    * character sequence represented by this <code>String</code> object and
711    * with every character equal to the result of applying the method
712    * <code>Character.toUpperCase</code> to the corresponding character of
713    * this <code>String</code> object. <p>
714    * Examples:
715    * <blockquote><pre>
716    * "Fahrvergn�gen".toUpperCase() returns "FAHRVERGN�GEN"
717    * "Visit Ljubinje!".toUpperCase() returns "VISIT LJUBINJE!"
718    * </pre></blockquote>
719    *
720    * @return  the string, converted to uppercase.
721    * @see     java.lang.Character#toUpperCase(char)
722    * @see     java.lang.String#toUpperCase(Locale)
723    */
724   public XMLString toUpperCase()
725   {
726     return new XMLStringDefault(m_str.toUpperCase());
727   }
728 
729   /**
730    * Removes white space from both ends of this string.
731    * <p>
732    * If this <code>String</code> object represents an empty character
733    * sequence, or the first and last characters of character sequence
734    * represented by this <code>String</code> object both have codes
735    * greater than <code>'&#92;u0020'</code> (the space character), then a
736    * reference to this <code>String</code> object is returned.
737    * <p>
738    * Otherwise, if there is no character with a code greater than
739    * <code>'&#92;u0020'</code> in the string, then a new
740    * <code>String</code> object representing an empty string is created
741    * and returned.
742    * <p>
743    * Otherwise, let <i>k</i> be the index of the first character in the
744    * string whose code is greater than <code>'&#92;u0020'</code>, and let
745    * <i>m</i> be the index of the last character in the string whose code
746    * is greater than <code>'&#92;u0020'</code>. A new <code>String</code>
747    * object is created, representing the substring of this string that
748    * begins with the character at index <i>k</i> and ends with the
749    * character at index <i>m</i>-that is, the result of
750    * <code>this.substring(<i>k</i>,&nbsp;<i>m</i>+1)</code>.
751    * <p>
752    * This method may be used to trim
753    * {@link Character#isSpace(char) whitespace} from the beginning and end
754    * of a string; in fact, it trims all ASCII control characters as well.
755    *
756    * @return  this string, with white space removed from the front and end.
757    */
758   public XMLString trim()
759   {
760     return new XMLStringDefault(m_str.trim());
761   }
762 
763   /**
764    * This object (which is already a string!) is itself returned.
765    *
766    * @return  the string itself.
767    */
768   public String   toString()
769   {
770     return m_str;
771   }
772   
773   /**
774    * Tell if this object contains a java String object.
775    * 
776    * @return true if this XMLString can return a string without creating one.
777    */
778   public boolean hasString()
779   {
780     return true;
781   }
782   
783   /**
784    * Convert a string to a double -- Allowed input is in fixed
785    * notation ddd.fff.
786    *
787    * @return A double value representation of the string, or return Double.NaN 
788    * if the string can not be converted.
789    */
790   public double toDouble()
791   {
792     try {
793       return Double.valueOf(m_str).doubleValue();
794     }
795     catch (NumberFormatException   nfe)
796     {
797       return Double.NaN;
798     }
799   }
800 }
801
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags