2001-09-04 Tom Tromey <tromey@redhat.com>
+ * java/text/SimpleDateFormat.java: Re-merged with Classpath.
+ * gnu/gcj/text/LocaleData.java, gnu/gcj/text/LocaleData_en.java,
+ gnu/gcj/text/LocaleData_en_US.java: Removed.
+ * java/text/DateFormatSymbols.java (clone): Use Classpath
+ implementation.
+ (equals): Simplified.
+ (DateFormatSymbols): Look in gnu.java.locale for information.
+ (DateFormatSymbols(DateFormatSymbols)): Removed.
+ (safeGetResource): Removed.
+ (DateFormatSymbols): Throws MissingResourceException.
+ (ampmsDefault, erasDefault, localPatternCharsDefault,
+ monthsDefault, shortMonthsDefault, shortWeekdaysDefault,
+ weekdaysDefault, zoneStringsDefault): Removed.
+ * java/text/Collator.java (getAvailableLocales): Use modified
+ Classpath implementation.
+ (getInstance): Look in gnu.java.locale for information.
+ (clone): Rewrote.
+ * java/text/MessageFormat.java: Reindented.
+ (clone): Rewrote.
+ * java/text/FieldPosition.java: Merged with Classpath.
+ * java/text/ParsePosition.java: Merged with Classpath.
+ * java/text/Format.java: Merged with Classpath.
+ * java/text/StringCharacterIterator.java
+ (StringCharacterIterator(StringCharacterIterator,int,int)): New
+ constructor from Classpath.
+ * java/text/Annotation.java,
+ java/text/AttributedCharacterIterator.java,
+ java/text/AttributedString.java,
+ java/text/AttributedStringIterator.java: New from Classpath.
+ * java/text/CharacterIterator.java: Copied from Classpath.
+ * java/text/ChoiceFormat.java: Reindented.
+ (clone): Removed.
+ * gnu/java/text/BaseBreakIterator.java,
+ gnu/java/text/CharacterBreakIterator.java,
+ gnu/java/text/LineBreakIterator.java,
+ gnu/java/text/LocaleData_en.java,
+ gnu/java/text/LocaleData_en_US.java,
+ gnu/java/text/SentenceBreakIterator.java,
+ gnu/java/text/WordBreakIterator.java: Renamed from gnu/gcj/text/*.
+ * gnu/gcj/text/BaseBreakIterator.java (last): Advance past final
+ character.
+ * java/text/BreakIterator.java (getAvailableLocales): Use
+ Classpath implementation.
+ (getInstance): Look in gnu.java.locale for information.
+ (getCharacterInstance, getLineInstance, getSentenceInstance,
+ getWordInstance): Look in gnu.java.text for implementations.
+ * java/text/DecimalFormatSymbols.java: Reindented
+ (clone): Use Classpath implementation.
+ (DecimalFormatSymbols(DecimalFormatSymbols)): Removed.
+ (DecimalFormatSymbols(Locale)): Look in gnu.java.locale for
+ information.
+ * java/text/DateFormat.java: Merged with Classpath.
+ (getAvailableLocales): Use Classpath implementation.
+ (format(Object,StringBuffer,FieldPosition)): Minor cleanup.
+ (computeInstance): Look in gnu.java.locale for information.
+ * java/text/NumberFormat.java: Reindented.
+ (computeInstance): Look in gnu.java.locale for information.
+ (getAvailableLocales): Use implementation from Classpath.
+ (setMaximumIntegerDigits): Likewise.
+ (setMinimumIntegerDigits): Likewise.
+ (setMaximumFractionDigits): Likewise.
+ (clone): Removed.
+ * java/text/DecimalFormat.java: Reindented.
+ * gnu/java/locale/LocaleInformation_en.java: Copied from Classpath.
+ * gnu/java/locale/LocaleInformation_en_US.java: Copied from Classpath.
+ * Makefile.in: Rebuilt.
+ * Makefile.am (ordinary_java_source_files): Added all new files.
+ (ordinary_java_source_files): Renamed or removed gnu/gcj/text/*.
+ * java/security/spec/AlgorithmParameterSpec.java,
+ java/security/spec/KeySpec.java: Re-merged with Classpath.
+
Fix for PR libgcj/4213:
* Makefile.am (ordinary_java_source_files): Added new file.
* gnu/gcj/text/LocaleData.java: New file.
gnu/gcj/runtime/FileDeleter.java \
gnu/gcj/runtime/FirstThread.java \
gnu/gcj/runtime/VMClassLoader.java \
-gnu/gcj/text/BaseBreakIterator.java \
-gnu/gcj/text/CharacterBreakIterator.java \
-gnu/gcj/text/LineBreakIterator.java \
-gnu/gcj/text/LocaleData.java \
-gnu/gcj/text/LocaleData_en.java \
-gnu/gcj/text/LocaleData_en_US.java \
-gnu/gcj/text/SentenceBreakIterator.java \
-gnu/gcj/text/WordBreakIterator.java \
gnu/java/io/ClassLoaderObjectInputStream.java \
gnu/java/io/NullOutputStream.java \
gnu/java/io/ObjectIdentityWrapper.java \
gnu/java/locale/Calendar_de.java \
gnu/java/locale/Calendar_en.java \
gnu/java/locale/Calendar_nl.java \
+gnu/java/locale/LocaleInformation.java \
+gnu/java/locale/LocaleInformation_de.java \
+gnu/java/locale/LocaleInformation_en.java \
+gnu/java/locale/LocaleInformation_en_US.java \
+gnu/java/locale/LocaleInformation_nl.java \
gnu/java/security/provider/DefaultPolicy.java \
gnu/java/security/provider/Gnu.java \
gnu/java/security/provider/SHA.java \
gnu/java/security/provider/SHA1PRNG.java \
+gnu/java/text/BaseBreakIterator.java \
+gnu/java/text/CharacterBreakIterator.java \
+gnu/java/text/LineBreakIterator.java \
+gnu/java/text/SentenceBreakIterator.java \
+gnu/java/text/WordBreakIterator.java \
gnu/java/util/DoubleEnumeration.java \
java/lang/ref/PhantomReference.java \
java/lang/ref/Reference.java \
java/sql/Time.java \
java/sql/Timestamp.java \
java/sql/Types.java \
+java/text/Annotation.java \
+java/text/AttributedCharacterIterator.java \
+java/text/AttributedString.java \
+java/text/AttributedStringIterator.java \
java/text/BreakIterator.java \
java/text/CharacterIterator.java \
java/text/ChoiceFormat.java \
gnu/gcj/runtime/FileDeleter.java \
gnu/gcj/runtime/FirstThread.java \
gnu/gcj/runtime/VMClassLoader.java \
-gnu/gcj/text/BaseBreakIterator.java \
-gnu/gcj/text/CharacterBreakIterator.java \
-gnu/gcj/text/LineBreakIterator.java \
-gnu/gcj/text/LocaleData.java \
-gnu/gcj/text/LocaleData_en.java \
-gnu/gcj/text/LocaleData_en_US.java \
-gnu/gcj/text/SentenceBreakIterator.java \
-gnu/gcj/text/WordBreakIterator.java \
gnu/java/io/ClassLoaderObjectInputStream.java \
gnu/java/io/NullOutputStream.java \
gnu/java/io/ObjectIdentityWrapper.java \
gnu/java/locale/Calendar_de.java \
gnu/java/locale/Calendar_en.java \
gnu/java/locale/Calendar_nl.java \
+gnu/java/locale/LocaleInformation.java \
+gnu/java/locale/LocaleInformation_de.java \
+gnu/java/locale/LocaleInformation_en.java \
+gnu/java/locale/LocaleInformation_en_US.java \
+gnu/java/locale/LocaleInformation_nl.java \
gnu/java/security/provider/DefaultPolicy.java \
gnu/java/security/provider/Gnu.java \
gnu/java/security/provider/SHA.java \
gnu/java/security/provider/SHA1PRNG.java \
+gnu/java/text/BaseBreakIterator.java \
+gnu/java/text/CharacterBreakIterator.java \
+gnu/java/text/LineBreakIterator.java \
+gnu/java/text/SentenceBreakIterator.java \
+gnu/java/text/WordBreakIterator.java \
gnu/java/util/DoubleEnumeration.java \
java/lang/ref/PhantomReference.java \
java/lang/ref/Reference.java \
java/sql/Time.java \
java/sql/Timestamp.java \
java/sql/Types.java \
+java/text/Annotation.java \
+java/text/AttributedCharacterIterator.java \
+java/text/AttributedString.java \
+java/text/AttributedStringIterator.java \
java/text/BreakIterator.java \
java/text/CharacterIterator.java \
java/text/ChoiceFormat.java \
.deps/gnu/gcj/protocol/jar/Handler.P \
.deps/gnu/gcj/runtime/FileDeleter.P .deps/gnu/gcj/runtime/FirstThread.P \
.deps/gnu/gcj/runtime/VMClassLoader.P \
-.deps/gnu/gcj/runtime/natFirstThread.P \
-.deps/gnu/gcj/text/BaseBreakIterator.P \
-.deps/gnu/gcj/text/CharacterBreakIterator.P \
-.deps/gnu/gcj/text/LineBreakIterator.P .deps/gnu/gcj/text/LocaleData.P \
-.deps/gnu/gcj/text/LocaleData_en.P \
-.deps/gnu/gcj/text/LocaleData_en_US.P \
-.deps/gnu/gcj/text/SentenceBreakIterator.P \
-.deps/gnu/gcj/text/WordBreakIterator.P .deps/gnu/gcj/xlib/Clip.P \
+.deps/gnu/gcj/runtime/natFirstThread.P .deps/gnu/gcj/xlib/Clip.P \
.deps/gnu/gcj/xlib/Colormap.P .deps/gnu/gcj/xlib/Display.P \
.deps/gnu/gcj/xlib/Drawable.P .deps/gnu/gcj/xlib/Font.P \
.deps/gnu/gcj/xlib/GC.P .deps/gnu/gcj/xlib/Pixmap.P \
.deps/gnu/java/lang/reflect/TypeSignature.P \
.deps/gnu/java/locale/Calendar.P .deps/gnu/java/locale/Calendar_de.P \
.deps/gnu/java/locale/Calendar_en.P .deps/gnu/java/locale/Calendar_nl.P \
+.deps/gnu/java/locale/LocaleInformation.P \
+.deps/gnu/java/locale/LocaleInformation_de.P \
+.deps/gnu/java/locale/LocaleInformation_en.P \
+.deps/gnu/java/locale/LocaleInformation_en_US.P \
+.deps/gnu/java/locale/LocaleInformation_nl.P \
.deps/gnu/java/rmi/dgc/DGCImpl.P .deps/gnu/java/rmi/dgc/DGCImpl_Skel.P \
.deps/gnu/java/rmi/dgc/DGCImpl_Stub.P \
.deps/gnu/java/rmi/registry/RegistryImpl.P \
.deps/gnu/java/security/provider/Gnu.P \
.deps/gnu/java/security/provider/SHA.P \
.deps/gnu/java/security/provider/SHA1PRNG.P \
+.deps/gnu/java/text/BaseBreakIterator.P \
+.deps/gnu/java/text/CharacterBreakIterator.P \
+.deps/gnu/java/text/LineBreakIterator.P \
+.deps/gnu/java/text/SentenceBreakIterator.P \
+.deps/gnu/java/text/WordBreakIterator.P \
.deps/gnu/java/util/DoubleEnumeration.P .deps/interpret.P \
.deps/java/applet/Applet.P .deps/java/applet/AppletContext.P \
.deps/java/applet/AppletStub.P .deps/java/applet/AudioClip.P \
.deps/java/sql/SQLOutput.P .deps/java/sql/SQLWarning.P \
.deps/java/sql/Statement.P .deps/java/sql/Struct.P \
.deps/java/sql/Time.P .deps/java/sql/Timestamp.P .deps/java/sql/Types.P \
+.deps/java/text/Annotation.P \
+.deps/java/text/AttributedCharacterIterator.P \
+.deps/java/text/AttributedString.P \
+.deps/java/text/AttributedStringIterator.P \
.deps/java/text/BreakIterator.P .deps/java/text/CharacterIterator.P \
.deps/java/text/ChoiceFormat.P \
.deps/java/text/CollationElementIterator.P \
+++ /dev/null
-// Base class for default BreakIterators.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
-
-import java.text.BreakIterator;
-import java.text.CharacterIterator;
-
-/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date March 22, 1999
- */
-
-public abstract class BaseBreakIterator extends BreakIterator
-{
- public int current ()
- {
- return iter.getIndex();
- }
-
- public int first ()
- {
- iter.first();
- return iter.getBeginIndex();
- }
-
- public int following (int pos)
- {
- int save = iter.getIndex();
- iter.setIndex(pos);
- int r = next ();
- iter.setIndex(save);
- return r;
- }
-
- public CharacterIterator getText ()
- {
- return iter;
- }
-
- public int last ()
- {
- iter.last();
- return iter.getEndIndex();
- }
-
- public int next (int n)
- {
- int r = iter.getIndex ();
- if (n > 0)
- {
- while (n > 0 && r != DONE)
- {
- r = next ();
- --n;
- }
- }
- else if (n < 0)
- {
- while (n < 0 && r != DONE)
- {
- r = previous ();
- ++n;
- }
- }
- return r;
- }
-
- public void setText (CharacterIterator newText)
- {
- iter = newText;
- }
-
- protected CharacterIterator iter;
-}
+++ /dev/null
-// Generic locale data for java.text.
-
-/* Copyright (C) 2001 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
-
-import java.util.ListResourceBundle;
-
-public class LocaleData extends ListResourceBundle
-{
- private static final Object[][] contents =
- {
- };
-
- protected Object[][] getContents ()
- {
- return contents;
- }
-}
+++ /dev/null
-// Generic English locale data for java.text.
-
-/* Copyright (C) 1999, 2000 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
-
-import java.util.ListResourceBundle;
-
-/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date March 4, 1999
- */
-
-public final class LocaleData_en extends ListResourceBundle
-{
- // These are for DateFormatSymbols.
- static final String[] ampmsDefault = {"AM", "PM" };
- static final String[] erasDefault = {"BC", "AD" };
- static final String localPatternCharsDefault = "GyMdkHmsSEDFwWahKz";
- static final String[] monthsDefault = {
- "January", "February", "March", "April", "May", "June",
- "July", "August", "September", "October", "November", "December", ""
- };
- static final String[] shortMonthsDefault = {
- "Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""
- };
- static final String[] shortWeekdaysDefault = {
- "", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
- };
- static final String[] weekdaysDefault = {
- "", "Sunday", "Monday", "Tuesday",
- "Wednesday", "Thursday", "Friday", "Saturday"
- };
-
- private static final Object[][] contents =
- {
- // These are for DecimalFormatSymbols.
- { "decimalSeparator", "." },
- { "digit", "#" },
- { "exponential", "E" },
- { "groupingSeparator", "," },
- { "infinity", "\u221e" },
- { "minusSign", "-" },
- { "monetarySeparator", "." },
- { "NaN", "\ufffd" },
- { "patternSeparator", ";" },
- { "percent", "%" },
- { "perMill", "\u2030" },
- { "zeroDigit", "0" },
-
- // These are for NumberFormat.
- { "numberFormat", "#,##0.###" },
- { "percentFormat", "#,##0%" },
-
- // These are for DateFormatSymbols.
- { "ampm", ampmsDefault },
- { "eras", erasDefault },
- { "datePatternChars", localPatternCharsDefault },
- { "months", monthsDefault },
- { "shortMonths", shortMonthsDefault },
- { "shortWeekdays", shortWeekdaysDefault },
- { "weekdays", weekdaysDefault },
-
- // These are for DateFormat.
- { "shortDateFormat", "M/d/yy" }, // Java's Y2K bug.
- { "mediumDateFormat", "d-MMM-yy" },
- { "longDateFormat", "MMMM d, yyyy" },
- { "fullDateFormat", "EEEE MMMM d, yyyy G" },
- { "shortTimeFormat", "h:mm a" },
- { "mediumTimeFormat", "h:mm:ss a" },
- { "longTimeFormat", "h:mm:ss a z" },
- { "fullTimeFormat", "h:mm:ss;S 'o''clock' a z" },
-
- // For RuleBasedCollator.
- // FIXME: this is nowhere near complete.
- // In particular we must mark accents as ignorable,
- // and probably other things as well.
- { "collatorRule", "< 0 < 1 < 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < a,A < b,B < c,C < d,D < e,E < f,F < g,G < h,H < i,I < j,J < k,K < l,L < m,M < n,N < o,O < p,P < q,Q < r,R < s,S < t,T < u,U < v,V < w,W < x,X < y,Y < z,Z" }
- };
-
- protected Object[][] getContents ()
- {
- return contents;
- }
-}
+++ /dev/null
-// US English locale data for java.text.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
-
-import java.util.ListResourceBundle;
-
-/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date March 4, 1999
- */
-
-public final class LocaleData_en_US extends ListResourceBundle
-{
- // These are for DateFormatSymbols.
- static String[][] zoneStringsDefault = {
- { "GMT", "Greenwich Mean Time", "GMT",
- /**/ "Greenwich Mean Time", "GMT", "GMT" },
- { "PST", "Pacific Standard Time", "PST",
- /**/ "Pacific Daylight Time", "PDT", "San Francisco" },
- { "MST", "Mountain Standard Time", "MST",
- /**/ "Mountain Daylight Time", "MDT", "Denver" },
- { "PNT", "Mountain Standard Time", "MST",
- /**/ "Mountain Standard Time", "MST", "Phoenix" },
- { "CST", "Central Standard Time", "CST",
- /**/ "Central Daylight Time", "CDT", "Chicago" },
- { "EST", "Eastern Standard Time", "EST",
- /**/ "Eastern Daylight Time", "EDT", "Boston" },
- { "IET", "Eastern Standard Time", "EST",
- /**/ "Eastern Standard Time", "EST", "Indianapolis" },
- { "PRT", "Atlantic Standard Time", "AST",
- /**/ "Atlantic Daylight Time", "ADT", "Halifax" },
- { "CNT", "Newfoundland Standard Time", "NST",
- /**/ "Newfoundland Daylight Time", "NDT", "St. Johns" },
- { "ECT", "Central European Standard Time", "CET",
- /**/ "Central European Daylight Time", "CEST", "Paris" },
- { "CTT", "China Standard Time", "CST",
- /**/ "China Standard Time", "CST", "Shanghai" },
- { "JST", "Japan Standard Time", "JST",
- /**/ "Japan Standard Time", "JST", "Tokyo" },
- { "HST", "Hawaii Standard Time", "HST",
- /**/ "Hawaii Standard Time", "HST", "Honolulu" },
- { "AST", "Alaska Standard Time", "AKST",
- /**/ "Alaska Daylight Time", "AKDT", "Anchorage" }
- };
-
- private static final Object[][] contents =
- {
- // These are for DecimalFormatSymbols.
- { "currency", "$" },
- { "intlCurrencySymbol", "$" }, // FIXME?
-
- // These are for NumberFormat.
- { "currencyFormat", "$#,##0.00;($#,##0.00)" },
-
- // These are for DateFormatSymbols.
- { "zoneStrings", zoneStringsDefault },
-
- // These are for DateFormat.
- { "shortDateFormat", "M/d/yy" }, // Java's Y2K bug.
- { "mediumDateFormat", "d-MMM-yy" },
- { "longDateFormat", "MMMM d, yyyy" },
- { "fullDateFormat", "EEEE MMMM d, yyyy G" },
- { "shortTimeFormat", "h:mm a" },
- { "mediumTimeFormat", "h:mm:ss a" },
- { "longTimeFormat", "h:mm:ss a z" },
- { "fullTimeFormat", "h:mm:ss;S 'o''clock' a z" }
- };
-
- protected Object[][] getContents ()
- {
- return contents;
- }
-}
/* LocaleInformation_de.java -- German locale data
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
* proper format.
*/
private static final String collation_rules =
- "-<0,1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
+ "<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z" +
"&ae,\u00e4&Ae,\u00c4&oe,\u00f6&Oe,\u00d6&ue,\u00fc&Ue,\u00dc&ss,\u00df";
/* LocaleInformation_en.java -- US English locale data
- Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.util.Date;
/**
- * This class contains locale data for the US English locale
- */
-
+ * This class contains locale data for English.
+ */
public class LocaleInformation_en extends ListResourceBundle
{
-/*
- * This area is used for defining object values
- */
-
-/**
- * This is the set of collation rules used by java.text.RuleBasedCollator
- * to sort strings properly. See the documentation of that class for the
- * proper format.
- */
-private static final String collation_rules =
- "-<0,1<2<3<4<5<6<7<8<9A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
+ /*
+ * This area is used for defining object values
+ */
+
+ /**
+ * This is the set of collation rules used by java.text.RuleBasedCollator
+ * to sort strings properly. See the documentation of that class for the
+ * proper format.
+ */
+ // FIXME: this is nowhere near complete.
+ // In particular we must mark accents as ignorable,
+ // and probably other things as well.
+ private static final String collation_rules =
+ "<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z";
-/*
- * For the followings lists, strings that are subsets of other break strigns
- * must be listed first. For example, if "\r" and "\r\n" are sequences,
- * the "\r" must be first or it will never be used.
- */
-
-/**
- * This is the list of word separator characters used by
- * java.text.BreakIterator
- */
-private static final String[] word_breaks = { " ", "\t", "\r\n", "\n" };
-
-/**
- * This is the list of sentence break sequences used by
- * java.text.BreakIterator
- */
-private static final String[] sentence_breaks = { ". " };
-
-/**
- * This is the list of potential line break locations.
- */
-private static final String[] line_breaks = { "\t", "-", "\r\n",
- "\n", ". ", ". ", ".", "? ", "? ", "?", "! ", "! ", "!", ", ", " " };
-
-/**
- * This is the list of months, fully spelled out
- */
-private static final String[] months = { "January", "February", "March",
- "April", "May", "June", "July", "August", "September", "October",
- "November", "December", null };
-
-/**
- * This is the list of abbreviated month names
- */
-private static final String[] shortMonths = { "Jan", "Feb", "Mar", "Apr", "May",
- "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", null };
-
-/**
- * This is the list of weekdays, fully spelled out
- */
-private static final String[] weekdays = { null, "Sunday", "Monday", "Tuesday",
- "Wednesday", "Thursday", "Friday", "Saturday" };
-
-/**
- * This is the list of abbreviated weekdays
- */
-private static final String[] shortWeekdays = { null, "Sun", "Mon", "Tue", "Wed",
- "Thu", "Fri", "Sat" };
-
-/**
- * This is the list of AM/PM strings
- */
-private static final String[] ampms = { "AM", "PM" };
-
-/**
- * This is the list of era identifiers
- */
-private static final String[] eras = { "BC", "AD" };
-
-/**
- * This is the list of timezone strings. The JDK appears to include a
- * city name as the sixth element.
- */
-private static final String[][] zoneStrings =
-{
- { "EST6EDT", "Eastern Standard Time", "EST", "Eastern Daylight Time", "EDT",
- "New York" },
- { "EST6", "Eastern Standard Time", "EST", "Eastern Standard Time", "EST",
- "Indianapolis" },
- { "CST6CDT", "Central Standard Time", "CST", "Central Daylight Time", "CDT",
- "Chicago" },
- { "MST6MDT", "Mountain Standard Time", "MST", "Mountain Daylight Time",
- "MDT", "Denver" },
- { "MST6", "Mountain Standard Time", "MST", "Mountain Standard Time", "MST",
- "Phoenix" },
- { "PST6PDT", "Pacific Standard Time", "PDT", "Pacific Daylight Time", "PDT",
- "San Francisco" },
- { "AST6ADT", "Alaska Standard Time", "AST", "Alaska Daylight Time", "ADT",
- "Anchorage" },
- { "HST6HDT", "Hawaii Standard Time", "HST", "Hawaii Daylight Time", "HDT",
- "Honolulu" },
- // European time zones. The city names are a little bit random.
- { "WET", "Western European Time", "WET", "Western European Savings Time", "WEST", "London" },
- { "CET", "Central European Time", "CET", "Central European Savings Time", "CEST", "Berlin" },
- { "EET", "Eastern European Time", "EET", "Eastern European Savings Time", "EEST", "Istanbul" },
-};
-
-/**
- * This is the list of pattern characters for formatting dates
- */
-private static final String localPatternChars = "GyMdkHmsSEDFwWahKz"; // Not a mistake!
-
-/**
- * This is the DateFormat.SHORT date format
- */
-private static final String shortDateFormat = "M/d/yy";
-
-/**
- * This is the DateFormat.MEDIUM format
- */
-private static final String mediumDateFormat = "dd-MMM-yy";
-
-/**
- * This is the DateFormat.LONG format
- */
-private static final String longDateFormat = "MMMM d, yyyy";
-
-/**
- * This is the DateFormat.FULL format
- */
-private static final String fullDateFormat = "EEEE, MMMM d, yyyy";
-
-/**
- * This is the DateFormat.DEFAULT format
- */
-private static final String defaultDateFormat = "dd-MMM-yy";
-
-/**
- * This is the DateFormat.SHORT format
- */
-private static final String shortTimeFormat = "h:mm a";
-
-/**
- * This is the DateFormat.MEDIUM format
- */
-private static final String mediumTimeFormat = "h:mm:ss a";
-
-/**
- * This is the DateFormat.LONG format
- */
-private static final String longTimeFormat = "h:mm:ss a z";
-
-/**
- * This is the DateFormat.FULL format
- */
-private static final String fullTimeFormat = "h:mm:ss 'o''clock' a z";
-
-/**
- * This is the DateFormat.DEFAULT format
- */
-private static final String defaultTimeFormat = "h:mm:ss a";
-
-/**
- * This is the currency symbol
- */
-private static final String currencySymbol = "$";
-
-/**
- * This is the international currency symbol.
- */
-private static final String intlCurrencySymbol = "US$";
-
-/**
- * This is the decimal point.
- */
-private static final String decimalSeparator = ".";
-
-/**
- * This is the exponential symbol
- */
-private static final String exponential = "E";
-
-/**
- * This is the char used for digits in format strings
- */
-private static final String digit = "#";
-
-/**
- * This is the grouping separator symbols
- */
-private static final String groupingSeparator = ",";
-
-/**
- * This is the symbols for infinity
- */
-private static final String infinity = "\u221e";
-
-/**
- * This is the symbol for the not a number value
- */
-private static final String NaN = "\ufffd";
-
-/**
- * This is the minus sign symbol.
- */
-private static final String minusSign = "-";
-
-/**
- * This is the decimal separator in monetary values.
- */
-private static final String monetarySeparator = ".";
-
-/**
- * This is the separator between positive and negative subpatterns.
- */
-private static final String patternSeparator = ";";
-
-/**
- * This is the percent sign
- */
-private static final String percent = "%";
-
-/**
- * This is the per mille sign
- */
-private static final String perMill = "\u2030";
-
-/**
- * This is the character for zero.
- */
-private static final String zeroDigit = "0";
-
-/*************************************************************************/
-
-/**
- * This is the object array used to hold the keys and values
- * for this bundle
- */
-
-private static final Object[][] contents =
-{
- // For RuleBasedCollator
- { "collation_rules", collation_rules },
- // For BreakIterator
- { "word_breaks", word_breaks },
- { "sentence_breaks", sentence_breaks },
- { "line_breaks", line_breaks },
- // For SimpleDateFormat/DateFormatSymbols
- { "months", months },
- { "shortMonths", shortMonths },
- { "weekdays", weekdays },
- { "shortWeekdays", shortWeekdays },
- { "ampms", ampms },
- { "eras", eras },
- { "zoneStrings", zoneStrings },
- { "localPatternChars", localPatternChars },
- { "shortDateFormat", shortDateFormat },
- { "mediumDateFormat", mediumDateFormat },
- { "longDateFormat", longDateFormat },
- { "fullDateFormat", fullDateFormat },
- { "defaultDateFormat", defaultDateFormat },
- { "shortTimeFormat", shortTimeFormat },
- { "mediumTimeFormat", mediumTimeFormat },
- { "longTimeFormat", longTimeFormat },
- { "fullTimeFormat", fullTimeFormat },
- { "defaultTimeFormat", defaultTimeFormat },
- // For DecimalFormat/DecimalFormatSymbols
- { "currencySymbol", currencySymbol },
- { "intlCurrencySymbol", intlCurrencySymbol },
- { "decimalSeparator", decimalSeparator },
- { "digit", digit },
- { "exponential", exponential },
- { "groupingSeparator", groupingSeparator },
- { "infinity", infinity },
- { "NaN", NaN },
- { "minusSign", minusSign },
- { "monetarySeparator", monetarySeparator },
- { "patternSeparator", patternSeparator },
- { "percent", percent },
- { "perMill", perMill },
- { "zeroDigit", zeroDigit },
-};
-
-/*************************************************************************/
-
-/**
- * This method returns the object array of key, value pairs containing
- * the data for this bundle.
- *
- * @return The key, value information.
- */
-public Object[][]
-getContents()
-{
- return(contents);
+ /**
+ * This is the list of months, fully spelled out
+ */
+ private static final String[] months =
+ {
+ "January", "February", "March", "April", "May", "June",
+ "July", "August", "September", "October", "November", "December", null
+ };
+
+ /**
+ * This is the list of abbreviated month names
+ */
+ private static final String[] shortMonths =
+ {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", null
+ };
+
+ /**
+ * This is the list of weekdays, fully spelled out
+ */
+ private static final String[] weekdays =
+ {
+ null, "Sunday", "Monday", "Tuesday", "Wednesday",
+ "Thursday", "Friday", "Saturday"
+ };
+
+ /**
+ * This is the list of abbreviated weekdays
+ */
+ private static final String[] shortWeekdays =
+ {
+ null, "Sun", "Mon", "Tue", "Wed",
+ "Thu", "Fri", "Sat"
+ };
+
+ /**
+ * This is the list of AM/PM strings
+ */
+ private static final String[] ampms = { "AM", "PM" };
+
+ /**
+ * This is the list of era identifiers
+ */
+ private static final String[] eras = { "BC", "AD" };
+
+ /*************************************************************************/
+
+ /**
+ * This is the object array used to hold the keys and values
+ * for this bundle
+ */
+
+ private static final Object[][] contents =
+ {
+ // For RuleBasedCollator
+ { "collation_rules", collation_rules },
+
+ // For SimpleDateFormat/DateFormatSymbols
+ { "months", months },
+ { "shortMonths", shortMonths },
+ { "weekdays", weekdays },
+ { "shortWeekdays", shortWeekdays },
+ { "ampms", ampms },
+ { "eras", eras },
+ { "localPatternChars", "GyMdkHmsSEDFwWahKz" },
+
+ // For DecimalFormat/DecimalFormatSymbols
+ { "decimalSeparator", "." },
+ { "digit", "#" },
+ { "exponential", "E" },
+ { "groupingSeparator", "," },
+ { "infinity", "\u221e" },
+ { "NaN", "\ufffd" },
+ { "minusSign", "-" },
+ { "monetarySeparator", "." },
+ { "patternSeparator", ";" },
+ { "percent", "%" },
+ { "perMill", "\u2030" },
+ { "zeroDigit", "0" },
+
+ // For NumberFormat.
+ { "numberFormat", "#,##0.###" },
+ { "percentFormat", "#,##0%" },
+ };
+
+ /*************************************************************************/
+
+ /**
+ * This method returns the object array of key, value pairs containing
+ * the data for this bundle.
+ *
+ * @return The key, value information.
+ */
+ public Object[][] getContents ()
+ {
+ return contents;
+ }
}
-
-} // class LocaleInformation_en
-
--- /dev/null
+/* LocaleInformation_en.java -- US English locale data
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.locale;
+
+import java.util.ListResourceBundle;
+import java.util.Calendar;
+import java.util.Date;
+
+/**
+ * This class contains locale data for English in the US.
+ */
+public class LocaleInformation_en_US extends ListResourceBundle
+{
+ // These are for DateFormatSymbols.
+ private static final String[][] zoneStrings =
+ {
+ { "GMT", "Greenwich Mean Time", "GMT",
+ /**/ "Greenwich Mean Time", "GMT", "GMT" },
+ { "PST", "Pacific Standard Time", "PST",
+ /**/ "Pacific Daylight Time", "PDT", "San Francisco" },
+ { "MST", "Mountain Standard Time", "MST",
+ /**/ "Mountain Daylight Time", "MDT", "Denver" },
+ { "PNT", "Mountain Standard Time", "MST",
+ /**/ "Mountain Standard Time", "MST", "Phoenix" },
+ { "CST", "Central Standard Time", "CST",
+ /**/ "Central Daylight Time", "CDT", "Chicago" },
+ { "EST", "Eastern Standard Time", "EST",
+ /**/ "Eastern Daylight Time", "EDT", "Boston" },
+ { "IET", "Eastern Standard Time", "EST",
+ /**/ "Eastern Standard Time", "EST", "Indianapolis" },
+ { "PRT", "Atlantic Standard Time", "AST",
+ /**/ "Atlantic Daylight Time", "ADT", "Halifax" },
+ { "CNT", "Newfoundland Standard Time", "NST",
+ /**/ "Newfoundland Daylight Time", "NDT", "St. Johns" },
+ { "ECT", "Central European Standard Time", "CET",
+ /**/ "Central European Daylight Time", "CEST", "Paris" },
+ { "CTT", "China Standard Time", "CST",
+ /**/ "China Standard Time", "CST", "Shanghai" },
+ { "JST", "Japan Standard Time", "JST",
+ /**/ "Japan Standard Time", "JST", "Tokyo" },
+ { "HST", "Hawaii Standard Time", "HST",
+ /**/ "Hawaii Standard Time", "HST", "Honolulu" },
+ { "AST", "Alaska Standard Time", "AKST",
+ /**/ "Alaska Daylight Time", "AKDT", "Anchorage" }
+ };
+
+ /**
+ * This is the object array used to hold the keys and values
+ * for this bundle
+ */
+
+ private static final Object[][] contents =
+ {
+ // For SimpleDateFormat/DateFormatSymbols
+ { "zoneStrings", zoneStrings },
+ { "shortDateFormat", "M/d/yy" }, // Java's Y2K bug.
+ { "mediumDateFormat", "d-MMM-yy" },
+ { "longDateFormat", "MMMM d, yyyy" },
+ { "defaultDateFormat", "d-MMMM-yy" },
+ { "fullDateFormat", "EEEE MMMM d, yyyy G" },
+ { "shortTimeFormat", "h:mm a" },
+ { "mediumTimeFormat", "h:mm:ss a" },
+ { "longTimeFormat", "h:mm:ss a z" },
+ { "fullTimeFormat", "h:mm:ss;S 'o''clock' a z" },
+ { "defaultTimeFormat", "h:mm:ss a" },
+
+ // For DecimalFormat/DecimalFormatSymbols
+ { "currencySymbol", "$" },
+ { "intlCurrencySymbol", "US$" },
+
+ // For NumberFormat.
+ { "currencyFormat", "$#,##0.00;($#,##0.00)" }
+ };
+
+ /*************************************************************************/
+
+ /**
+ * This method returns the object array of key, value pairs containing
+ * the data for this bundle.
+ *
+ * @return The key, value information.
+ */
+ public Object[][] getContents ()
+ {
+ return contents;
+ }
+}
/* LocaleInformation_nl.java -- Dutch locale data
- Copyright (C) 1999 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
* This is the same rule as used in the English locale.
*/
private static final String collation_rules =
- "-<0,1<2<3<4<5<6<7<8<9A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<j,K" +
+ "<0<1<2<3<4<5<6<7<8<9<A,a<b,B<c,C<d,D<e,E<f,F<g,G<h,H<i,I<j,J<k,K" +
"<l,L<m,M<n,N<o,O<p,P<q,Q<r,R<s,S<t,T<u,U<v,V<w,W<x,X<y,Y,z<Z";
-/*
- * For the followings lists, strings that are subsets of other break strings
- * must be listed first. For example, if "\r" and "\r\n" are sequences,
- * the "\r" must be first or it will never be used.
- */
-
-/**
- * This is the list of word separator characters used by
- * java.text.BreakIterator
- * <p>
- * This is the same list as used in the English local
- */
-private static final String[] word_breaks = { " ", "\t", "\r\n", "\n" };
-
-/**
- * This is the list of sentence break sequences used by
- * java.text.BreakIterator
- * <p>
- * This is the same list as used in the English local
- */
-private static final String[] sentence_breaks = { ". " };
-
-/**
- * This is the list of potential line break locations.
- * <p>
- * This is the same list as used in the English local
- */
-private static final String[] line_breaks = { "\t", "-", "\r\n",
- "\n", ". ", ". ", ".", "? ", "? ", "?", "! ", "! ", "!", ", ", " " };
-
/**
* This is the list of months, fully spelled out
*/
{
// For RuleBasedCollator
{ "collation_rules", collation_rules },
- // For BreakIterator
- { "word_breaks", word_breaks },
- { "sentence_breaks", sentence_breaks },
- { "line_breaks", line_breaks },
// For SimpleDateFormat/DateFormatSymbols
{ "months", months },
{ "shortMonths", shortMonths },
--- /dev/null
+/* BaseBreakIterator.java -- Base class for default BreakIterators
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.text;
+
+import java.text.BreakIterator;
+import java.text.CharacterIterator;
+
+/**
+ * @author Tom Tromey <tromey@cygnus.com>
+ * @date March 22, 1999
+ */
+
+public abstract class BaseBreakIterator extends BreakIterator
+{
+ public int current ()
+ {
+ return iter.getIndex();
+ }
+
+ public int first ()
+ {
+ iter.first();
+ return iter.getBeginIndex();
+ }
+
+ public int following (int pos)
+ {
+ int save = iter.getIndex();
+ iter.setIndex(pos);
+ int r = next ();
+ iter.setIndex(save);
+ return r;
+ }
+
+ public CharacterIterator getText ()
+ {
+ return iter;
+ }
+
+ public int last ()
+ {
+ iter.last();
+ // Go past the last character.
+ iter.next();
+ return iter.getEndIndex();
+ }
+
+ public int next (int n)
+ {
+ int r = iter.getIndex ();
+ if (n > 0)
+ {
+ while (n > 0 && r != DONE)
+ {
+ r = next ();
+ --n;
+ }
+ }
+ else if (n < 0)
+ {
+ while (n < 0 && r != DONE)
+ {
+ r = previous ();
+ ++n;
+ }
+ }
+ return r;
+ }
+
+ public void setText (CharacterIterator newText)
+ {
+ iter = newText;
+ }
+
+ protected CharacterIterator iter;
+}
-// Default character BreakIterator.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
+/* CharacterBreakIterator.java - Default character BreakIterator.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
-// Default word BreakIterator.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
+/* LineBreakIterator.java - Default word BreakIterator.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
-// Default sentence BreakIterator.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
+/* SentenceBreakIterator.java - Default sentence BreakIterator.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
-// Default word BreakIterator.
-
-/* Copyright (C) 1999 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
-
-package gnu.gcj.text;
+/* WordBreakIterator.java - Default word BreakIterator.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package gnu.java.text;
import java.text.BreakIterator;
import java.text.CharacterIterator;
--- /dev/null
+/* Annotation.java -- Wrapper for a text attribute object
+ Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.text;
+
+/**
+ * This class is used as a wrapper for a text attribute object. Annotation
+ * objects are associated with a specific range of text. Changing either
+ * the text range or the underlying text invalidates the object.
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public class Annotation
+{
+
+/*
+ * Instance Variables
+ */
+
+/**
+ * This is the attribute object being wrappered
+ */
+private Object attrib;
+
+/*************************************************************************/
+
+/**
+ * Constructors
+ */
+
+/**
+ * This method initializes a new instance of <code>Annotation</code> to
+ * wrapper the specified text attribute object.
+ *
+ * @param attrib The text attribute <code>Object</code> to wrapper.
+ */
+public
+Annotation(Object attrib)
+{
+ this.attrib = attrib;
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
+ */
+
+/**
+ * This method returns the text attribute object this <code>Annotation</code>
+ * instance is wrappering.
+ *
+ * @return The text attribute object for this <code>Annotation</code>.
+ */
+public Object
+getValue()
+{
+ return(attrib);
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns a <code>String</code> representation of this
+ * object.
+ *
+ * @return This object as a <code>String</code>.
+ */
+public String
+toString()
+{
+ return(getClass().getName() + "[value=" + attrib.toString() + "]");
+}
+
+} // class Annotation
+
--- /dev/null
+/* AttributedCharacterIterator.java -- Iterate over attributes
+ Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.text;
+
+import java.io.Serializable;
+import java.io.InvalidObjectException;
+import java.util.Set;
+import java.util.Map;
+
+/**
+ * This interface extends the <code>CharacterIterator</code> interface
+ * in order to support iteration over character attributes as well as
+ * over the characters themselves.
+ * <p>
+ * In addition to attributes of specific characters, this interface
+ * supports the concept of the "attribute run", which is an attribute
+ * that is defined for a particular value across an entire range of
+ * characters or which is undefined over a range of characters.
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public interface AttributedCharacterIterator extends CharacterIterator
+{
+
+/*
+ * Inner Classes
+ */
+
+/**
+ * This class defines attribute keys that are used as text attributes.
+ */
+public static class Attribute implements Serializable
+{
+
+/*************************************************************************/
+
+/*
+ * Static Variables
+ */
+
+/**
+ * This is the attribute for the language of the text. The value of
+ * attributes of this key type are instances of <code>Locale</code>.
+ */
+public static final Attribute LANGUAGE = new Attribute("LANGUAGE");
+
+/**
+ * This is the attribute for the reading form of text. This is used
+ * for storing pronunciation along with the written text for languages
+ * which need it. The value of attributes of this key type are
+ * instances of <code>Annotation</code> which wrappers a <code>String</code>.
+ */
+public static final Attribute READING = new Attribute("READING");
+
+/**
+ * This is the attribute for input method segments. The value of attributes
+ * of this key type are instances of <code>Annotation</code> which wrapper
+ * a <code>String</code>.
+ */
+public static final Attribute INPUT_METHOD_SEGMENT =
+ new Attribute("INPUT_METHOD_SEGMENT");
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
+ */
+
+/**
+ * This is the name of the attribute key
+ * @serial
+ */
+private String name;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+/**
+ * This method initializes a new instance of this class with the specified
+ * name.
+ *
+ * @param name The name of this attribute key.
+ */
+protected
+Attribute(String name)
+{
+ this.name = name;
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+/**
+ * This method returns the name of this attribute.
+ *
+ * @return The attribute name
+ */
+protected String
+getName()
+{
+ return(name);
+}
+
+/*************************************************************************/
+
+/**
+ * This method resolves an instance of <code>AttributedCharacterIterator.Attribute</code>
+ * that is being deserialized to one of the three pre-defined attribute
+ * constants. It does this by comparing the names of the attributes. The
+ * constant that the deserialized object resolves to is returned.
+ *
+ * @return The resolved contant value
+ *
+ * @exception InvalidObjectException If the object being deserialized cannot be resolved.
+ */
+protected Object
+readResolve() throws InvalidObjectException
+{
+ if (this.equals(READING))
+ return(READING);
+
+ if (this.equals(LANGUAGE))
+ return(LANGUAGE);
+
+ if (this.equals(INPUT_METHOD_SEGMENT))
+ return(INPUT_METHOD_SEGMENT);
+
+ throw new InvalidObjectException("Can't resolve Attribute: " + getName());
+}
+
+/*************************************************************************/
+
+/**
+ * This method tests this object for equality against the specified object.
+ * The two objects will be considered equal if and only if:
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>AttributedCharacterIterator.Attribute</code>.
+ * <li>The specified object has the same attribute name as this object.
+ * </ul>
+ *
+ * @param The <code>Object</code> to test for equality against this object.
+ *
+ * @return <code>true</code> if the specified object is equal to this one, <code>false</code> otherwise.
+ */
+public final boolean
+equals(Object obj)
+{
+ if (obj == this)
+ return(true);
+ else
+ return(false);
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns a hash value for this object.
+ *
+ * @return A hash value for this object.
+ */
+public final int
+hashCode()
+{
+ return(super.hashCode());
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns a <code>String</code> representation of this object.
+ *
+ * @return A <code>String</code> representation of this object.
+ */
+public String
+toString()
+{
+ return(getClass().getName() + "(" + getName() + ")");
+}
+
+} // Inner class Attribute
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+/**
+ * This method returns a list of all keys that are defined for the
+ * text range. This can be an empty list if no attributes are defined.
+ *
+ * @return A list of keys
+ */
+public abstract Set
+getAllAttributeKeys();
+
+/*************************************************************************/
+
+/**
+ * This method returns a <code>Map</code> of the attributed defined for
+ * the current character.
+ *
+ * @return A <code>Map</code> of the attributes for the current character.
+ */
+public abstract Map
+getAttributes();
+
+/*************************************************************************/
+
+/**
+ * This method returns the value of the specified attribute for the
+ * current character. If the attribute is not defined for the current
+ * character, <code>null</code> is returned.
+ *
+ * @param attrib The attribute to retrieve the value of.
+ *
+ * @return The value of the specified attribute
+ */
+public abstract Object
+getAttribute(AttributedCharacterIterator.Attribute attrib);
+
+/*************************************************************************/
+
+/**
+ * This method returns the index of the first character in the run that
+ * contains all attributes defined for the current character.
+ *
+ * @return The start index of the run
+ */
+public abstract int
+getRunStart();
+
+/*************************************************************************/
+
+/**
+ * This method returns the index of the first character in the run that
+ * contains all attributes in the specified <code>Set</code> defined for
+ * the current character.
+ *
+ * @param attribs The <code>Set</code> of attributes.
+ *
+ * @return The start index of the run.
+ */
+public abstract int
+getRunStart(Set attribs);
+
+/*************************************************************************/
+
+/**
+ * This method returns the index of the first character in the run that
+ * contains the specified attribute defined for the current character.
+ *
+ * @param attrib The attribute.
+ *
+ * @return The start index of the run.
+ */
+public abstract int
+getRunStart(AttributedCharacterIterator.Attribute attrib);
+
+/*************************************************************************/
+
+/**
+ * This method returns the index of the character after the end of the run
+ * that contains all attributed defined for the current character.
+ *
+ * @return The end index of the run.
+ */
+public abstract int
+getRunLimit();
+
+/*************************************************************************/
+
+/**
+ * This method returns the index of the character after the end of the run
+ * that contains all attributes in the specified <code>Set</code> defined
+ * for the current character.
+ *
+ * @param attribs The <code>Set</code> of attributes.
+ *
+ * @return The end index of the run.
+ */
+public abstract int
+getRunLimit(Set attribs);
+
+/*************************************************************************/
+
+/**
+ * This methods returns the index of the character after the end of the run
+ * that contains the specified attribute defined for the current character.
+ *
+ * @param attrib The attribute.
+ *
+ * @return The end index of the run.
+ */
+public abstract int
+getRunLimit(AttributedCharacterIterator.Attribute attrib);
+
+} // interface AttributedCharacterIterator
+
--- /dev/null
+/* AttributedString.java -- Models text with attributes
+ Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.text;
+
+import java.util.Iterator;
+import java.util.Hashtable;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * This class models a <code>String</code> with attributes over various
+ * subranges of the string. It allows applications to access this
+ * information via the <code>AttributedCharcterIterator</code> interface.
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+public class AttributedString
+{
+
+/*************************************************************************/
+
+/*
+ * Inner Classes
+ */
+
+/**
+ * This class contains the attributes and ranges of text over which
+ * that attributes apply.
+ */
+final class AttributeRange
+{
+
+/*
+ * Instance Variables
+ */
+
+/**
+ * A Map of the attributes
+ */
+Map attribs;
+
+/**
+ * The beginning index of the attributes
+ */
+int begin_index;
+
+/**
+ * The ending index of the attributes
+ */
+int end_index;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+AttributeRange(Map attribs, int begin_index, int end_index)
+{
+ this.attribs = attribs;
+ this.begin_index = begin_index;
+ this.end_index = end_index;
+}
+
+} // Inner class AttributeRange
+
+/*************************************************************************/
+
+/*
+ * Instance Variables
+ */
+
+/**
+ * This object holds the string we are representing.
+ */
+private StringCharacterIterator sci;
+
+/**
+ * This is the attribute information
+ */
+private AttributeRange[] attribs;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+/**
+ * This method initializes a new instance of <code>AttributedString</code>
+ * that represents the specified <code>String</code> with no attributes.
+ *
+ * @param str The <code>String</code> to be attributed.
+ */
+public
+AttributedString(String str)
+{
+ sci = new StringCharacterIterator(str);
+ attribs = new AttributeRange[0];
+}
+
+/*************************************************************************/
+
+/**
+ * This method initializes a new instance of <code>AttributedString</code>
+ * that represents that specified <code>String</code> with the specified
+ * attributes over the entire length of the <code>String</code>.
+ *
+ * @param str The <code>String</code> to be attributed.
+ * @param attributes The attribute list.
+ */
+public
+AttributedString(String str, Map attributes)
+{
+ this(str);
+
+ attribs = new AttributeRange[1];
+ attribs[0] = new AttributeRange(attributes, 0, str.length());
+}
+
+/*************************************************************************/
+
+/**
+ * This method initializes a new instance of <code>AttributedString</code>
+ * that will use the text and attribute information from the specified
+ * <code>AttributedCharacterIterator</code>.
+ *
+ * @param aci The <code>AttributedCharacterIterator</code> containing the text and attribute information.
+ */
+public
+AttributedString(AttributedCharacterIterator aci)
+{
+ this(aci, aci.getBeginIndex(), aci.getEndIndex(), null);
+}
+
+/*************************************************************************/
+
+/**
+ * This method initializes a new instance of <code>AttributedString</code>
+ * that will use the text and attribute information from the specified
+ * subrange of the specified <code>AttributedCharacterIterator</code>.
+ *
+ * @param aci The <code>AttributedCharacterIterator</code> containing the text and attribute information.
+ * @param begin_index The beginning index of the text subrange.
+ * @param end_index The ending index of the text subrange.
+ */
+public
+AttributedString(AttributedCharacterIterator aci, int begin_index,
+ int end_index)
+{
+ this(aci, begin_index, end_index, null);
+}
+
+/*************************************************************************/
+
+/**
+ * This method initializes a new instance of <code>AttributedString</code>
+ * that will use the text and attribute information from the specified
+ * subrange of the specified <code>AttributedCharacterIterator</code>.
+ * Only attributes from the source iterator that are present in the
+ * specified array of attributes will be included in the attribute list
+ * for this object.
+ *
+ * @param aci The <code>AttributedCharacterIterator</code> containing the text and attribute information.
+ * @param begin_index The beginning index of the text subrange.
+ * @param end_index The ending index of the text subrange.
+ * @param attributes A list of attributes to include from the iterator, or <code>null</code> to include all attributes.
+ */
+public
+AttributedString(AttributedCharacterIterator aci, int begin_index,
+ int end_index, AttributedCharacterIterator.Attribute[] attributes)
+{
+ // Validate some arguments
+ if ((begin_index < 0) || (end_index < begin_index))
+ throw new IllegalArgumentException("Bad index values");
+
+ StringBuffer sb = new StringBuffer("");
+
+ // Get the valid attribute list
+ Set all_attribs = aci.getAllAttributeKeys();
+ if (attributes != null)
+ {
+ Set valid_attribs = new HashSet();
+ Iterator iter = all_attribs.iterator();
+ while (iter.hasNext())
+ {
+ Object obj = iter.next();
+
+ int i;
+ for (i = 0; i < attributes.length; i++)
+ if (obj.equals(attributes[0]))
+ break;
+
+ if (i == attributes.length)
+ continue;
+
+ valid_attribs.add(obj);
+ }
+
+ all_attribs = valid_attribs;
+ }
+
+ // Loop through and extract the attributes
+ char c = aci.setIndex(begin_index);
+
+ do
+ {
+ sb.append(c);
+
+ Iterator iter = all_attribs.iterator();
+ while(iter.hasNext())
+ {
+ Object obj = iter.next();
+
+ // What should we do if this is not true?
+ if (!(obj instanceof AttributedCharacterIterator.Attribute))
+ continue;
+
+ AttributedCharacterIterator.Attribute attrib =
+ (AttributedCharacterIterator.Attribute)obj;
+
+ // Make sure the attribute is defined.
+ int rl = aci.getRunLimit(attrib);
+ if (rl == -1)
+ continue;
+ if (rl > end_index)
+ rl = end_index;
+ rl -= begin_index;
+
+ // Check to see if we already processed this one
+ int rs = aci.getRunStart(attrib);
+ if ((rs < aci.getIndex()) && (aci.getIndex() != begin_index))
+ continue;
+
+ // If the attribute run starts before the beginning index, we
+ // need to junk it if it is an Annotation.
+ Object attrib_obj = aci.getAttribute(attrib);
+ if (rs < begin_index)
+ {
+ if (attrib_obj instanceof Annotation)
+ continue;
+
+ rs = begin_index;
+ }
+ else
+ {
+ rs -= begin_index;
+ }
+
+ // Create a map object. Yes this will only contain one attribute
+ Map new_map = new Hashtable();
+ new_map.put(attrib, attrib_obj);
+
+ // Add it to the attribute list. Yes this is a bad way to do things.
+ AttributeRange[] new_list = new AttributeRange[attribs.length + 1];
+ System.arraycopy(attribs, 0, new_list, 0, attribs.length);
+ attribs = new_list;
+ attribs[attribs.length - 1] = new AttributeRange(new_map, rs, rl);
+ }
+
+ c = aci.next();
+ }
+ while(c != CharacterIterator.DONE);
+
+ sci = new StringCharacterIterator(sb.toString());
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+/**
+ * This method adds a new attribute that will cover the entire string.
+ *
+ * @param attrib The attribute to add.
+ * @param value The value of the attribute.
+ */
+public void
+addAttribute(AttributedCharacterIterator.Attribute attrib, Object value)
+{
+ addAttribute(attrib, value, 0, sci.getEndIndex() - 1);
+}
+
+/*************************************************************************/
+
+/**
+ * This method adds a new attribute that will cover the specified subrange
+ * of the string.
+ *
+ * @param attrib The attribute to add.
+ * @param value The value of the attribute.
+ * @param begin_index The beginning index of the subrange.
+ * @param end_index The ending index of the subrange.
+ *
+ * @exception IllegalArgumentException If attribute is <code>null</code> or the subrange is not valid.
+ */
+public void
+addAttribute(AttributedCharacterIterator.Attribute attrib, Object value,
+ int begin_index, int end_index)
+{
+ if (attrib == null)
+ throw new IllegalArgumentException("null attribute");
+
+ Hashtable ht = new Hashtable();
+ ht.put(attrib, value);
+
+ addAttributes(ht, begin_index, end_index);
+}
+
+/*************************************************************************/
+
+/**
+ * This method adds all of the attributes in the specified list to the
+ * specified subrange of the string.
+ *
+ * @param attributes The list of attributes.
+ * @param begin_index The beginning index.
+ * @param end_index The ending index
+ *
+ * @param IllegalArgumentException If the list is <code>null</code> or the subrange is not valid.
+ */
+public void
+addAttributes(Map attributes, int begin_index, int end_index)
+{
+ if (attributes == null)
+ throw new IllegalArgumentException("null attribute");
+
+ if ((begin_index < 0) || (end_index > sci.getEndIndex()) ||
+ (end_index < begin_index))
+ throw new IllegalArgumentException("bad range");
+
+ AttributeRange[] new_list = new AttributeRange[attribs.length + 1];
+ System.arraycopy(attribs, 0, new_list, 0, attribs.length);
+ attribs = new_list;
+ attribs[attribs.length - 1] = new AttributeRange(attributes, begin_index,
+ end_index);
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns an <code>AttributedCharacterIterator</code> that
+ * will iterate over the entire string.
+ *
+ * @return An <code>AttributedCharacterIterator</code> for the entire string.
+ */
+public AttributedCharacterIterator
+getIterator()
+{
+ return(new AttributedStringIterator(sci, attribs, 0, sci.getEndIndex() - 1,
+ null));
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns an <code>AttributedCharacterIterator</code> that
+ * will iterate over the entire string. This iterator will return information
+ * about the list of attributes in the specified array. Attributes not in
+ * the array may or may not be returned by the iterator. If the specified
+ * array is <code>null</code>, all attributes will be returned.
+ *
+ * @param attributes A list of attributes to include in the returned iterator.
+ *
+ * @return An <code>AttributedCharacterIterator</code> for this string.
+ */
+public AttributedCharacterIterator
+getIterator(AttributedCharacterIterator.Attribute[] attributes)
+{
+ return(getIterator(attributes, 0, sci.getEndIndex() - 1));
+}
+
+/*************************************************************************/
+
+/**
+ * This method returns an <code>AttributedCharacterIterator</code> that
+ * will iterate over the specified subrange. This iterator will return information
+ * about the list of attributes in the specified array. Attributes not in
+ * the array may or may not be returned by the iterator. If the specified
+ * array is <code>null</code>, all attributes will be returned.
+ *
+ * @param attributes A list of attributes to include in the returned iterator.
+ * @param begin_index The beginning index of the subrange.
+ * @param end_index The ending index of the subrange.
+ *
+ * @return An <code>AttributedCharacterIterator</code> for this string.
+ */
+public AttributedCharacterIterator
+getIterator(AttributedCharacterIterator.Attribute[] attributes,
+ int begin_index, int end_index)
+{
+ if ((begin_index < 0) || (end_index > sci.getEndIndex()) ||
+ (end_index < begin_index))
+ throw new IllegalArgumentException("bad range");
+
+ return(new AttributedStringIterator(sci, attribs, begin_index, end_index,
+ attributes));
+}
+
+} // class AttributedString
+
--- /dev/null
+/* AttributedStringIterator.java -- Class to iterate over AttributedString
+ Copyright (C) 1998, 1999 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
+
+
+package java.text;
+
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * This class implements the AttributedCharacterIterator interface. It
+ * is used by AttributedString.getIterator().
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
+class AttributedStringIterator implements AttributedCharacterIterator
+{
+
+/*************************************************************************/
+
+/**
+ * Instance Variables
+ */
+
+/**
+ * The character iterator containing the text
+ */
+private CharacterIterator ci;
+
+/**
+ * The list of attributes and ranges
+ */
+private AttributedString.AttributeRange[] attribs;
+
+/**
+ * The list of attributes that the user is interested in. We may,
+ * at our option, not return any other attributes.
+ */
+private AttributedCharacterIterator.Attribute[] restricts;
+
+/*************************************************************************/
+
+/*
+ * Constructors
+ */
+
+AttributedStringIterator(StringCharacterIterator sci,
+ AttributedString.AttributeRange[] attribs,
+ int begin_index, int end_index,
+ AttributedCharacterIterator.Attribute[] restricts)
+{
+ this.ci = new StringCharacterIterator(sci, begin_index, end_index);
+ this.attribs = attribs;
+ this.restricts = restricts;
+}
+
+/*************************************************************************/
+
+/*
+ * Instance Methods
+ */
+
+// First we have a bunch of stupid redirects. If StringCharacterIterator
+// weren't final, I just would have extended that for this class. Alas, no.
+
+public Object
+clone()
+{
+ return(ci.clone());
+}
+
+public char
+current()
+{
+ return(ci.current());
+}
+
+public char
+next()
+{
+ return(ci.next());
+}
+
+public char
+previous()
+{
+ return(ci.previous());
+}
+
+public char
+first()
+{
+ return(ci.first());
+}
+
+public char
+last()
+{
+ return(ci.last());
+}
+
+public int
+getIndex()
+{
+ return(ci.getIndex());
+}
+
+public char
+setIndex(int index)
+{
+ return(ci.setIndex(index));
+}
+
+public int
+getBeginIndex()
+{
+ return(ci.getBeginIndex());
+}
+
+public int
+getEndIndex()
+{
+ return(ci.getEndIndex());
+}
+
+/*
+ * Here is where the AttributedCharacterIterator methods start.
+ */
+
+/*************************************************************************/
+
+/**
+ * Returns a list of all the attribute keys that are defined anywhere
+ * on this string.
+ */
+public Set
+getAllAttributeKeys()
+{
+ HashSet s = new HashSet();
+ if (attribs == null)
+ return(s);
+
+ for (int i = 0; i < attribs.length; i++)
+ {
+ Set key_set = attribs[i].attribs.keySet();
+ Iterator iter = key_set.iterator();
+ while (iter.hasNext())
+ {
+ s.add(iter.next());
+ }
+ }
+
+ return(s);
+}
+
+/*************************************************************************/
+
+/**
+ * Various methods that determine how far the run extends for various
+ * attribute combinations.
+ */
+
+public int
+getRunLimit()
+{
+ return(getRunLimit(getAttributes().keySet()));
+}
+
+public int
+getRunLimit(AttributedCharacterIterator.Attribute attrib)
+{
+ HashSet s = new HashSet();
+ s.add(attrib);
+
+ return(getRunLimit(s));
+}
+
+public synchronized int
+getRunLimit(Set attribute_set)
+{
+ int orig_index = ci.getIndex();
+ int run_limit;
+
+ do
+ {
+ run_limit = ci.getIndex();
+
+ Map attribute_map = getAttributes();
+
+ boolean found = false;
+ Iterator iter = attribute_set.iterator();
+ while(iter.hasNext())
+ if (!attribute_map.containsKey(iter.next()))
+ {
+ found = true;
+ break;
+ }
+
+ if (found)
+ break;
+ }
+ while (ci.next() != CharacterIterator.DONE);
+
+ boolean hit_end = (ci.previous() == CharacterIterator.DONE);
+
+ ci.setIndex(orig_index);
+
+ if (run_limit == orig_index)
+ return(-1); // No characters match the given attributes
+// else if (!hit_end)
+// --run_limit;
+
+ return(run_limit);
+}
+
+/*************************************************************************/
+
+/**
+ * Various methods that determine where the run begins for various
+ * attribute combinations.
+ */
+
+public int
+getRunStart()
+{
+ return(getRunStart(getAttributes().keySet()));
+}
+
+public int
+getRunStart(AttributedCharacterIterator.Attribute attrib)
+{
+ HashSet s = new HashSet();
+ s.add(attrib);
+
+ return(getRunStart(s));
+}
+
+public int
+getRunStart(Set attribute_set)
+{
+ int orig_index = ci.getIndex();
+ int run_start;
+
+ do
+ {
+ run_start = ci.getIndex();
+
+ Map attribute_map = getAttributes();
+
+ Iterator iter = attribute_set.iterator();
+ while(iter.hasNext())
+ if (!attribute_map.containsKey(iter.next()))
+ break;
+
+ if (iter.hasNext())
+ break;
+ }
+ while (ci.previous() != CharacterIterator.DONE);
+
+ boolean hit_beginning = (ci.previous() == CharacterIterator.DONE);
+
+ ci.setIndex(orig_index);
+
+ if (run_start == orig_index)
+ return(-1); // No characters match the given attributes
+ else if (!hit_beginning)
+ ++run_start;
+
+ return(run_start);
+}
+
+/*************************************************************************/
+
+public Object
+getAttribute(AttributedCharacterIterator.Attribute attrib)
+{
+ if (attribs == null)
+ return(null);
+
+ for (int i = 0; i < attribs.length; i++)
+ {
+ Set key_set = attribs[i].attribs.keySet();
+ Iterator iter = key_set.iterator();
+ while (iter.hasNext())
+ {
+ Object obj = iter.next();
+
+ // Check for attribute match and range match
+ if (obj.equals(attrib))
+ if ((ci.getIndex() >= attribs[i].begin_index) &&
+ (ci.getIndex() <= attribs[i].end_index))
+ return(attribs[i].attribs.get(obj));
+ }
+ }
+
+ return(null);
+}
+
+/*************************************************************************/
+
+/**
+ * Return a list of all the attributes and values defined for this
+ * character
+ */
+public Map
+getAttributes()
+{
+ HashMap m = new HashMap();
+ if (attribs == null)
+ return(m);
+
+ for (int i = 0; i < attribs.length; i++)
+ {
+ if ((ci.getIndex() >= attribs[i].begin_index) &&
+ (ci.getIndex() <= attribs[i].end_index))
+ m.putAll(attribs[i].attribs);
+ }
+
+ return(m);
+}
+
+} // class AttributedStringIterator
+
-// BreakIterator.java - Iterate over logical breaks in text.
+/* BreakIterator.java -- Breaks text into elements
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
import java.util.ResourceBundle;
/**
+ * This class iterates over text elements such as words, lines, sentences,
+ * and characters. It can only iterate over one of these text elements at
+ * a time. An instance of this class configured for the desired iteration
+ * type is created by calling one of the static factory methods, not
+ * by directly calling a constructor.
+ *
* @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @date March 19, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct to 1.1.
*/
-
public abstract class BreakIterator implements Cloneable
{
+ /**
+ * This value is returned by the <code>next()</code> and
+ * <code>previous</code> in order to indicate that the end of the
+ * text has been reached.
+ */
// The value was discovered by writing a test program.
public static final int DONE = -1;
+ /**
+ * This method initializes a new instance of <code>BreakIterator</code>.
+ * This protected constructor is available to subclasses as a default
+ * no-arg superclass constructor.
+ */
protected BreakIterator ()
{
}
+ /**
+ * This method returns the index of the current text element boundary.
+ *
+ * @return The current text boundary.
+ */
public abstract int current ();
+
+ /**
+ * This method returns the first text element boundary in the text being
+ * iterated over.
+ *
+ * @return The first text boundary.
+ */
public abstract int first ();
+
+ /**
+ * This methdod returns the offset of the text element boundary following
+ * the specified offset.
+ *
+ * @param offset The text index from which to find the next text boundary.
+ *
+ * @param The next text boundary following the specified index.
+ */
public abstract int following (int pos);
+ /**
+ * This method returns a list of locales for which instances of
+ * <code>BreakIterator</code> are available.
+ *
+ * @return A list of available locales
+ */
public static synchronized Locale[] getAvailableLocales ()
{
- // FIXME.
- return null;
+ Locale[] l = new Locale[1];
+ l[0] = Locale.US;
+ return l;
}
private static BreakIterator getInstance (String type, Locale loc)
try
{
ResourceBundle res
- = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
+ = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc);
className = res.getString(type);
}
catch (MissingResourceException x)
}
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over characters as defined in the default locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getCharacterInstance ()
{
return getCharacterInstance (Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over characters as defined in the specified locale. If the
+ * desired locale is not available, the default locale is used.
+ *
+ * @param locale The desired locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getCharacterInstance (Locale loc)
{
BreakIterator r = getInstance ("CharacterIterator", loc);
if (r == null)
- r = new gnu.gcj.text.CharacterBreakIterator ();
+ r = new gnu.java.text.CharacterBreakIterator ();
return r;
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over line breaks as defined in the default locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getLineInstance ()
{
return getLineInstance (Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over line breaks as defined in the specified locale. If the
+ * desired locale is not available, the default locale is used.
+ *
+ * @param locale The desired locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getLineInstance (Locale loc)
{
BreakIterator r = getInstance ("LineIterator", loc);
if (r == null)
- r = new gnu.gcj.text.LineBreakIterator ();
+ r = new gnu.java.text.LineBreakIterator ();
return r;
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over sentences as defined in the default locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getSentenceInstance ()
{
return getSentenceInstance (Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over sentences as defined in the specified locale. If the
+ * desired locale is not available, the default locale is used.
+ *
+ * @param locale The desired locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getSentenceInstance (Locale loc)
{
BreakIterator r = getInstance ("SentenceIterator", loc);
if (r == null)
- r = new gnu.gcj.text.SentenceBreakIterator ();
+ r = new gnu.java.text.SentenceBreakIterator ();
return r;
}
+ /**
+ * This method returns the text this object is iterating over as a
+ * <code>CharacterIterator</code>.
+ *
+ * @param The text being iterated over.
+ */
public abstract CharacterIterator getText ();
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over words as defined in the default locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getWordInstance ()
{
return getWordInstance (Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>BreakIterator</code> that will
+ * iterate over words as defined in the specified locale. If the
+ * desired locale is not available, the default locale is used.
+ *
+ * @param locale The desired locale.
+ *
+ * @return A <code>BreakIterator</code> instance for the default locale.
+ */
public static BreakIterator getWordInstance (Locale loc)
{
BreakIterator r = getInstance ("WordIterator", loc);
if (r == null)
- r = new gnu.gcj.text.WordBreakIterator ();
+ r = new gnu.java.text.WordBreakIterator ();
return r;
}
+ /**
+ * This method tests whether or not the specified position is a text
+ * element boundary.
+ *
+ * @param offset The text position to test.
+ *
+ * @return <code>true</code> if the position is a boundary,
+ * <code>false</code> otherwise.
+ */
public boolean isBoundary (int pos)
{
if (pos == 0)
return following (pos - 1) == pos;
}
+ /**
+ * This method returns the last text element boundary in the text being
+ * iterated over.
+ *
+ * @return The last text boundary.
+ */
public abstract int last ();
+
+ /**
+ * This method returns the text element boundary following the current
+ * text position.
+ *
+ * @return The next text boundary.
+ */
public abstract int next ();
+
+ /**
+ * This method returns the n'th text element boundary following the current
+ * text position.
+ *
+ * @param n The number of text element boundaries to skip.
+ *
+ * @return The next text boundary.
+ */
public abstract int next (int n);
+ /**
+ * This methdod returns the offset of the text element boundary preceding
+ * the specified offset.
+ *
+ * @param offset The text index from which to find the preceding
+ * text boundary.
+ *
+ * @returns The next text boundary preceding the specified index.
+ */
public int preceding (int pos)
{
if (following (pos) == DONE)
return current ();
}
+ /**
+ * This method returns the text element boundary preceding the current
+ * text position.
+ *
+ * @return The previous text boundary.
+ */
public abstract int previous ();
+ /**
+ * This method sets the text string to iterate over.
+ *
+ * @param str The <code>String</code> to iterate over.
+ */
public void setText (String newText)
{
setText (new StringCharacterIterator (newText));
}
+ /**
+ * This method sets the text to iterate over from the specified
+ * <code>CharacterIterator</code>.
+ *
+ * @param ci The desired <code>CharacterIterator</code>.
+ */
public abstract void setText (CharacterIterator newText);
}
-// CharacterIterator.java - Protocol for iterating over Unicode characters.
+/* CharacterIterator.java -- Iterate over a character range
+ Copyright (C) 1998, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
/**
- * @author Tom Tromey <tromey@cygnus.com>
- * @date February 22, 1999
- */
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct to 1.1.
- */
-
+ * This interface defines a mechanism for iterating over a range of
+ * characters. For a given range of text, a beginning and ending index,
+ * as well as a current index are defined. These values can be queried
+ * by the methods in this interface. Additionally, various methods allow
+ * the index to be set.
+ *
+ * @version 0.0
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ */
public interface CharacterIterator extends Cloneable
{
- public abstract Object clone ();
+
+ /*************************************************************************/
+
+ /*
+ * Static Variables
+ */
+
+ /**
+ * This is a special constant value that is returned when the beginning or
+ * end of the character range has been reached.
+ */
+ public static final char DONE = '\uFFFF';
+
+ /*************************************************************************/
+
+ /*
+ * Instance Methods
+ */
+
+ /**
+ * This method returns the character at the current index position
+ *
+ * @return The character at the current index position.
+ */
public abstract char current ();
+
+ /*************************************************************************/
+
+ /**
+ * This method increments the current index and then returns the character
+ * at the new index value. If the index is already at <code>getEndIndex() - 1</code>,
+ * it will not be incremented.
+ *
+ * @return The character at the position of the incremented index value, or <code>DONE</code> if the index has reached getEndIndex() - 1
+ */
+ public abstract char next ();
+
+ /*************************************************************************/
+
+ /**
+ * This method decrements the current index and then returns the character
+ * at the new index value. If the index value is already at the beginning
+ * index, it will not be decremented.
+ *
+ * @return The character at the position of the decremented index value, or <code>DONE</code> if index was already equal to the beginning index value.
+ */
+ public abstract char previous ();
+
+ /*************************************************************************/
+
+ /**
+ * This method sets the index value to the beginning of the range and returns
+ * the character there.
+ *
+ * @return The character at the beginning of the range, or <code>DONE</code> if the range is empty.
+ */
public abstract char first ();
+
+ /*************************************************************************/
+
+ /**
+ * This method sets the index value to <code>getEndIndex() - 1</code> and
+ * returns the character there. If the range is empty, then the index value
+ * will be set equal to the beginning index.
+ *
+ * @return The character at the end of the range, or <code>DONE</code> if the range is empty.
+ */
+ public abstract char last ();
+
+ /*************************************************************************/
+
+ /**
+ * This method returns the current value of the index.
+ *
+ * @return The current index value
+ */
+ public abstract int getIndex ();
+
+ /*************************************************************************/
+
+ /**
+ * This method sets the value of the index to the specified value, then
+ * returns the character at that position.
+ *
+ * @param index The new index value.
+ *
+ * @return The character at the new index value or <code>DONE</code> if the index value is equal to <code>getEndIndex</code>.
+ */
+ public abstract char setIndex (int index) throws IllegalArgumentException;
+
+ /*************************************************************************/
+
+ /**
+ * This method returns the character position of the first character in the
+ * range.
+ *
+ * @return The index of the first character in the range.
+ */
public abstract int getBeginIndex ();
+
+ /*************************************************************************/
+
+ /**
+ * This method returns the character position of the end of the text range.
+ * This will actually be the index of the first character following the
+ * end of the range. In the event the text range is empty, this will be
+ * equal to the first character in the range.
+ *
+ * @return The index of the end of the range.
+ */
public abstract int getEndIndex ();
- public abstract int getIndex ();
- public abstract char last ();
- public abstract char next ();
- public abstract char previous ();
- public abstract char setIndex (int idx);
- public static final char DONE = '\uffff';
+ /*************************************************************************/
+
+ /**
+ * This method creates a copy of this <code>CharacterIterator</code>.
+ *
+ * @return A copy of this <code>CharacterIterator</code>.
+ */
+ public abstract Object clone ();
}
-// ChoiceFormat.java - Formatter for `switch'-like string substitution.
+/* ChoiceFormat.java -- Format over a range of numbers
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999, 2000 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
import java.util.Vector;
/**
+ * This class allows a format to be specified based on a range of numbers.
+ * To use this class, first specify two lists of formats and range terminators.
+ * These lists must be arrays of equal length. The format of index
+ * <code>i</code> will be selected for value <code>X</code> if
+ * <code>terminator[i] <= X < limit[i + 1]</code>. If the value X is not
+ * included in any range, then either the first or last format will be
+ * used depending on whether the value X falls outside the range.
+ * <p>
+ * This sounds complicated, but that is because I did a poor job of
+ * explaining it. Consider the following example:
+ * <p>
+ * <pre>
+ * terminators = { 1, ChoiceFormat.nextDouble(1) }
+ * formats = { "file", "files" }
+ * </pre>
+ * <p>
+ * In this case if the actual number tested is one or less, then the word
+ * "file" is used as the format value. If the number tested is greater than
+ * one, then "files" is used. This allows plurals to be handled
+ * gracefully. Note the use of the method <code>nextDouble</code>. This
+ * method selects the next highest double number than its argument. This
+ * effectively makes any double greater than 1.0 cause the "files" string
+ * to be selected. (Note that all terminator values are specified as
+ * doubles.
+ * <p>
+ * Note that in order for this class to work properly, the range terminator
+ * array must be sorted in ascending order and the format string array
+ * must be the same length as the terminator array.
+ *
* @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @date March 9, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct to 1.1.
*/
-
public class ChoiceFormat extends NumberFormat
{
- // Note: we assume the same kind of quoting rules apply here.
- // This isn't explicitly documented. But for instance we accept
- // '#' as a literal hash in a format string.
+ /**
+ * This method sets new range terminators and format strings for this
+ * object based on the specified pattern. This pattern is of the form
+ * "term#string|term#string...". For example "1#Sunday|2#Monday|#Tuesday".
+ *
+ * @param pattern The pattern of terminators and format strings.
+ *
+ * @exception IllegalArgumentException If the pattern is not valid
+ */
public void applyPattern (String newPattern)
- {
- int index = 0, max = newPattern.length();
- Vector stringVec = new Vector ();
- Vector limitVec = new Vector ();
- StringBuffer buf = new StringBuffer ();
-
- while (true)
- {
- // Find end of double.
- int dstart = index;
- while (index < max)
- {
- char c = newPattern.charAt(index);
- if (c == '#' || c == '\u2064' || c == '<')
- break;
- ++index;
- }
-
- if (index == max)
- throw new IllegalArgumentException ("unexpected end of text");
- Double d = new Double (newPattern.substring(dstart, index));
-
- if (newPattern.charAt(index) == '<')
- d = new Double (nextDouble (d.doubleValue()));
-
- limitVec.addElement(d);
-
- // Scan text.
- ++index;
- buf.setLength(0);
- while (index < max)
- {
- char c = newPattern.charAt(index);
- if (c == '\'' && index < max + 1
- && newPattern.charAt(index + 1) == '\'')
- {
- buf.append(c);
- ++index;
- }
- else if (c == '\'' && index < max + 2)
- {
- buf.append(newPattern.charAt(index + 1));
- index += 2;
- }
- else if (c == '|')
- break;
- else
+ {
+ // Note: we assume the same kind of quoting rules apply here.
+ // This isn't explicitly documented. But for instance we accept
+ // '#' as a literal hash in a format string.
+ int index = 0, max = newPattern.length();
+ Vector stringVec = new Vector ();
+ Vector limitVec = new Vector ();
+ StringBuffer buf = new StringBuffer ();
+
+ while (true)
+ {
+ // Find end of double.
+ int dstart = index;
+ while (index < max)
+ {
+ char c = newPattern.charAt(index);
+ if (c == '#' || c == '\u2064' || c == '<')
+ break;
+ ++index;
+ }
+
+ if (index == max)
+ throw new IllegalArgumentException ("unexpected end of text");
+ Double d = new Double (newPattern.substring(dstart, index));
+
+ if (newPattern.charAt(index) == '<')
+ d = new Double (nextDouble (d.doubleValue()));
+
+ limitVec.addElement(d);
+
+ // Scan text.
+ ++index;
+ buf.setLength(0);
+ while (index < max)
+ {
+ char c = newPattern.charAt(index);
+ if (c == '\'' && index < max + 1
+ && newPattern.charAt(index + 1) == '\'')
+ {
buf.append(c);
- ++index;
- }
-
- stringVec.addElement(buf.toString());
- if (index == max)
- break;
- ++index;
- }
-
- choiceFormats = new String[stringVec.size()];
- stringVec.copyInto(choiceFormats);
-
- choiceLimits = new double[limitVec.size()];
- for (int i = 0; i < choiceLimits.length; ++i)
- {
- Double d = (Double) limitVec.elementAt(i);
- choiceLimits[i] = d.doubleValue();
- }
- }
-
+ ++index;
+ }
+ else if (c == '\'' && index < max + 2)
+ {
+ buf.append(newPattern.charAt(index + 1));
+ index += 2;
+ }
+ else if (c == '|')
+ break;
+ else
+ buf.append(c);
+ ++index;
+ }
+
+ stringVec.addElement(buf.toString());
+ if (index == max)
+ break;
+ ++index;
+ }
+
+ choiceFormats = new String[stringVec.size()];
+ stringVec.copyInto(choiceFormats);
+
+ choiceLimits = new double[limitVec.size()];
+ for (int i = 0; i < choiceLimits.length; ++i)
+ {
+ Double d = (Double) limitVec.elementAt(i);
+ choiceLimits[i] = d.doubleValue();
+ }
+ }
+
+ /**
+ * This method initializes a new instance of <code>ChoiceFormat</code> that
+ * generates its range terminator and format string arrays from the
+ * specified pattern. This pattern is of the form
+ * "term#string|term#string...". For example "1#Sunday|2#Monday|#Tuesday".
+ * This is the same pattern type used by the <code>applyPattern</code>
+ * method.
+ *
+ * @param pattern The pattern of terminators and format strings.
+ *
+ * @exception IllegalArgumentException If the pattern is not valid
+ */
public ChoiceFormat (String newPattern)
- {
- super ();
- applyPattern (newPattern);
- }
-
+ {
+ super ();
+ applyPattern (newPattern);
+ }
+
+ /**
+ * This method initializes a new instance of <code>ChoiceFormat</code> that
+ * will use the specified range terminators and format strings.
+ *
+ * @param choiceLimits The array of range terminators
+ * @param choiceFormats The array of format strings
+ */
public ChoiceFormat (double[] choiceLimits, String[] choiceFormats)
- {
- super ();
- setChoices (choiceLimits, choiceFormats);
- }
-
- public Object clone ()
- {
- return new ChoiceFormat (choiceLimits, choiceFormats);
- }
-
+ {
+ super ();
+ setChoices (choiceLimits, choiceFormats);
+ }
+
+ /**
+ * This method tests this object for equality with the specified
+ * object. This will be true if and only if:
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>ChoiceFormat</code>.
+ * <li>The termination ranges and format strings are identical to
+ * this object's.
+ * </ul>
+ *
+ * @param obj The object to test for equality against.
+ *
+ * @return <code>true</code> if the specified object is equal to
+ * this one, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
- {
- if (! (obj instanceof ChoiceFormat))
- return false;
- ChoiceFormat cf = (ChoiceFormat) obj;
- if (choiceLimits.length != cf.choiceLimits.length)
- return false;
- for (int i = choiceLimits.length - 1; i >= 0; --i)
- {
- if (choiceLimits[i] != cf.choiceLimits[i]
- || !choiceFormats[i].equals(cf.choiceFormats[i]))
- return false;
- }
- return true;
- }
-
+ {
+ if (! (obj instanceof ChoiceFormat))
+ return false;
+ ChoiceFormat cf = (ChoiceFormat) obj;
+ if (choiceLimits.length != cf.choiceLimits.length)
+ return false;
+ for (int i = choiceLimits.length - 1; i >= 0; --i)
+ {
+ if (choiceLimits[i] != cf.choiceLimits[i]
+ || !choiceFormats[i].equals(cf.choiceFormats[i]))
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * This method appends the appropriate format string to the specified
+ * <code>StringBuffer</code> based on the supplied <code>long</code>
+ * argument.
+ *
+ * @param number The number used for determine (based on the range
+ * terminators) which format string to append.
+ * @param sb The <code>StringBuffer</code> to append the format string to.
+ * @param status Unused.
+ *
+ * @return The <code>StringBuffer</code> with the format string appended.
+ */
public StringBuffer format (long num, StringBuffer appendBuf,
FieldPosition pos)
- {
- return format ((double) num, appendBuf, pos);
- }
-
+ {
+ return format ((double) num, appendBuf, pos);
+ }
+
+ /**
+ * This method appends the appropriate format string to the specified
+ * <code>StringBuffer</code> based on the supplied <code>double</code>
+ * argument.
+ *
+ * @param number The number used for determine (based on the range
+ * terminators) which format string to append.
+ * @param sb The <code>StringBuffer</code> to append the format string to.
+ * @param status Unused.
+ *
+ * @return The <code>StringBuffer</code> with the format string appended.
+ */
public StringBuffer format (double num, StringBuffer appendBuf,
FieldPosition pos)
- {
- if (choiceLimits.length == 0)
- return appendBuf;
-
- int index = 0;
- if (! Double.isNaN(num) && num >= choiceLimits[0])
- {
- for (; index < choiceLimits.length - 1; ++index)
- {
- if (choiceLimits[index] <= num
- && index != choiceLimits.length - 2
- && num < choiceLimits[index + 1])
- break;
- }
- }
-
- return appendBuf.append(choiceFormats[index]);
- }
-
+ {
+ if (choiceLimits.length == 0)
+ return appendBuf;
+
+ int index = 0;
+ if (! Double.isNaN(num) && num >= choiceLimits[0])
+ {
+ for (; index < choiceLimits.length - 1; ++index)
+ {
+ if (choiceLimits[index] <= num
+ && index != choiceLimits.length - 2
+ && num < choiceLimits[index + 1])
+ break;
+ }
+ }
+
+ return appendBuf.append(choiceFormats[index]);
+ }
+
+ /**
+ * This method returns the list of format strings in use.
+ *
+ * @return The list of format objects.
+ */
public Object[] getFormats ()
- {
- return (Object[]) choiceFormats.clone();
- }
-
+ {
+ return (Object[]) choiceFormats.clone();
+ }
+
+ /**
+ * This method returns the list of range terminators in use.
+ *
+ * @return The list of range terminators.
+ */
public double[] getLimits ()
- {
- return (double[]) choiceLimits.clone();
- }
-
+ {
+ return (double[]) choiceLimits.clone();
+ }
+
+ /**
+ * This method returns a hash value for this object
+ *
+ * @return A hash value for this object.
+ */
public int hashCode ()
- {
- int hash = 0;
- for (int i = 0; i < choiceLimits.length; ++i)
- {
- long v = Double.doubleToLongBits(choiceLimits[i]);
- hash ^= (v ^ (v >>> 32));
- hash ^= choiceFormats[i].hashCode();
- }
- return hash;
- }
-
+ {
+ int hash = 0;
+ for (int i = 0; i < choiceLimits.length; ++i)
+ {
+ long v = Double.doubleToLongBits(choiceLimits[i]);
+ hash ^= (v ^ (v >>> 32));
+ hash ^= choiceFormats[i].hashCode();
+ }
+ return hash;
+ }
+
+ /**
+ * This method returns the lowest possible double greater than the
+ * specified double. If the specified double value is equal to
+ * <code>Double.NaN</code> then that is the value returned.
+ *
+ * @param d The specified double
+ *
+ * @return The lowest double value greater than the specified double.
+ */
public static final double nextDouble (double d)
- {
- return nextDouble (d, true);
- }
-
+ {
+ return nextDouble (d, true);
+ }
+
+ /**
+ * This method returns a double that is either the next highest double
+ * or next lowest double compared to the specified double depending on the
+ * value of the passed boolean parameter. If the boolean parameter is
+ * <code>true</code>, then the lowest possible double greater than the
+ * specified double will be returned. Otherwise the highest possible
+ * double less than the specified double will be returned.
+ *
+ * @param d The specified double
+ * @param positive <code>true</code> to return the next highest
+ * double, <code>false</code> otherwise.
+ *
+ * @return The next highest or lowest double value.
+ */
public static double nextDouble (double d, boolean next)
- {
- if (Double.isInfinite(d) || Double.isNaN(d))
- return d;
+ {
+ if (Double.isInfinite(d) || Double.isNaN(d))
+ return d;
- long bits = Double.doubleToLongBits(d);
+ long bits = Double.doubleToLongBits(d);
- long mantMask = (1L << mantissaBits) - 1;
- long mantissa = bits & mantMask;
+ long mantMask = (1L << mantissaBits) - 1;
+ long mantissa = bits & mantMask;
- long expMask = (1L << exponentBits) - 1;
- long exponent = (bits >>> mantissaBits) & expMask;
+ long expMask = (1L << exponentBits) - 1;
+ long exponent = (bits >>> mantissaBits) & expMask;
- if (next ^ (bits < 0)) // Increment magnitude
- {
- if (mantissa == (1L << mantissaBits) - 1)
- {
- mantissa = 0L;
- exponent++;
+ if (next ^ (bits < 0)) // Increment magnitude
+ {
+ if (mantissa == (1L << mantissaBits) - 1)
+ {
+ mantissa = 0L;
+ exponent++;
- // Check for absolute overflow.
- if (exponent >= (1L << mantissaBits))
- return (bits > 0) ? Double.POSITIVE_INFINITY
- : Double.NEGATIVE_INFINITY;
- }
- else
- mantissa++;
- }
- else // Decrement magnitude
- {
- if (exponent == 0L && mantissa == 0L)
- {
- // The only case where there is a change of sign
- return next ? Double.MIN_VALUE : -Double.MIN_VALUE;
- }
- else
- {
- if (mantissa == 0L)
- {
- mantissa = (1L << mantissaBits) - 1;
- exponent--;
- }
- else
- mantissa--;
- }
- }
-
- long result = bits < 0 ? 1 : 0;
- result = (result << exponentBits) | exponent;
- result = (result << mantissaBits) | mantissa;
- return Double.longBitsToDouble(result);
- }
-
+ // Check for absolute overflow.
+ if (exponent >= (1L << mantissaBits))
+ return (bits > 0) ? Double.POSITIVE_INFINITY
+ : Double.NEGATIVE_INFINITY;
+ }
+ else
+ mantissa++;
+ }
+ else // Decrement magnitude
+ {
+ if (exponent == 0L && mantissa == 0L)
+ {
+ // The only case where there is a change of sign
+ return next ? Double.MIN_VALUE : -Double.MIN_VALUE;
+ }
+ else
+ {
+ if (mantissa == 0L)
+ {
+ mantissa = (1L << mantissaBits) - 1;
+ exponent--;
+ }
+ else
+ mantissa--;
+ }
+ }
+
+ long result = bits < 0 ? 1 : 0;
+ result = (result << exponentBits) | exponent;
+ result = (result << mantissaBits) | mantissa;
+ return Double.longBitsToDouble(result);
+ }
+
+ /**
+ * I'm not sure what this method is really supposed to do, as it is
+ * not documented.
+ */
public Number parse (String sourceStr, ParsePosition pos)
- {
- int index = pos.getIndex();
- for (int i = 0; i < choiceLimits.length; ++i)
- {
- if (sourceStr.startsWith(choiceFormats[i], index))
- {
- pos.setIndex(index + choiceFormats[i].length());
- return new Double (choiceLimits[i]);
- }
- }
- pos.setErrorIndex(index);
- return new Double (Double.NaN);
- }
-
+ {
+ int index = pos.getIndex();
+ for (int i = 0; i < choiceLimits.length; ++i)
+ {
+ if (sourceStr.startsWith(choiceFormats[i], index))
+ {
+ pos.setIndex(index + choiceFormats[i].length());
+ return new Double (choiceLimits[i]);
+ }
+ }
+ pos.setErrorIndex(index);
+ return new Double (Double.NaN);
+ }
+
+ /**
+ * This method returns the highest possible double less than the
+ * specified double. If the specified double value is equal to
+ * <code>Double.NaN</code> then that is the value returned.
+ *
+ * @param d The specified double
+ *
+ * @return The highest double value less than the specified double.
+ */
public static final double previousDouble (double d)
- {
- return nextDouble (d, false);
- }
-
+ {
+ return nextDouble (d, false);
+ }
+
+ /**
+ * This method sets new range terminators and format strings for this
+ * object.
+ *
+ * @param choiceLimits The new range terminators
+ * @param choiceFormats The new choice formats
+ */
public void setChoices (double[] choiceLimits, String[] choiceFormats)
- {
- if (choiceLimits == null || choiceFormats == null)
- throw new NullPointerException ();
- if (choiceLimits.length != choiceFormats.length)
- throw new IllegalArgumentException ();
- this.choiceFormats = (String[]) choiceFormats.clone();
- this.choiceLimits = (double[]) choiceLimits.clone();
- }
+ {
+ if (choiceLimits == null || choiceFormats == null)
+ throw new NullPointerException ();
+ if (choiceLimits.length != choiceFormats.length)
+ throw new IllegalArgumentException ();
+ this.choiceFormats = (String[]) choiceFormats.clone();
+ this.choiceLimits = (double[]) choiceLimits.clone();
+ }
private final void quoteString (StringBuffer dest, String text)
- {
- int max = text.length();
- for (int i = 0; i < max; ++i)
- {
- char c = text.charAt(i);
- if (c == '\'')
- {
- dest.append(c);
- dest.append(c);
- }
- else if (c == '#' || c == '|' || c == '\u2064' || c == '<')
- {
- dest.append('\'');
- dest.append(c);
- dest.append('\'');
- }
- else
+ {
+ int max = text.length();
+ for (int i = 0; i < max; ++i)
+ {
+ char c = text.charAt(i);
+ if (c == '\'')
+ {
dest.append(c);
- }
- }
-
+ dest.append(c);
+ }
+ else if (c == '#' || c == '|' || c == '\u2064' || c == '<')
+ {
+ dest.append('\'');
+ dest.append(c);
+ dest.append('\'');
+ }
+ else
+ dest.append(c);
+ }
+ }
+
+ /**
+ * This method returns the range terminator list and format string list
+ * as a <code>String</code> suitable for using with the
+ * <code>applyPattern</code> method.
+ *
+ * @return A pattern string for this object
+ */
public String toPattern ()
- {
- StringBuffer result = new StringBuffer ();
- for (int i = 0; i < choiceLimits.length; ++i)
- {
- result.append(choiceLimits[i]);
- result.append('#');
- quoteString (result, choiceFormats[i]);
- }
- return result.toString();
- }
-
- // Formats and limits.
+ {
+ StringBuffer result = new StringBuffer ();
+ for (int i = 0; i < choiceLimits.length; ++i)
+ {
+ result.append(choiceLimits[i]);
+ result.append('#');
+ quoteString (result, choiceFormats[i]);
+ }
+ return result.toString();
+ }
+
+ /**
+ * This is the list of format strings. Note that this variable is
+ * specified by the serialization spec of this class.
+ */
private String[] choiceFormats;
+
+ /**
+ * This is the list of range terminator values. Note that this variable is
+ * specified by the serialization spec of this class.
+ */
private double[] choiceLimits;
// Number of mantissa bits in double.
-// Collator.java - Locale-sensitive string comparison.
+/* Collator.java -- Perform locale dependent String comparisons.
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999, 2000 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
import java.util.Comparator;
/**
+ * This class is the abstract superclass of classes which perform
+ * locale dependent <code>String</code> comparisons. A caller requests
+ * an instance of <code>Collator</code> for a particular locale using
+ * the <code>getInstance()</code> static method in this class. That method
+ * will return a locale specific subclass of <code>Collator</code> which
+ * can be used to perform <code>String</code> comparisons for that locale.
+ * If a subclass of <code>Collator</code> cannot be located for a particular
+ * locale, a default instance for the current locale will be returned.
+ *
+ * In addition to setting the correct locale, there are two additional
+ * settings that can be adjusted to affect <code>String</code> comparisons:
+ * strength and decomposition. The strength value determines the level
+ * of signficance of character differences required for them to sort
+ * differently. (For example, whether or not capital letters are considered
+ * different from lower case letters). The decomposition value affects how
+ * variants of the same character are treated for sorting purposes. (For
+ * example, whether or not an accent is signficant or not). These settings
+ * are described in detail in the documentation for the methods and values
+ * that are related to them.
+ *
* @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @date March 18, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Mostly complete, but parts stubbed out. Look for FIXME.
*/
-
public abstract class Collator implements Comparator, Cloneable
{
- public static final int NO_DECOMPOSITION = 0;
- public static final int CANONICAL_DECOMPOSITION = 1;
- public static final int FULL_DECOMPOSITION = 2;
-
+ /**
+ * This constant is a strength value which indicates that only primary
+ * differences between characters will be considered signficant. As an
+ * example, two completely different English letters such as 'a' and 'b'
+ * are considered to have a primary difference.
+ */
public static final int PRIMARY = 0;
+
+ /**
+ * This constant is a strength value which indicates that only secondary
+ * or primary differences between characters will be considered
+ * significant. An example of a secondary difference between characters
+ * are instances of the same letter with different accented forms.
+ */
public static final int SECONDARY = 1;
+
+ /**
+ * This constant is a strength value which indicates that tertiary,
+ * secondary, and primary differences will be considered during sorting.
+ * An example of a tertiary difference is capitalization of a given letter.
+ * This is the default value for the strength setting.
+ */
public static final int TERTIARY = 2;
+
+ /**
+ * This constant is a strength value which indicates that any difference
+ * at all between character values are considered significant.
+ */
public static final int IDENTICAL = 3;
+
+ /**
+ * This constant indicates that accented characters won't be decomposed
+ * when performing comparisons. This will yield the fastest results, but
+ * will only work correctly in call cases for languages which do not
+ * use accents such as English.
+ */
+ public static final int NO_DECOMPOSITION = 0;
+
+ /**
+ * This constant indicates that only characters which are canonical variants
+ * in Unicode 2.0 will be decomposed prior to performing comparisons. This
+ * will cause accented languages to be sorted correctly. This is the
+ * default decomposition value.
+ */
+ public static final int CANONICAL_DECOMPOSITION = 1;
+
+ /**
+ * This constant indicates that both canonical variants and compatibility
+ * variants in Unicode 2.0 will be decomposed prior to performing
+ * comparisons. This is the slowest mode, but is required to get the
+ * correct sorting for certain languages with certain special formats.
+ */
+ public static final int FULL_DECOMPOSITION = 2;
+ /**
+ * This method initializes a new instance of <code>Collator</code> to have
+ * the default strength (TERTIARY) and decomposition
+ * (CANONICAL_DECOMPOSITION) settings. This constructor is protected and
+ * is for use by subclasses only. Non-subclass callers should use the
+ * static <code>getInstance()</code> methods of this class to instantiate
+ * <code>Collation</code> objects for the desired locale.
+ */
protected Collator ()
{
strength = TERTIARY;
decmp = CANONICAL_DECOMPOSITION;
}
+ /**
+ * This method compares the two <code>String</code>'s and returns an
+ * integer indicating whether or not the first argument is less than,
+ * equal to, or greater than the second argument. The comparison is
+ * performed according to the rules of the locale for this
+ * <code>Collator</code> and the strength and decomposition rules in
+ * effect.
+ *
+ * @param str1 The first object to compare
+ * @param str2 The second object to compare
+ *
+ * @return A negative integer if str1 < str2, 0 if str1 == str2, or
+ * a positive integer if str1 > str2.
+ */
public abstract int compare (String source, String target);
+ /**
+ * This method compares the two <code>Object</code>'s and returns an
+ * integer indicating whether or not the first argument is less than,
+ * equal to, or greater than the second argument. These two objects
+ * must be <code>String</code>'s or an exception will be thrown.
+ *
+ * @param obj1 The first object to compare
+ * @param obj2 The second object to compare
+ *
+ * @return A negative integer if obj1 < obj2, 0 if obj1 == obj2, or
+ * a positive integer if obj1 > obj2.
+ *
+ * @exception ClassCastException If the arguments are not instances
+ * of <code>String</code>.
+ */
public int compare (Object o1, Object o2)
{
return compare ((String) o1, (String) o2);
}
+ /**
+ * This method tests the specified object for equality against this
+ * object. This will be true if and only if the following conditions are
+ * met:
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>Collator</code>.
+ * <li>The specified object has the same strength and decomposition
+ * settings as this object.
+ * </ul>
+ *
+ * @param obj The <code>Object</code> to test for equality against
+ * this object.
+ *
+ * @return <code>true</code> if the specified object is equal to
+ * this one, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
if (! (obj instanceof Collator))
return decmp == c.decmp && strength == c.strength;
}
+ /**
+ * This method tests whether the specified <code>String</code>'s are equal
+ * according to the collation rules for the locale of this object and
+ * the current strength and decomposition settings.
+ *
+ * @param str1 The first <code>String</code> to compare
+ * @param str2 The second <code>String</code> to compare
+ *
+ * @return <code>true</code> if the two strings are equal,
+ * <code>false</code> otherwise.
+ */
public boolean equals (String source, String target)
{
return compare (source, target) == 0;
}
+ /**
+ * This method returns a copy of this <code>Collator</code> object.
+ *
+ * @return A duplicate of this object.
+ */
public Object clone ()
{
- return super.clone ();
+ try
+ {
+ return super.clone ();
+ }
+ catch (CloneNotSupportedException _)
+ {
+ return null;
+ }
}
+ /**
+ * This method returns an array of <code>Locale</code> objects which is
+ * the list of locales for which <code>Collator</code> objects exist.
+ *
+ * @return The list of locales for which <code>Collator</code>'s exist.
+ */
public static synchronized Locale[] getAvailableLocales ()
{
- // FIXME.
- return null;
+ // FIXME
+ Locale[] l = new Locale[1];
+ l[0] = Locale.US;
+ return l;
}
+ /**
+ * This method transforms the specified <code>String</code> into a
+ * <code>CollationKey</code> for faster comparisons. This is useful when
+ * comparisons against a string might be performed multiple times, such
+ * as during a sort operation.
+ *
+ * @param str The <code>String</code> to convert.
+ *
+ * @return A <code>CollationKey</code> for the specified <code>String</code>.
+ */
public abstract CollationKey getCollationKey (String source);
+ /**
+ * This method returns the current decomposition setting for this
+ * object. This * will be one of NO_DECOMPOSITION,
+ * CANONICAL_DECOMPOSITION, or * FULL_DECOMPOSITION. See the
+ * documentation for those constants for an * explanation of this
+ * setting.
+ *
+ * @return The current decomposition setting.
+ */
public synchronized int getDecomposition ()
{
return decmp;
}
+ /**
+ * This method returns an instance of <code>Collator</code> for the
+ * default locale.
+ *
+ * @return A <code>Collator</code> for the default locale.
+ */
public static Collator getInstance ()
{
return getInstance (Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>Collator</code> for the
+ * specified locale. If no <code>Collator</code> exists for the desired
+ * locale, a <code>Collator</code> for the default locale will be returned.
+ *
+ * @param locale The desired localed to load a <code>Collator</code> for.
+ *
+ * @return A <code>Collator</code> for the requested locale
+ */
public static Collator getInstance (Locale loc)
{
ResourceBundle res;
String pattern;
try
{
- res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
- pattern = res.getString("collatorRule");
+ res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc);
+ pattern = res.getString("collation_rules");
}
catch (MissingResourceException x)
{
}
}
+ /**
+ * This method returns the current strength setting for this object. This
+ * will be one of PRIMARY, SECONDARY, TERTIARY, or IDENTICAL. See the
+ * documentation for those constants for an explanation of this setting.
+ *
+ * @return The current strength setting.
+ */
public synchronized int getStrength ()
{
return strength;
}
+ /**
+ * This method returns a hash code value for this object.
+ *
+ * @return A hash value for this object.
+ */
public abstract int hashCode ();
+ /**
+ * This method sets the decomposition setting for this object to the
+ * specified value. This must be one of NO_DECOMPOSITION,
+ * CANONICAL_DECOMPOSITION, or FULL_DECOMPOSITION. Otherwise an
+ * exception will be thrown. See the documentation for those
+ * contants for an explanation of this setting.
+ *
+ * @param decmp The new decomposition setting.
+ *
+ * @exception IllegalArgumentException If the requested
+ * decomposition setting is not valid.
+ */
public synchronized void setDecomposition (int mode)
{
if (mode != NO_DECOMPOSITION
decmp = mode;
}
+ /**
+ * This method sets the strength setting for this object to the specified
+ * value. This must be one of PRIMARY, SECONDARY, TERTIARY, or IDENTICAL.
+ * Otherwise an exception is thrown. See the documentation for these
+ * constants for an explanation of this setting.
+ *
+ * @param strength The new strength setting.
+ *
+ * @exception IllegalArgumentException If the requested strength
+ * setting value is not valid.
+ */
public synchronized void setStrength (int strength)
{
if (strength != PRIMARY && strength != SECONDARY
// Decompose a single character and append results to the buffer.
native final void decomposeCharacter (char c, StringBuffer buf);
- // These names are fixed by the serialization spec.
+ /**
+ * This is the current collation decomposition setting.
+ */
int decmp;
+
+ /**
+ * This is the current collation strength setting.
+ */
int strength;
}
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* DateFormat.java -- Class for formatting/parsing date/times
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
protected NumberFormat numberFormat;
// (Values determined using a test program.)
- public final static int FULL = 0;
- public final static int LONG = 1;
- public final static int MEDIUM = 2;
- public final static int SHORT = 3;
- public final static int DEFAULT = MEDIUM;
-
- public final static int ERA_FIELD = 0;
- public final static int YEAR_FIELD = 1;
- public final static int MONTH_FIELD = 2;
- public final static int DATE_FIELD = 3;
- public final static int HOUR_OF_DAY1_FIELD = 4;
- public final static int HOUR_OF_DAY0_FIELD = 5;
- public final static int MINUTE_FIELD = 6;
- public final static int SECOND_FIELD = 7;
- public final static int MILLISECOND_FIELD = 8;
- public final static int DAY_OF_WEEK_FIELD = 9;
- public final static int DAY_OF_YEAR_FIELD = 10;
- public final static int DAY_OF_WEEK_IN_MONTH_FIELD = 11;
- public final static int WEEK_OF_YEAR_FIELD = 12;
- public final static int WEEK_OF_MONTH_FIELD = 13;
- public final static int AM_PM_FIELD = 14;
- public final static int HOUR1_FIELD = 15;
- public final static int HOUR0_FIELD = 16;
- public final static int TIMEZONE_FIELD = 17;
-
+ public static final int FULL = 0;
+ public static final int LONG = 1;
+ public static final int MEDIUM = 2;
+ public static final int SHORT = 3;
+ public static final int DEFAULT = MEDIUM;
+
+ /* These constants need to have these exact values. They
+ * correspond to index positions within the localPatternChars
+ * string for a given locale. For example, the US locale uses
+ * the string "GyMdkHmsSEDFwWahKz", where 'G' is the character
+ * for era, 'y' for year, and so on down to 'z' for time zone.
+ */
+ public static final int ERA_FIELD = 0;
+ public static final int YEAR_FIELD = 1;
+ public static final int MONTH_FIELD = 2;
+ public static final int DATE_FIELD = 3;
+ public static final int HOUR_OF_DAY1_FIELD = 4;
+ public static final int HOUR_OF_DAY0_FIELD = 5;
+ public static final int MINUTE_FIELD = 6;
+ public static final int SECOND_FIELD = 7;
+ public static final int MILLISECOND_FIELD = 8;
+ public static final int DAY_OF_WEEK_FIELD = 9;
+ public static final int DAY_OF_YEAR_FIELD = 10;
+ public static final int DAY_OF_WEEK_IN_MONTH_FIELD = 11;
+ public static final int WEEK_OF_YEAR_FIELD = 12;
+ public static final int WEEK_OF_MONTH_FIELD = 13;
+ public static final int AM_PM_FIELD = 14;
+ public static final int HOUR1_FIELD = 15;
+ public static final int HOUR0_FIELD = 16;
+ public static final int TIMEZONE_FIELD = 17;
+
+ /**
+ * This method initializes a new instance of <code>DateFormat</code>.
+ */
protected DateFormat ()
{
}
+ /**
+ * This method tests this object for equality against the specified object.
+ * The two objects will be considered equal if an only if the specified
+ * object:
+ * <P>
+ * <ul>
+ * <li>Is not <code>null</code>.
+ * <li>Is an instance of <code>DateFormat</code>.
+ * <li>Has the same calendar and numberFormat field values as this object.
+ * </ul>
+ *
+ * @param obj The object to test for equality against.
+ *
+ * @return <code>true</code> if the specified object is equal to this object,
+ * <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
if (! (obj instanceof DateFormat))
return calendar.equals(d.calendar) && numberFormat.equals(d.numberFormat);
}
+ /**
+ * This method returns a copy of this object.
+ *
+ * @return A copy of this object.
+ */
public Object clone ()
{
// We know the superclass just call's Object's generic cloner.
return super.clone ();
}
+ /**
+ * This method formats the specified <code>Object</code> into a date string
+ * and appends it to the specified <code>StringBuffer</code>.
+ * The specified object must be an instance of <code>Number</code> or
+ * <code>Date</code> or an <code>IllegalArgumentException</code> will be
+ * thrown.
+ *
+ * @param obj The <code>Object</code> to format.
+ * @param toAppendTo The <code>StringBuffer</code> to append the resultant
+ * <code>String</code> to.
+ * @param fieldPosition Is updated to the start and end index of the
+ * specified field.
+ *
+ * @return The <code>StringBuffer</code> supplied on input, with the
+ * formatted date/time appended.
+ */
public final StringBuffer format (Object obj,
StringBuffer buf, FieldPosition pos)
{
if (obj instanceof Number)
- return format (new Date(((Number) obj).longValue()), buf, pos);
+ obj = new Date(((Number) obj).longValue());
return format ((Date) obj, buf, pos);
}
+ /**
+ * Formats the date argument according to the pattern specified.
+ *
+ * @param date The formatted date.
+ */
public final String format (Date date)
{
StringBuffer sb = new StringBuffer ();
return sb.toString();
}
+ /**
+ * This method formats a <code>Date</code> into a string and appends it
+ * to the specified <code>StringBuffer</code>.
+ *
+ * @param date The <code>Date</code> value to format.
+ * @param toAppendTo The <code>StringBuffer</code> to append the resultant
+ * <code>String</code> to.
+ * @param fieldPosition Is updated to the start and end index of the
+ * specified field.
+ *
+ * @return The <code>StringBuffer</code> supplied on input, with the
+ * formatted date/time appended.
+ */
public abstract StringBuffer format (Date date,
StringBuffer buf, FieldPosition pos);
+ /**
+ * This method returns a list of available locales supported by this
+ * class.
+ */
public static Locale[] getAvailableLocales ()
{
- return null; // FIXME
+ // FIXME
+ Locale[] l = new Locale[1];
+ l[0] = Locale.US;
+ return l;
}
+ /**
+ * This method returns the <code>Calendar</code> object being used by
+ * this object to parse/format datetimes.
+ *
+ * @return The <code>Calendar</code> being used by this object.
+ *
+ * @see java.util.Calendar
+ */
public Calendar getCalendar ()
{
return calendar;
ResourceBundle res;
try
{
- res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
+ res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc);
}
catch (MissingResourceException x)
{
return new SimpleDateFormat (pattern, loc);
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the default formatting style for dates.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getDateInstance ()
{
return getDateInstance (DEFAULT, Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the specified formatting style for dates.
+ *
+ * @param style The type of formatting to perform.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getDateInstance (int style)
{
return getDateInstance (style, Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the specified formatting style for dates. The specified
+ * localed will be used in place of the default.
+ *
+ * @param style The type of formatting to perform.
+ * @param aLocale The desired locale.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getDateInstance (int style, Locale loc)
{
return computeInstance (style, loc, true, false);
}
+ /**
+ * This method returns a new instance of <code>DateFormat</code> that
+ * formats both dates and times using the <code>SHORT</code> style.
+ *
+ * @return A new <code>DateFormat</code>instance.
+ */
public static final DateFormat getDateTimeInstance ()
{
return getDateTimeInstance (DEFAULT, DEFAULT, Locale.getDefault());
}
+ /**
+ * This method returns a new instance of <code>DateFormat</code> that
+ * formats both dates and times using the <code>DEFAULT</code> style.
+ *
+ * @return A new <code>DateFormat</code>instance.
+ */
public static final DateFormat getDateTimeInstance (int dateStyle,
int timeStyle)
{
return getDateTimeInstance (dateStyle, timeStyle, Locale.getDefault());
}
+ /**
+ * This method returns a new instance of <code>DateFormat</code> that
+ * formats both dates and times using the specified styles.
+ *
+ * @param dateStyle The desired style for date formatting.
+ * @param timeStyle The desired style for time formatting
+ *
+ * @return A new <code>DateFormat</code>instance.
+ */
public static final DateFormat getDateTimeInstance (int dateStyle,
int timeStyle,
Locale loc)
return computeInstance (dateStyle, timeStyle, loc, true, true);
}
+ /**
+ * This method returns a new instance of <code>DateFormat</code> that
+ * formats both dates and times using the <code>SHORT</code> style.
+ *
+ * @return A new <code>DateFormat</code>instance.
+ */
public static final DateFormat getInstance ()
{
// JCL book says SHORT.
return getDateTimeInstance (SHORT, SHORT, Locale.getDefault());
}
+ /**
+ * This method returns the <code>NumberFormat</code> object being used
+ * by this object to parse/format time values.
+ *
+ * @return The <code>NumberFormat</code> in use by this object.
+ */
public NumberFormat getNumberFormat ()
{
return numberFormat;
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the default formatting style for times.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getTimeInstance ()
{
return getTimeInstance (DEFAULT, Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the specified formatting style for times.
+ *
+ * @param style The type of formatting to perform.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getTimeInstance (int style)
{
return getTimeInstance (style, Locale.getDefault());
}
+ /**
+ * This method returns an instance of <code>DateFormat</code> that will
+ * format using the specified formatting style for times. The specified
+ * localed will be used in place of the default.
+ *
+ * @param style The type of formatting to perform.
+ * @param aLocale The desired locale.
+ *
+ * @return A new <code>DateFormat</code> instance.
+ */
public static final DateFormat getTimeInstance (int style, Locale loc)
{
return computeInstance (style, loc, false, true);
}
+ /**
+ * This method returns the <code>TimeZone</code> object being used by
+ * this instance.
+ *
+ * @return The time zone in use.
+ */
public TimeZone getTimeZone ()
{
return calendar.getTimeZone();
}
+ /**
+ * This method returns a hash value for this object.
+ *
+ * @return A hash value for this object.
+ */
public int hashCode ()
{
int hash = calendar.hashCode();
return hash;
}
+ /**
+ * This method indicates whether or not the parsing of date and time
+ * values should be done in a lenient value.
+ *
+ * @return <code>true</code> if date/time parsing is lenient,
+ * <code>false</code> otherwise.
+ */
public boolean isLenient ()
{
return calendar.isLenient();
}
+ /**
+ * This method parses the specified date/time string.
+ *
+ * @return The resultant date.
+ *
+ * @exception ParseException If the specified string cannot be parsed.
+ */
public Date parse (String source) throws ParseException
{
ParsePosition pos = new ParsePosition(0);
return result;
}
+ /**
+ * This method parses the specified <code>String</code> into a
+ * <code>Date</code>. The <code>pos</code> argument contains the
+ * starting parse position on method entry and the ending parse
+ * position on method exit.
+ *
+ * @param text The string to parse.
+ * @param pos The starting parse position in entry, the ending parse
+ * position on exit.
+ *
+ * @return The parsed date, or <code>null</code> if the string cannot
+ * be parsed.
+ */
public abstract Date parse (String source, ParsePosition pos);
+ /**
+ * This method is identical to <code>parse(String, ParsePosition)</code>,
+ * but returns its result as an <code>Object</code> instead of a
+ * <code>Date</code>.
+ *
+ * @param source The string to parse.
+ * @param pos The starting parse position in entry, the ending parse
+ * position on exit.
+ *
+ * @return The parsed date, or <code>null</code> if the string cannot
+ * be parsed.
+ */
public Object parseObject (String source, ParsePosition pos)
{
return parse(source, pos);
}
+ /**
+ * This method specified the <code>Calendar</code> that should be used
+ * by this object to parse/format datetimes.
+ *
+ * @param The new <code>Calendar</code> for this object.
+ *
+ * @see java.util.Calendar
+ */
public void setCalendar (Calendar calendar)
{
this.calendar = calendar;
}
+ /**
+ * This method specifies whether or not this object should be lenient in
+ * the syntax it accepts while parsing date/time values.
+ *
+ * @param lenient <code>true</code> if parsing should be lenient,
+ * <code>false</code> otherwise.
+ */
public void setLenient (boolean lenient)
{
calendar.setLenient(lenient);
}
+ /**
+ * This method specifies the <code>NumberFormat</code> object that should
+ * be used by this object to parse/format times.
+ *
+ * @param The <code>NumberFormat</code> in use by this object.
+ */
public void setNumberFormat (NumberFormat numberFormat)
{
this.numberFormat = numberFormat;
}
+ /**
+ * This method sets the time zone that should be used by this object.
+ *
+ * @param The new time zone.
+ */
public void setTimeZone (TimeZone timeZone)
{
calendar.setTimeZone(timeZone);
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
This file is part of libgcj.
import java.util.ResourceBundle;
/**
+ * This class acts as container for locale specific date/time formatting
+ * information such as the days of the week and the months of the year.
* @author Per Bothner <bothner@cygnus.com>
* @date October 24, 1998.
*/
-
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3.
* Status: Believed complete and correct.
*/
-
-public class DateFormatSymbols extends Object
- implements java.io.Serializable, Cloneable
+public class DateFormatSymbols implements java.io.Serializable, Cloneable
{
String[] ampms;
String[] eras;
private static final long serialVersionUID = -5987973545549424702L;
// The order of these prefixes must be the same as in DateFormat
- // FIXME: XXX: Note that this differs from the Classpath implemention
- // in that there is no "default" entry; that is due to differing
- // implementations where DateFormat.DEFAULT is MEDIUM here but 4 in
- // Classpath (the JCL says it should be MEDIUM). That will need to be
- // resolved in the merge.
- private static final String[] formatPrefixes = { "full", "long", "medium", "short" };
-
- private static final String[] ampmsDefault = {"AM", "PM" };
- private static final String[] erasDefault = {"BC", "AD" };
- // localPatternCharsDefault is used by SimpleDateFormat.
- private static final String localPatternCharsDefault
- = "GyMdkHmsSEDFwWahKz";
- private static final String[] monthsDefault = {
- "January", "February", "March", "April", "May", "June",
- "July", "August", "September", "October", "November", "December", ""
- };
- private static final String[] shortMonthsDefault = {
- "Jan", "Feb", "Mar", "Apr", "May", "Jun",
- "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", ""
- };
- private static final String[] shortWeekdaysDefault = {
- "", "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
- };
- private static final String[] weekdaysDefault = {
- "", "Sunday", "Monday", "Tuesday",
- "Wednesday", "Thursday", "Friday", "Saturday"
- };
-
- private static String[][] zoneStringsDefault = {
- { "GMT", "Greenwich Mean Time", "GMT",
- /**/ "Greenwich Mean Time", "GMT", "GMT" },
- { "PST", "Pacific Standard Time", "PST",
- /**/ "Pacific Daylight Time", "PDT", "San Francisco" },
- { "MST", "Mountain Standard Time", "MST",
- /**/ "Mountain Daylight Time", "MDT", "Denver" },
- { "PNT", "Mountain Standard Time", "MST",
- /**/ "Mountain Standard Time", "MST", "Phoenix" },
- { "CST", "Central Standard Time", "CST",
- /**/ "Central Daylight Time", "CDT", "Chicago" },
- { "EST", "Eastern Standard Time", "EST",
- /**/ "Eastern Daylight Time", "EDT", "Boston" },
- { "IET", "Eastern Standard Time", "EST",
- /**/ "Eastern Standard Time", "EST", "Indianapolis" },
- { "PRT", "Atlantic Standard Time", "AST",
- /**/ "Atlantic Daylight Time", "ADT", "Halifax" },
- { "CNT", "Newfoundland Standard Time", "NST",
- /**/ "Newfoundland Daylight Time", "NDT", "St. Johns" },
- { "ECT", "Central European Standard Time", "CET",
- /**/ "Central European Daylight Time", "CEST", "Paris" },
- { "CTT", "China Standard Time", "CST",
- /**/ "China Standard Time", "CST", "Shanghai" },
- { "JST", "Japan Standard Time", "JST",
- /**/ "Japan Standard Time", "JST", "Tokyo" },
- { "HST", "Hawaii Standard Time", "HST",
- /**/ "Hawaii Standard Time", "HST", "Honolulu" },
- { "AST", "Alaska Standard Time", "AKST",
- /**/ "Alaska Daylight Time", "AKDT", "Anchorage" }
+ private static final String[] formatPrefixes =
+ {
+ "full", "long", "medium", "short"
};
// These are each arrays with a value for SHORT, MEDIUM, LONG, FULL,
return values;
}
- private final Object safeGetResource (ResourceBundle res,
- String key, Object def)
- {
- if (res != null)
- {
- try
- {
- return res.getObject(key);
- }
- catch (MissingResourceException x)
- {
- }
- }
- return def;
- }
-
- public DateFormatSymbols (Locale locale)
+ /**
+ * This method initializes a new instance of <code>DateFormatSymbols</code>
+ * by loading the date format information for the specified locale.
+ *
+ * @param locale The locale for which date formatting symbols should
+ * be loaded.
+ */
+ public DateFormatSymbols (Locale locale) throws MissingResourceException
{
- ResourceBundle res;
- try
- {
- res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", locale);
- }
- catch (MissingResourceException x)
- {
- res = null;
- }
- ampms = (String[]) safeGetResource (res, "ampm", ampmsDefault);
- eras = (String[]) safeGetResource (res, "eras", erasDefault);
- localPatternChars = (String) safeGetResource (res, "datePatternChars",
- localPatternCharsDefault);
- months = (String[]) safeGetResource (res, "months", monthsDefault);
- shortMonths = (String[]) safeGetResource (res, "shortMonths",
- shortMonthsDefault);
- shortWeekdays = (String[]) safeGetResource (res, "shortWeekdays",
- shortWeekdaysDefault);
- weekdays = (String[]) safeGetResource (res, "weekdays", weekdaysDefault);
- zoneStrings = (String[][]) safeGetResource (res, "zoneStrings",
- zoneStringsDefault);
+ ResourceBundle res
+ = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation", locale);
+
+ ampms = res.getStringArray ("ampms");
+ eras = res.getStringArray ("eras");
+ localPatternChars = res.getString ("localPatternChars");
+ months = res.getStringArray ("months");
+ shortMonths = res.getStringArray ("shortMonths");
+ shortWeekdays = res.getStringArray ("shortWeekdays");
+ weekdays = res.getStringArray ("weekdays");
+ zoneStrings = (String[][]) res.getObject ("zoneStrings");
dateFormats = formatsForKey(res, "DateFormat");
timeFormats = formatsForKey(res, "TimeFormat");
}
- public DateFormatSymbols ()
+ /**
+ * This method loads the format symbol information for the default
+ * locale.
+ */
+ public DateFormatSymbols () throws MissingResourceException
{
this (Locale.getDefault());
}
- // Copy constructor.
- private DateFormatSymbols (DateFormatSymbols old)
- {
- ampms = old.ampms;
- eras = old.eras;
- localPatternChars = old.localPatternChars;
- months = old.months;
- shortMonths = old.shortMonths;
- shortWeekdays = old.shortWeekdays;
- weekdays = old.weekdays;
- zoneStrings = old.zoneStrings;
- dateFormats = old.dateFormats;
- timeFormats = old.timeFormats;
- }
-
+ /**
+ * This method returns the list of strings used for displaying AM or PM.
+ * This is a two element <code>String</code> array indexed by
+ * <code>Calendar.AM</code> and <code>Calendar.PM</code>
+ *
+ * @return The list of AM/PM display strings.
+ */
public String[] getAmPmStrings()
{
return ampms;
}
+ /**
+ * This method returns the list of strings used for displaying eras
+ * (e.g., "BC" and "AD"). This is a two element <code>String</code>
+ * array indexed by <code>Calendar.BC</code> and <code>Calendar.AD</code>.
+ *
+ * @return The list of era disply strings.
+ */
public String[] getEras()
{
return eras;
}
-
+ /**
+ * This method returns the pattern character information for this
+ * object. This is an 18 character string that contains the characters
+ * that are used in creating the date formatting strings in
+ * <code>SimpleDateFormat</code>. The following are the character
+ * positions in the string and which format character they correspond
+ * to (the character in parentheses is the default value in the US English
+ * locale):
+ * <p>
+ * <ul>
+ * <li>0 - era (G)
+ * <li>1 - year (y)
+ * <li>2 - month (M)
+ * <li 3 - day of month (d)
+ * <li>4 - hour out of 12, from 1-12 (h)
+ * <li>5 - hour out of 24, from 0-23 (H)
+ * <li>6 - minute (m)
+ * <li>7 - second (s)
+ * <li>8 - millisecond (S)
+ * <li>9 - date of week (E)
+ * <li>10 - date of year (D)
+ * <li>11 - day of week in month, eg. "4th Thur in Nov" (F)
+ * <li>12 - week in year (w)
+ * <li>13 - week in month (W)
+ * <li>14 - am/pm (a)
+ * <li>15 - hour out of 24, from 1-24 (k)
+ * <li>16 - hour out of 12, from 0-11 (K)
+ * <li>17 - time zone (z)
+ * </ul>
+ *
+ * @return The format patter characters
+ */
public String getLocalPatternChars()
{
return localPatternChars;
}
+ /**
+ * This method returns the list of strings used for displaying month
+ * names (e.g., "January" and "February"). This is a thirteen element
+ * string array indexed by <code>Calendar.JANUARY</code> through
+ * <code>Calendar.UNDECEMBER</code>. Note that there are thirteen
+ * elements because some calendars have thriteen months.
+ *
+ * @return The list of month display strings.
+ */
public String[] getMonths ()
{
return months;
}
+ /**
+ * This method returns the list of strings used for displaying abbreviated
+ * month names (e.g., "Jan" and "Feb"). This is a thirteen element
+ * <code>String</code> array indexed by <code>Calendar.JANUARY</code>
+ * through <code>Calendar.UNDECEMBER</code>. Note that there are thirteen
+ * elements because some calendars have thirteen months.
+ *
+ * @return The list of abbreviated month display strings.
+ */
public String[] getShortMonths ()
{
return shortMonths;
}
+ /**
+ * This method returns the list of strings used for displaying abbreviated
+ * weekday names (e.g., "Sun" and "Mon"). This is an eight element
+ * <code>String</code> array indexed by <code>Calendar.SUNDAY</code>
+ * through <code>Calendar.SATURDAY</code>. Note that the first element
+ * of this array is ignored.
+ *
+ * @return This list of abbreviated weekday display strings.
+ */
public String[] getShortWeekdays ()
{
return shortWeekdays;
}
+ /**
+ * This method returns the list of strings used for displaying weekday
+ * names (e.g., "Sunday" and "Monday"). This is an eight element
+ * <code>String</code> array indexed by <code>Calendar.SUNDAY</code>
+ * through <code>Calendar.SATURDAY</code>. Note that the first element
+ * of this array is ignored.
+ *
+ * @return This list of weekday display strings.
+ */
public String[] getWeekdays ()
{
return weekdays;
}
+ /**
+ * This method returns this list of localized timezone display strings.
+ * This is a two dimensional <code>String</code> array where each row in
+ * the array contains five values:
+ * <P>
+ * <ul>
+ * <li>0 - The non-localized time zone id string.
+ * <li>1 - The long name of the time zone (standard time).
+ * <li>2 - The short name of the time zone (standard time).
+ * <li>3 - The long name of the time zone (daylight savings time).
+ * <li>4 - the short name of the time zone (daylight savings time).
+ *
+ * @return The list of time zone display strings.
+ */
public String[] [] getZoneStrings ()
{
return zoneStrings;
}
+ /**
+ * This method sets the list of strings used to display AM/PM values to
+ * the specified list.
+ * This is a two element <code>String</code> array indexed by
+ * <code>Calendar.AM</code> and <code>Calendar.PM</code>
+ *
+ * @param ampms The new list of AM/PM display strings.
+ */
public void setAmPmStrings (String[] value)
{
ampms = value;
}
+ /**
+ * This method sets the list of strings used to display time eras to
+ * to the specified list.
+ * This is a two element <code>String</code>
+ * array indexed by <code>Calendar.BC</code> and <code>Calendar.AD</code>.
+ *
+ * @param eras The new list of era disply strings.
+ */
public void setEras (String[] value)
{
eras = value;
}
+ /**
+ * This method sets the list of characters used to specific date/time
+ * formatting strings.
+ * This is an 18 character string that contains the characters
+ * that are used in creating the date formatting strings in
+ * <code>SimpleDateFormat</code>. The following are the character
+ * positions in the string and which format character they correspond
+ * to (the character in parentheses is the default value in the US English
+ * locale):
+ * <p>
+ * <ul>
+ * <li>0 - era (G)
+ * <li>1 - year (y)
+ * <li>2 - month (M)
+ * <li 3 - day of month (d)
+ * <li>4 - hour out of 12, from 1-12 (h)
+ * <li>5 - hour out of 24, from 0-23 (H)
+ * <li>6 - minute (m)
+ * <li>7 - second (s)
+ * <li>8 - millisecond (S)
+ * <li>9 - date of week (E)
+ * <li>10 - date of year (D)
+ * <li>11 - day of week in month, eg. "4th Thur in Nov" (F)
+ * <li>12 - week in year (w)
+ * <li>13 - week in month (W)
+ * <li>14 - am/pm (a)
+ * <li>15 - hour out of 24, from 1-24 (k)
+ * <li>16 - hour out of 12, from 0-11 (K)
+ * <li>17 - time zone (z)
+ * </ul>
+ *
+ * @param localPatternChars The new format patter characters
+ */
public void setLocalPatternChars (String value)
{
localPatternChars = value;
}
+ /**
+ * This method sets the list of strings used to display month names.
+ * This is a thirteen element
+ * string array indexed by <code>Calendar.JANUARY</code> through
+ * <code>Calendar.UNDECEMBER</code>. Note that there are thirteen
+ * elements because some calendars have thriteen months.
+ *
+ * @param months The list of month display strings.
+ */
public void setMonths (String[] value)
{
months = value;
}
+ /**
+ * This method sets the list of strings used to display abbreviated month
+ * names.
+ * This is a thirteen element
+ * <code>String</code> array indexed by <code>Calendar.JANUARY</code>
+ * through <code>Calendar.UNDECEMBER</code>. Note that there are thirteen
+ * elements because some calendars have thirteen months.
+ *
+ * @param shortMonths The new list of abbreviated month display strings.
+ */
public void setShortMonths (String[] value)
{
shortMonths = value;
}
+ /**
+ * This method sets the list of strings used to display abbreviated
+ * weekday names.
+ * This is an eight element
+ * <code>String</code> array indexed by <code>Calendar.SUNDAY</code>
+ * through <code>Calendar.SATURDAY</code>. Note that the first element
+ * of this array is ignored.
+ *
+ * @param shortWeekdays This list of abbreviated weekday display strings.
+ */
public void setShortWeekdays (String[] value)
{
shortWeekdays = value;
}
+ /**
+ * This method sets the list of strings used to display weekday names.
+ * This is an eight element
+ * <code>String</code> array indexed by <code>Calendar.SUNDAY</code>
+ * through <code>Calendar.SATURDAY</code>. Note that the first element
+ * of this array is ignored.
+ *
+ * @param weekdays This list of weekday display strings.
+ */
public void setWeekdays (String[] value)
{
weekdays = value;
}
+ /**
+ * This method sets the list of display strings for time zones.
+ * This is a two dimensional <code>String</code> array where each row in
+ * the array contains five values:
+ * <P>
+ * <ul>
+ * <li>0 - The non-localized time zone id string.
+ * <li>1 - The long name of the time zone (standard time).
+ * <li>2 - The short name of the time zone (standard time).
+ * <li>3 - The long name of the time zone (daylight savings time).
+ * <li>4 - the short name of the time zone (daylight savings time).
+ *
+ * @return The list of time zone display strings.
+ */
public void setZoneStrings (String[][] value)
{
zoneStrings = value;
return hash;
}
+ /**
+ * This method tests a specified object for equality against this object.
+ * This will be true if and only if the specified object:
+ * <p>
+ * <ul>
+ * <li> Is not <code>null</code>.
+ * <li> Is an instance of <code>DateFormatSymbols</code>.
+ * <li> Contains identical formatting symbols to this object.
+ * </ul>
+ *
+ * @param obj The <code>Object</code> to test for equality against.
+ *
+ * @return <code>true</code> if the specified object is equal to this one,
+ * </code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
- if (obj == null || ! (obj instanceof DateFormatSymbols))
+ if (! (obj instanceof DateFormatSymbols))
return false;
DateFormatSymbols other = (DateFormatSymbols) obj;
return (equals(ampms, other.ampms)
&& equals(zoneStrings, other.zoneStrings));
}
+ /**
+ * Returns a new copy of this object.
+ *
+ * @param A copy of this object
+ */
public Object clone ()
{
- return new DateFormatSymbols (this);
+ try
+ {
+ return super.clone ();
+ }
+ catch (CloneNotSupportedException e)
+ {
+ return null;
+ }
}
+ /**
+ * This method returns a hash value for this object.
+ *
+ * @return A hash value for this object.
+ */
public int hashCode ()
{
return (hashCode(ampms)
-// DecimalFormat.java - Localized number formatting.
-
-/* Copyright (C) 1999, 2000 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
+/* DecimalFormat.java -- Formats and parses numbers
+ Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
package java.text;
* Note however that the docs are very unclear about how format parsing
* should work. No doubt there are problems here.
*/
-
public class DecimalFormat extends NumberFormat
{
// This is a helper for applyPatternWithSymbols. It reads a prefix
private final int scanFix (String pattern, int index, StringBuffer buf,
String patChars, DecimalFormatSymbols syms,
boolean is_suffix)
- {
- int len = pattern.length();
- buf.setLength(0);
- boolean multiplierSet = false;
- while (index < len)
- {
- char c = pattern.charAt(index);
- if (c == '\'' && index + 1 < len
- && pattern.charAt(index + 1) == '\'')
- {
- buf.append(c);
- ++index;
- }
- else if (c == '\'' && index + 2 < len
- && pattern.charAt(index + 2) == '\'')
- {
- buf.append(pattern.charAt(index + 1));
- index += 2;
- }
- else if (c == '\u00a4')
- {
- if (index + 1 < len && pattern.charAt(index + 1) == '\u00a4')
- {
- buf.append(syms.getInternationalCurrencySymbol());
- ++index;
- }
- else
- buf.append(syms.getCurrencySymbol());
- }
- else if (is_suffix && c == syms.getPercent())
- {
- if (multiplierSet)
- throw new IllegalArgumentException ("multiplier already set " +
- "- index: " + index);
- multiplierSet = true;
- multiplier = 100;
- buf.append(c);
- }
- else if (is_suffix && c == syms.getPerMill())
- {
- if (multiplierSet)
- throw new IllegalArgumentException ("multiplier already set " +
- "- index: " + index);
- multiplierSet = true;
- multiplier = 1000;
- buf.append(c);
- }
- else if (patChars.indexOf(c) != -1)
- {
- // This is a pattern character.
- break;
- }
- else
+ {
+ int len = pattern.length();
+ buf.setLength(0);
+ boolean multiplierSet = false;
+ while (index < len)
+ {
+ char c = pattern.charAt(index);
+ if (c == '\'' && index + 1 < len
+ && pattern.charAt(index + 1) == '\'')
+ {
buf.append(c);
- ++index;
- }
+ ++index;
+ }
+ else if (c == '\'' && index + 2 < len
+ && pattern.charAt(index + 2) == '\'')
+ {
+ buf.append(pattern.charAt(index + 1));
+ index += 2;
+ }
+ else if (c == '\u00a4')
+ {
+ if (index + 1 < len && pattern.charAt(index + 1) == '\u00a4')
+ {
+ buf.append(syms.getInternationalCurrencySymbol());
+ ++index;
+ }
+ else
+ buf.append(syms.getCurrencySymbol());
+ }
+ else if (is_suffix && c == syms.getPercent())
+ {
+ if (multiplierSet)
+ throw new IllegalArgumentException ("multiplier already set " +
+ "- index: " + index);
+ multiplierSet = true;
+ multiplier = 100;
+ buf.append(c);
+ }
+ else if (is_suffix && c == syms.getPerMill())
+ {
+ if (multiplierSet)
+ throw new IllegalArgumentException ("multiplier already set " +
+ "- index: " + index);
+ multiplierSet = true;
+ multiplier = 1000;
+ buf.append(c);
+ }
+ else if (patChars.indexOf(c) != -1)
+ {
+ // This is a pattern character.
+ break;
+ }
+ else
+ buf.append(c);
+ ++index;
+ }
- return index;
- }
+ return index;
+ }
// A helper which reads a number format.
private final int scanFormat (String pattern, int index,
String patChars, DecimalFormatSymbols syms,
boolean is_positive)
- {
- int max = pattern.length();
-
- int countSinceGroup = 0;
- int zeroCount = 0;
- boolean saw_group = false;
-
- //
- // Scan integer part.
- //
- while (index < max)
- {
- char c = pattern.charAt(index);
-
- if (c == syms.getDigit())
- {
- if (zeroCount > 0)
- throw new IllegalArgumentException ("digit mark following " +
- "zero - index: " + index);
- ++countSinceGroup;
- }
- else if (c == syms.getZeroDigit())
- {
- ++zeroCount;
- ++countSinceGroup;
- }
- else if (c == syms.getGroupingSeparator())
- {
- countSinceGroup = 0;
- saw_group = true;
- }
- else
- break;
+ {
+ int max = pattern.length();
- ++index;
- }
-
- // We can only side-effect when parsing the positive format.
- if (is_positive)
- {
- groupingUsed = saw_group;
- groupingSize = (byte) countSinceGroup;
- minimumIntegerDigits = zeroCount;
- }
-
- // Early termination.
- if (index == max || pattern.charAt(index) == syms.getGroupingSeparator())
- {
- if (is_positive)
- decimalSeparatorAlwaysShown = false;
- return index;
- }
-
- if (pattern.charAt(index) == syms.getDecimalSeparator())
- {
- ++index;
-
- //
- // Scan fractional part.
- //
- int hashCount = 0;
- zeroCount = 0;
- while (index < max)
- {
- char c = pattern.charAt(index);
- if (c == syms.getZeroDigit())
- {
- if (hashCount > 0)
- throw new IllegalArgumentException ("zero mark " +
- "following digit - index: " + index);
- ++zeroCount;
- }
- else if (c == syms.getDigit())
- {
- ++hashCount;
- }
- else if (c != syms.getExponential()
- && c != syms.getPatternSeparator()
- && patChars.indexOf(c) != -1)
- throw new IllegalArgumentException ("unexpected special " +
- "character - index: " + index);
- else
- break;
-
- ++index;
- }
-
- if (is_positive)
- {
- maximumFractionDigits = hashCount + zeroCount;
- minimumFractionDigits = zeroCount;
- }
-
- if (index == max)
- return index;
- }
-
- if (pattern.charAt(index) == syms.getExponential())
- {
- //
- // Scan exponential format.
- //
- zeroCount = 0;
- ++index;
- while (index < max)
- {
- char c = pattern.charAt(index);
- if (c == syms.getZeroDigit())
+ int countSinceGroup = 0;
+ int zeroCount = 0;
+ boolean saw_group = false;
+
+ //
+ // Scan integer part.
+ //
+ while (index < max)
+ {
+ char c = pattern.charAt(index);
+
+ if (c == syms.getDigit())
+ {
+ if (zeroCount > 0)
+ throw new IllegalArgumentException ("digit mark following " +
+ "zero - index: " + index);
+ ++countSinceGroup;
+ }
+ else if (c == syms.getZeroDigit())
+ {
+ ++zeroCount;
+ ++countSinceGroup;
+ }
+ else if (c == syms.getGroupingSeparator())
+ {
+ countSinceGroup = 0;
+ saw_group = true;
+ }
+ else
+ break;
+
+ ++index;
+ }
+
+ // We can only side-effect when parsing the positive format.
+ if (is_positive)
+ {
+ groupingUsed = saw_group;
+ groupingSize = (byte) countSinceGroup;
+ minimumIntegerDigits = zeroCount;
+ }
+
+ // Early termination.
+ if (index == max || pattern.charAt(index) == syms.getGroupingSeparator())
+ {
+ if (is_positive)
+ decimalSeparatorAlwaysShown = false;
+ return index;
+ }
+
+ if (pattern.charAt(index) == syms.getDecimalSeparator())
+ {
+ ++index;
+
+ //
+ // Scan fractional part.
+ //
+ int hashCount = 0;
+ zeroCount = 0;
+ while (index < max)
+ {
+ char c = pattern.charAt(index);
+ if (c == syms.getZeroDigit())
+ {
+ if (hashCount > 0)
+ throw new IllegalArgumentException ("zero mark " +
+ "following digit - index: " + index);
++zeroCount;
- else if (c == syms.getDigit())
- {
- if (zeroCount > 0)
- throw new
- IllegalArgumentException ("digit mark following zero " +
- "in exponent - index: " +
- index);
- }
- else if (patChars.indexOf(c) != -1)
- throw new IllegalArgumentException ("unexpected special " +
- "character - index: " +
- index);
- else
- break;
-
- ++index;
- }
-
- if (is_positive)
- {
- useExponentialNotation = true;
- minExponentDigits = (byte) zeroCount;
- }
- }
-
- return index;
- }
+ }
+ else if (c == syms.getDigit())
+ {
+ ++hashCount;
+ }
+ else if (c != syms.getExponential()
+ && c != syms.getPatternSeparator()
+ && patChars.indexOf(c) != -1)
+ throw new IllegalArgumentException ("unexpected special " +
+ "character - index: " + index);
+ else
+ break;
+
+ ++index;
+ }
+
+ if (is_positive)
+ {
+ maximumFractionDigits = hashCount + zeroCount;
+ minimumFractionDigits = zeroCount;
+ }
+
+ if (index == max)
+ return index;
+ }
+
+ if (pattern.charAt(index) == syms.getExponential())
+ {
+ //
+ // Scan exponential format.
+ //
+ zeroCount = 0;
+ ++index;
+ while (index < max)
+ {
+ char c = pattern.charAt(index);
+ if (c == syms.getZeroDigit())
+ ++zeroCount;
+ else if (c == syms.getDigit())
+ {
+ if (zeroCount > 0)
+ throw new
+ IllegalArgumentException ("digit mark following zero " +
+ "in exponent - index: " +
+ index);
+ }
+ else if (patChars.indexOf(c) != -1)
+ throw new IllegalArgumentException ("unexpected special " +
+ "character - index: " +
+ index);
+ else
+ break;
+
+ ++index;
+ }
+
+ if (is_positive)
+ {
+ useExponentialNotation = true;
+ minExponentDigits = (byte) zeroCount;
+ }
+ }
+
+ return index;
+ }
// This helper function creates a string consisting of all the
// characters which can appear in a pattern and must be quoted.
private final String patternChars (DecimalFormatSymbols syms)
- {
- StringBuffer buf = new StringBuffer ();
- buf.append(syms.getDecimalSeparator());
- buf.append(syms.getDigit());
- buf.append(syms.getExponential());
- buf.append(syms.getGroupingSeparator());
- // Adding this one causes pattern application to fail.
- // Of course, omitting is causes toPattern to fail.
- // ... but we already have bugs there. FIXME.
- // buf.append(syms.getMinusSign());
- buf.append(syms.getPatternSeparator());
- buf.append(syms.getPercent());
- buf.append(syms.getPerMill());
- buf.append(syms.getZeroDigit());
- buf.append('\u00a4');
- return buf.toString();
- }
+ {
+ StringBuffer buf = new StringBuffer ();
+ buf.append(syms.getDecimalSeparator());
+ buf.append(syms.getDigit());
+ buf.append(syms.getExponential());
+ buf.append(syms.getGroupingSeparator());
+ // Adding this one causes pattern application to fail.
+ // Of course, omitting is causes toPattern to fail.
+ // ... but we already have bugs there. FIXME.
+ // buf.append(syms.getMinusSign());
+ buf.append(syms.getPatternSeparator());
+ buf.append(syms.getPercent());
+ buf.append(syms.getPerMill());
+ buf.append(syms.getZeroDigit());
+ buf.append('\u00a4');
+ return buf.toString();
+ }
private final void applyPatternWithSymbols (String pattern,
DecimalFormatSymbols syms)
- {
- // Initialize to the state the parser expects.
- negativePrefix = "";
- negativeSuffix = "";
- positivePrefix = "";
- positiveSuffix = "";
- decimalSeparatorAlwaysShown = false;
- groupingSize = 0;
- minExponentDigits = 0;
- multiplier = 1;
- useExponentialNotation = false;
- groupingUsed = false;
- maximumFractionDigits = 0;
- maximumIntegerDigits = 309;
- minimumFractionDigits = 0;
- minimumIntegerDigits = 1;
-
- StringBuffer buf = new StringBuffer ();
- String patChars = patternChars (syms);
-
- int max = pattern.length();
- int index = scanFix (pattern, 0, buf, patChars, syms, false);
- positivePrefix = buf.toString();
-
- index = scanFormat (pattern, index, patChars, syms, true);
-
- index = scanFix (pattern, index, buf, patChars, syms, true);
- positiveSuffix = buf.toString();
-
- if (index == pattern.length())
- {
- // No negative info.
- negativePrefix = null;
- negativeSuffix = null;
- }
- else
- {
- if (pattern.charAt(index) != syms.getPatternSeparator())
- throw new IllegalArgumentException ("separator character " +
- "expected - index: " + index);
-
- index = scanFix (pattern, index + 1, buf, patChars, syms, false);
- negativePrefix = buf.toString();
-
- // We parse the negative format for errors but we don't let
- // it side-effect this object.
- index = scanFormat (pattern, index, patChars, syms, false);
-
- index = scanFix (pattern, index, buf, patChars, syms, true);
- negativeSuffix = buf.toString();
-
- if (index != pattern.length())
- throw new IllegalArgumentException ("end of pattern expected " +
- "- index: " + index);
- }
- }
+ {
+ // Initialize to the state the parser expects.
+ negativePrefix = "";
+ negativeSuffix = "";
+ positivePrefix = "";
+ positiveSuffix = "";
+ decimalSeparatorAlwaysShown = false;
+ groupingSize = 0;
+ minExponentDigits = 0;
+ multiplier = 1;
+ useExponentialNotation = false;
+ groupingUsed = false;
+ maximumFractionDigits = 0;
+ maximumIntegerDigits = 309;
+ minimumFractionDigits = 0;
+ minimumIntegerDigits = 1;
+
+ StringBuffer buf = new StringBuffer ();
+ String patChars = patternChars (syms);
+
+ int max = pattern.length();
+ int index = scanFix (pattern, 0, buf, patChars, syms, false);
+ positivePrefix = buf.toString();
+
+ index = scanFormat (pattern, index, patChars, syms, true);
+
+ index = scanFix (pattern, index, buf, patChars, syms, true);
+ positiveSuffix = buf.toString();
+
+ if (index == pattern.length())
+ {
+ // No negative info.
+ negativePrefix = null;
+ negativeSuffix = null;
+ }
+ else
+ {
+ if (pattern.charAt(index) != syms.getPatternSeparator())
+ throw new IllegalArgumentException ("separator character " +
+ "expected - index: " + index);
+
+ index = scanFix (pattern, index + 1, buf, patChars, syms, false);
+ negativePrefix = buf.toString();
+
+ // We parse the negative format for errors but we don't let
+ // it side-effect this object.
+ index = scanFormat (pattern, index, patChars, syms, false);
+
+ index = scanFix (pattern, index, buf, patChars, syms, true);
+ negativeSuffix = buf.toString();
+
+ if (index != pattern.length())
+ throw new IllegalArgumentException ("end of pattern expected " +
+ "- index: " + index);
+ }
+ }
public void applyLocalizedPattern (String pattern)
- {
- // JCL p. 638 claims this throws a ParseException but p. 629
- // contradicts this. Empirical tests with patterns of "0,###.0"
- // and "#.#.#" corroborate the p. 629 statement that an
- // IllegalArgumentException is thrown.
- applyPatternWithSymbols (pattern, symbols);
- }
+ {
+ // JCL p. 638 claims this throws a ParseException but p. 629
+ // contradicts this. Empirical tests with patterns of "0,###.0"
+ // and "#.#.#" corroborate the p. 629 statement that an
+ // IllegalArgumentException is thrown.
+ applyPatternWithSymbols (pattern, symbols);
+ }
public void applyPattern (String pattern)
- {
- // JCL p. 638 claims this throws a ParseException but p. 629
- // contradicts this. Empirical tests with patterns of "0,###.0"
- // and "#.#.#" corroborate the p. 629 statement that an
- // IllegalArgumentException is thrown.
- applyPatternWithSymbols (pattern, nonLocalizedSymbols);
- }
+ {
+ // JCL p. 638 claims this throws a ParseException but p. 629
+ // contradicts this. Empirical tests with patterns of "0,###.0"
+ // and "#.#.#" corroborate the p. 629 statement that an
+ // IllegalArgumentException is thrown.
+ applyPatternWithSymbols (pattern, nonLocalizedSymbols);
+ }
public Object clone ()
- {
- return new DecimalFormat (this);
- }
+ {
+ return new DecimalFormat (this);
+ }
private DecimalFormat (DecimalFormat dup)
- {
- decimalSeparatorAlwaysShown = dup.decimalSeparatorAlwaysShown;
- groupingSize = dup.groupingSize;
- minExponentDigits = dup.minExponentDigits;
- multiplier = dup.multiplier;
- negativePrefix = dup.negativePrefix;
- negativeSuffix = dup.negativeSuffix;
- positivePrefix = dup.positivePrefix;
- positiveSuffix = dup.positiveSuffix;
- symbols = (DecimalFormatSymbols) dup.symbols.clone();
- useExponentialNotation = dup.useExponentialNotation;
- }
+ {
+ decimalSeparatorAlwaysShown = dup.decimalSeparatorAlwaysShown;
+ groupingSize = dup.groupingSize;
+ minExponentDigits = dup.minExponentDigits;
+ multiplier = dup.multiplier;
+ negativePrefix = dup.negativePrefix;
+ negativeSuffix = dup.negativeSuffix;
+ positivePrefix = dup.positivePrefix;
+ positiveSuffix = dup.positiveSuffix;
+ symbols = (DecimalFormatSymbols) dup.symbols.clone();
+ useExponentialNotation = dup.useExponentialNotation;
+ }
public DecimalFormat ()
- {
- this ("#,##0.###");
- }
+ {
+ this ("#,##0.###");
+ }
public DecimalFormat (String pattern)
- {
- this (pattern, new DecimalFormatSymbols ());
- }
+ {
+ this (pattern, new DecimalFormatSymbols ());
+ }
public DecimalFormat (String pattern, DecimalFormatSymbols symbols)
- {
- this.symbols = symbols;
- applyPattern (pattern);
- }
+ {
+ this.symbols = symbols;
+ applyPattern (pattern);
+ }
private final boolean equals (String s1, String s2)
- {
- if (s1 == null || s2 == null)
- return s1 == s2;
- return s1.equals(s2);
- }
+ {
+ if (s1 == null || s2 == null)
+ return s1 == s2;
+ return s1.equals(s2);
+ }
public boolean equals (Object obj)
- {
- if (! (obj instanceof DecimalFormat))
- return false;
- DecimalFormat dup = (DecimalFormat) obj;
- return (decimalSeparatorAlwaysShown == dup.decimalSeparatorAlwaysShown
- && groupingSize == dup.groupingSize
- && minExponentDigits == dup.minExponentDigits
- && multiplier == dup.multiplier
- && equals(negativePrefix, dup.negativePrefix)
- && equals(negativeSuffix, dup.negativeSuffix)
- && equals(positivePrefix, dup.positivePrefix)
- && equals(positiveSuffix, dup.positiveSuffix)
- && symbols.equals(dup.symbols)
- && useExponentialNotation == dup.useExponentialNotation);
- }
+ {
+ if (! (obj instanceof DecimalFormat))
+ return false;
+ DecimalFormat dup = (DecimalFormat) obj;
+ return (decimalSeparatorAlwaysShown == dup.decimalSeparatorAlwaysShown
+ && groupingSize == dup.groupingSize
+ && minExponentDigits == dup.minExponentDigits
+ && multiplier == dup.multiplier
+ && equals(negativePrefix, dup.negativePrefix)
+ && equals(negativeSuffix, dup.negativeSuffix)
+ && equals(positivePrefix, dup.positivePrefix)
+ && equals(positiveSuffix, dup.positiveSuffix)
+ && symbols.equals(dup.symbols)
+ && useExponentialNotation == dup.useExponentialNotation);
+ }
public StringBuffer format (double number, StringBuffer dest,
FieldPosition fieldPos)
- {
- // A very special case.
- if (Double.isNaN(number))
- {
- dest.append(symbols.getNaN());
- if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
- {
- int index = dest.length();
- fieldPos.setBeginIndex(index - symbols.getNaN().length());
- fieldPos.setEndIndex(index);
- }
- return dest;
- }
-
- boolean is_neg = number < 0;
- if (is_neg)
- {
- if (negativePrefix != null)
- dest.append(negativePrefix);
- else
- {
- dest.append(symbols.getMinusSign());
- dest.append(positivePrefix);
- }
- number = - number;
- }
- else
- dest.append(positivePrefix);
-
- int integerBeginIndex = dest.length();
- int integerEndIndex = 0;
- if (Double.isInfinite (number))
- {
- dest.append(symbols.getInfinity());
- integerEndIndex = dest.length();
- }
- else
- {
- number *= multiplier;
-
- // Compute exponent.
- long exponent = 0;
- double baseNumber;
- if (useExponentialNotation)
- {
- exponent = (long) (Math.log(number) / Math.log(10));
- if (minimumIntegerDigits > 0)
- exponent -= minimumIntegerDigits - 1;
- baseNumber = (long) (number / Math.pow(10.0, exponent));
- }
- else
- baseNumber = number;
-
- // Round to the correct number of digits.
- baseNumber += 5 * Math.pow(10.0, - maximumFractionDigits - 1);
-
- int index = dest.length();
- double intPart = Math.floor(baseNumber);
- int count = 0;
- while (count < maximumIntegerDigits
- && (intPart > 0 || count < minimumIntegerDigits))
- {
- long dig = (long) (intPart % 10);
- intPart = Math.floor(intPart / 10);
-
- // Append group separator if required.
- if (groupingUsed && count > 0 && count % groupingSize == 0)
- dest.insert(index, symbols.getGroupingSeparator());
-
- dest.insert(index, (char) (symbols.getZeroDigit() + dig));
-
- ++count;
- }
-
- integerEndIndex = dest.length();
-
- int decimal_index = integerEndIndex;
- int consecutive_zeros = 0;
- int total_digits = 0;
-
- // Strip integer part from NUMBER.
- double fracPart = baseNumber - Math.floor(baseNumber);
- for (count = 0;
- count < maximumFractionDigits
- && (fracPart != 0 || count < minimumFractionDigits);
- ++count)
- {
- ++total_digits;
- fracPart *= 10;
- long dig = (long) fracPart;
- if (dig == 0)
- ++consecutive_zeros;
- else
- consecutive_zeros = 0;
- dest.append((char) (symbols.getZeroDigit() + dig));
-
- // Strip integer part from FRACPART.
- fracPart = fracPart - Math.floor (fracPart);
- }
-
- // Strip extraneous trailing `0's. We can't always detect
- // these in the loop.
- int extra_zeros = Math.min (consecutive_zeros,
- total_digits - minimumFractionDigits);
- if (extra_zeros > 0)
- {
- dest.setLength(dest.length() - extra_zeros);
- total_digits -= extra_zeros;
- }
-
- // If required, add the decimal symbol.
- if (decimalSeparatorAlwaysShown
- || total_digits > 0)
- {
- dest.insert(decimal_index, symbols.getDecimalSeparator());
- if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
- {
- fieldPos.setBeginIndex(decimal_index + 1);
- fieldPos.setEndIndex(dest.length());
- }
- }
-
- // Finally, print the exponent.
- if (useExponentialNotation)
- {
- dest.append(symbols.getExponential());
- dest.append(exponent < 0 ? '-' : '+');
- index = dest.length();
- for (count = 0;
- exponent > 0 || count < minExponentDigits;
- ++count)
- {
- long dig = exponent % 10;
- exponent /= 10;
- dest.insert(index, (char) (symbols.getZeroDigit() + dig));
- }
- }
- }
-
- if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
- {
- fieldPos.setBeginIndex(integerBeginIndex);
- fieldPos.setEndIndex(integerEndIndex);
- }
-
- dest.append((is_neg && negativeSuffix != null)
- ? negativeSuffix
- : positiveSuffix);
- return dest;
- }
+ {
+ // A very special case.
+ if (Double.isNaN(number))
+ {
+ dest.append(symbols.getNaN());
+ if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
+ {
+ int index = dest.length();
+ fieldPos.setBeginIndex(index - symbols.getNaN().length());
+ fieldPos.setEndIndex(index);
+ }
+ return dest;
+ }
+
+ boolean is_neg = number < 0;
+ if (is_neg)
+ {
+ if (negativePrefix != null)
+ dest.append(negativePrefix);
+ else
+ {
+ dest.append(symbols.getMinusSign());
+ dest.append(positivePrefix);
+ }
+ number = - number;
+ }
+ else
+ dest.append(positivePrefix);
+
+ int integerBeginIndex = dest.length();
+ int integerEndIndex = 0;
+ if (Double.isInfinite (number))
+ {
+ dest.append(symbols.getInfinity());
+ integerEndIndex = dest.length();
+ }
+ else
+ {
+ number *= multiplier;
+
+ // Compute exponent.
+ long exponent = 0;
+ double baseNumber;
+ if (useExponentialNotation)
+ {
+ exponent = (long) (Math.log(number) / Math.log(10));
+ if (minimumIntegerDigits > 0)
+ exponent -= minimumIntegerDigits - 1;
+ baseNumber = (long) (number / Math.pow(10.0, exponent));
+ }
+ else
+ baseNumber = number;
+
+ // Round to the correct number of digits.
+ baseNumber += 5 * Math.pow(10.0, - maximumFractionDigits - 1);
+
+ int index = dest.length();
+ double intPart = Math.floor(baseNumber);
+ int count = 0;
+ while (count < maximumIntegerDigits
+ && (intPart > 0 || count < minimumIntegerDigits))
+ {
+ long dig = (long) (intPart % 10);
+ intPart = Math.floor(intPart / 10);
+
+ // Append group separator if required.
+ if (groupingUsed && count > 0 && count % groupingSize == 0)
+ dest.insert(index, symbols.getGroupingSeparator());
+
+ dest.insert(index, (char) (symbols.getZeroDigit() + dig));
+
+ ++count;
+ }
+
+ integerEndIndex = dest.length();
+
+ int decimal_index = integerEndIndex;
+ int consecutive_zeros = 0;
+ int total_digits = 0;
+
+ // Strip integer part from NUMBER.
+ double fracPart = baseNumber - Math.floor(baseNumber);
+ for (count = 0;
+ count < maximumFractionDigits
+ && (fracPart != 0 || count < minimumFractionDigits);
+ ++count)
+ {
+ ++total_digits;
+ fracPart *= 10;
+ long dig = (long) fracPart;
+ if (dig == 0)
+ ++consecutive_zeros;
+ else
+ consecutive_zeros = 0;
+ dest.append((char) (symbols.getZeroDigit() + dig));
+
+ // Strip integer part from FRACPART.
+ fracPart = fracPart - Math.floor (fracPart);
+ }
+
+ // Strip extraneous trailing `0's. We can't always detect
+ // these in the loop.
+ int extra_zeros = Math.min (consecutive_zeros,
+ total_digits - minimumFractionDigits);
+ if (extra_zeros > 0)
+ {
+ dest.setLength(dest.length() - extra_zeros);
+ total_digits -= extra_zeros;
+ }
+
+ // If required, add the decimal symbol.
+ if (decimalSeparatorAlwaysShown
+ || total_digits > 0)
+ {
+ dest.insert(decimal_index, symbols.getDecimalSeparator());
+ if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
+ {
+ fieldPos.setBeginIndex(decimal_index + 1);
+ fieldPos.setEndIndex(dest.length());
+ }
+ }
+
+ // Finally, print the exponent.
+ if (useExponentialNotation)
+ {
+ dest.append(symbols.getExponential());
+ dest.append(exponent < 0 ? '-' : '+');
+ index = dest.length();
+ for (count = 0;
+ exponent > 0 || count < minExponentDigits;
+ ++count)
+ {
+ long dig = exponent % 10;
+ exponent /= 10;
+ dest.insert(index, (char) (symbols.getZeroDigit() + dig));
+ }
+ }
+ }
+
+ if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
+ {
+ fieldPos.setBeginIndex(integerBeginIndex);
+ fieldPos.setEndIndex(integerEndIndex);
+ }
+
+ dest.append((is_neg && negativeSuffix != null)
+ ? negativeSuffix
+ : positiveSuffix);
+ return dest;
+ }
public StringBuffer format (long number, StringBuffer dest,
FieldPosition fieldPos)
- {
- // If using exponential notation, we just format as a double.
- if (useExponentialNotation)
- return format ((double) number, dest, fieldPos);
-
- boolean is_neg = number < 0;
- if (is_neg)
- {
- if (negativePrefix != null)
- dest.append(negativePrefix);
- else
- {
- dest.append(symbols.getMinusSign());
- dest.append(positivePrefix);
- }
- number = - number;
- }
- else
- dest.append(positivePrefix);
-
- int integerBeginIndex = dest.length();
- int index = dest.length();
- int count = 0;
- while (count < maximumIntegerDigits
- && (number > 0 || count < minimumIntegerDigits))
- {
- long dig = number % 10;
- number /= 10;
- // NUMBER and DIG will be less than 0 if the original number
- // was the most negative long.
- if (dig < 0)
- {
- dig = - dig;
- number = - number;
- }
-
- // Append group separator if required.
- if (groupingUsed && count > 0 && count % groupingSize == 0)
- dest.insert(index, symbols.getGroupingSeparator());
-
- dest.insert(index, (char) (symbols.getZeroDigit() + dig));
-
- ++count;
- }
-
- if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
- {
- fieldPos.setBeginIndex(integerBeginIndex);
- fieldPos.setEndIndex(dest.length());
- }
-
- if (decimalSeparatorAlwaysShown || minimumFractionDigits > 0)
- {
- dest.append(symbols.getDecimalSeparator());
- if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
- {
- fieldPos.setBeginIndex(dest.length());
- fieldPos.setEndIndex(dest.length() + minimumFractionDigits);
- }
- }
-
- for (count = 0; count < minimumFractionDigits; ++count)
- dest.append(symbols.getZeroDigit());
-
- dest.append((is_neg && negativeSuffix != null)
- ? negativeSuffix
- : positiveSuffix);
- return dest;
- }
+ {
+ // If using exponential notation, we just format as a double.
+ if (useExponentialNotation)
+ return format ((double) number, dest, fieldPos);
+
+ boolean is_neg = number < 0;
+ if (is_neg)
+ {
+ if (negativePrefix != null)
+ dest.append(negativePrefix);
+ else
+ {
+ dest.append(symbols.getMinusSign());
+ dest.append(positivePrefix);
+ }
+ number = - number;
+ }
+ else
+ dest.append(positivePrefix);
+
+ int integerBeginIndex = dest.length();
+ int index = dest.length();
+ int count = 0;
+ while (count < maximumIntegerDigits
+ && (number > 0 || count < minimumIntegerDigits))
+ {
+ long dig = number % 10;
+ number /= 10;
+ // NUMBER and DIG will be less than 0 if the original number
+ // was the most negative long.
+ if (dig < 0)
+ {
+ dig = - dig;
+ number = - number;
+ }
+
+ // Append group separator if required.
+ if (groupingUsed && count > 0 && count % groupingSize == 0)
+ dest.insert(index, symbols.getGroupingSeparator());
+
+ dest.insert(index, (char) (symbols.getZeroDigit() + dig));
+
+ ++count;
+ }
+
+ if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
+ {
+ fieldPos.setBeginIndex(integerBeginIndex);
+ fieldPos.setEndIndex(dest.length());
+ }
+
+ if (decimalSeparatorAlwaysShown || minimumFractionDigits > 0)
+ {
+ dest.append(symbols.getDecimalSeparator());
+ if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
+ {
+ fieldPos.setBeginIndex(dest.length());
+ fieldPos.setEndIndex(dest.length() + minimumFractionDigits);
+ }
+ }
+
+ for (count = 0; count < minimumFractionDigits; ++count)
+ dest.append(symbols.getZeroDigit());
+
+ dest.append((is_neg && negativeSuffix != null)
+ ? negativeSuffix
+ : positiveSuffix);
+ return dest;
+ }
public DecimalFormatSymbols getDecimalFormatSymbols ()
- {
- return symbols;
- }
+ {
+ return symbols;
+ }
public int getGroupingSize ()
- {
- return groupingSize;
- }
+ {
+ return groupingSize;
+ }
public int getMultiplier ()
- {
- return multiplier;
- }
+ {
+ return multiplier;
+ }
public String getNegativePrefix ()
- {
- return negativePrefix;
- }
+ {
+ return negativePrefix;
+ }
public String getNegativeSuffix ()
- {
- return negativeSuffix;
- }
+ {
+ return negativeSuffix;
+ }
public String getPositivePrefix ()
- {
- return positivePrefix;
- }
+ {
+ return positivePrefix;
+ }
public String getPositiveSuffix ()
- {
- return positiveSuffix;
- }
+ {
+ return positiveSuffix;
+ }
public int hashCode ()
- {
- int hash = (negativeSuffix.hashCode() ^ negativePrefix.hashCode()
- ^positivePrefix.hashCode() ^ positiveSuffix.hashCode());
- // FIXME.
- return hash;
- }
+ {
+ int hash = (negativeSuffix.hashCode() ^ negativePrefix.hashCode()
+ ^positivePrefix.hashCode() ^ positiveSuffix.hashCode());
+ // FIXME.
+ return hash;
+ }
public boolean isDecimalSeparatorAlwaysShown ()
- {
- return decimalSeparatorAlwaysShown;
- }
+ {
+ return decimalSeparatorAlwaysShown;
+ }
public Number parse (String str, ParsePosition pos)
- {
- // Our strategy is simple: copy the text into a buffer,
- // translating or omitting locale-specific information. Then
- // let Double or Long convert the number for us.
+ {
+ // Our strategy is simple: copy the text into a buffer,
+ // translating or omitting locale-specific information. Then
+ // let Double or Long convert the number for us.
- boolean is_neg = false;
- int index = pos.getIndex();
- StringBuffer buf = new StringBuffer ();
+ boolean is_neg = false;
+ int index = pos.getIndex();
+ StringBuffer buf = new StringBuffer ();
// We have to check both prefixes, because one might be empty.
// We want to pick the longest prefix that matches.
- boolean got_pos = str.startsWith(positivePrefix, index);
- String np = (negativePrefix != null
- ? negativePrefix
- : positivePrefix + symbols.getMinusSign());
- boolean got_neg = str.startsWith(np, index);
-
- if (got_pos && got_neg)
- {
- // By checking this way, we preserve ambiguity in the case
- // where the negative format differs only in suffix. We
- // check this again later.
- if (np.length() > positivePrefix.length())
- {
- is_neg = true;
- index += np.length();
- }
- else
- index += positivePrefix.length();
- }
- else if (got_neg)
- {
- is_neg = true;
- index += np.length();
- }
- else if (got_pos)
- index += positivePrefix.length();
- else
- {
- pos.setErrorIndex (index);
- return null;
- }
-
- // FIXME: handle Inf and NaN.
+ boolean got_pos = str.startsWith(positivePrefix, index);
+ String np = (negativePrefix != null
+ ? negativePrefix
+ : positivePrefix + symbols.getMinusSign());
+ boolean got_neg = str.startsWith(np, index);
+
+ if (got_pos && got_neg)
+ {
+ // By checking this way, we preserve ambiguity in the case
+ // where the negative format differs only in suffix. We
+ // check this again later.
+ if (np.length() > positivePrefix.length())
+ {
+ is_neg = true;
+ index += np.length();
+ }
+ else
+ index += positivePrefix.length();
+ }
+ else if (got_neg)
+ {
+ is_neg = true;
+ index += np.length();
+ }
+ else if (got_pos)
+ index += positivePrefix.length();
+ else
+ {
+ pos.setErrorIndex (index);
+ return null;
+ }
+
+ // FIXME: handle Inf and NaN.
// FIXME: do we have to respect minimum/maxmimum digit stuff?
// What about leading zeros? What about multiplier?
- int start_index = index;
- int max = str.length();
- char zero = symbols.getZeroDigit();
- int last_group = -1;
- boolean int_part = true;
- boolean exp_part = false;
- for (; index < max; ++index)
- {
- char c = str.charAt(index);
-
- // FIXME: what about grouping size?
- if (groupingUsed && c == symbols.getGroupingSeparator())
- {
- if (last_group != -1
- && (index - last_group) % groupingSize != 0)
- {
- pos.setErrorIndex(index);
- return null;
- }
- last_group = index;
- }
- else if (c >= zero && c <= zero + 9)
- {
- buf.append((char) (c - zero + '0'));
- exp_part = false;
- }
- else if (parseIntegerOnly)
- break;
- else if (c == symbols.getDecimalSeparator())
- {
- if (last_group != -1
- && (index - last_group) % groupingSize != 0)
- {
- pos.setErrorIndex(index);
- return null;
- }
- buf.append('.');
- int_part = false;
- }
- else if (c == symbols.getExponential())
- {
- buf.append('E');
- int_part = false;
- exp_part = true;
- }
- else if (exp_part
- && (c == '+' || c == '-' || c == symbols.getMinusSign()))
- {
- // For exponential notation.
- buf.append(c);
- }
- else
- break;
- }
-
- if (index == start_index)
- {
- // Didn't see any digits.
- pos.setErrorIndex(index);
- return null;
- }
-
- // Check the suffix. We must do this before converting the
- // buffer to a number to handle the case of a number which is
- // the most negative Long.
- boolean got_pos_suf = str.startsWith(positiveSuffix, index);
- String ns = (negativePrefix == null ? positiveSuffix : negativeSuffix);
- boolean got_neg_suf = str.startsWith(ns, index);
- if (is_neg)
- {
- if (! got_neg_suf)
- {
- pos.setErrorIndex(index);
- return null;
- }
- }
- else if (got_pos && got_neg && got_neg_suf)
- {
- is_neg = true;
- }
- else if (got_pos != got_pos_suf && got_neg != got_neg_suf)
- {
- pos.setErrorIndex(index);
- return null;
- }
-
- String suffix = is_neg ? ns : positiveSuffix;
- if (is_neg)
- buf.insert(0, '-');
-
- String t = buf.toString();
- Number result = null;
- try
- {
- result = new Long (t);
- }
- catch (NumberFormatException x1)
- {
- try
- {
- result = new Double (t);
- }
- catch (NumberFormatException x2)
- {
- }
- }
- if (result == null)
- {
- pos.setErrorIndex(index);
- return null;
- }
-
- pos.setIndex(index + suffix.length());
-
- return result;
- }
+ int start_index = index;
+ int max = str.length();
+ char zero = symbols.getZeroDigit();
+ int last_group = -1;
+ boolean int_part = true;
+ boolean exp_part = false;
+ for (; index < max; ++index)
+ {
+ char c = str.charAt(index);
+
+ // FIXME: what about grouping size?
+ if (groupingUsed && c == symbols.getGroupingSeparator())
+ {
+ if (last_group != -1
+ && (index - last_group) % groupingSize != 0)
+ {
+ pos.setErrorIndex(index);
+ return null;
+ }
+ last_group = index;
+ }
+ else if (c >= zero && c <= zero + 9)
+ {
+ buf.append((char) (c - zero + '0'));
+ exp_part = false;
+ }
+ else if (parseIntegerOnly)
+ break;
+ else if (c == symbols.getDecimalSeparator())
+ {
+ if (last_group != -1
+ && (index - last_group) % groupingSize != 0)
+ {
+ pos.setErrorIndex(index);
+ return null;
+ }
+ buf.append('.');
+ int_part = false;
+ }
+ else if (c == symbols.getExponential())
+ {
+ buf.append('E');
+ int_part = false;
+ exp_part = true;
+ }
+ else if (exp_part
+ && (c == '+' || c == '-' || c == symbols.getMinusSign()))
+ {
+ // For exponential notation.
+ buf.append(c);
+ }
+ else
+ break;
+ }
+
+ if (index == start_index)
+ {
+ // Didn't see any digits.
+ pos.setErrorIndex(index);
+ return null;
+ }
+
+ // Check the suffix. We must do this before converting the
+ // buffer to a number to handle the case of a number which is
+ // the most negative Long.
+ boolean got_pos_suf = str.startsWith(positiveSuffix, index);
+ String ns = (negativePrefix == null ? positiveSuffix : negativeSuffix);
+ boolean got_neg_suf = str.startsWith(ns, index);
+ if (is_neg)
+ {
+ if (! got_neg_suf)
+ {
+ pos.setErrorIndex(index);
+ return null;
+ }
+ }
+ else if (got_pos && got_neg && got_neg_suf)
+ {
+ is_neg = true;
+ }
+ else if (got_pos != got_pos_suf && got_neg != got_neg_suf)
+ {
+ pos.setErrorIndex(index);
+ return null;
+ }
+
+ String suffix = is_neg ? ns : positiveSuffix;
+ if (is_neg)
+ buf.insert(0, '-');
+
+ String t = buf.toString();
+ Number result = null;
+ try
+ {
+ result = new Long (t);
+ }
+ catch (NumberFormatException x1)
+ {
+ try
+ {
+ result = new Double (t);
+ }
+ catch (NumberFormatException x2)
+ {
+ }
+ }
+ if (result == null)
+ {
+ pos.setErrorIndex(index);
+ return null;
+ }
+
+ pos.setIndex(index + suffix.length());
+
+ return result;
+ }
public void setDecimalFormatSymbols (DecimalFormatSymbols newSymbols)
- {
- symbols = newSymbols;
- }
+ {
+ symbols = newSymbols;
+ }
public void setDecimalSeparatorAlwaysShown (boolean newValue)
- {
- decimalSeparatorAlwaysShown = newValue;
- }
+ {
+ decimalSeparatorAlwaysShown = newValue;
+ }
public void setGroupingSize (int groupSize)
- {
- groupingSize = (byte) groupSize;
- }
+ {
+ groupingSize = (byte) groupSize;
+ }
public void setMaximumFractionDigits (int newValue)
- {
- maximumFractionDigits = Math.min(newValue, 340);
- }
+ {
+ maximumFractionDigits = Math.min(newValue, 340);
+ }
public void setMaximumIntegerDigits (int newValue)
- {
- maximumIntegerDigits = Math.min(newValue, 309);
- }
+ {
+ maximumIntegerDigits = Math.min(newValue, 309);
+ }
public void setMinimumFractionDigits (int newValue)
- {
- minimumFractionDigits = Math.min(newValue, 340);
- }
+ {
+ minimumFractionDigits = Math.min(newValue, 340);
+ }
public void setMinimumIntegerDigits (int newValue)
- {
- minimumIntegerDigits = Math.min(newValue, 309);
- }
+ {
+ minimumIntegerDigits = Math.min(newValue, 309);
+ }
public void setMultiplier (int newValue)
- {
- multiplier = newValue;
- }
+ {
+ multiplier = newValue;
+ }
public void setNegativePrefix (String newValue)
- {
- negativePrefix = newValue;
- }
+ {
+ negativePrefix = newValue;
+ }
public void setNegativeSuffix (String newValue)
- {
- negativeSuffix = newValue;
- }
+ {
+ negativeSuffix = newValue;
+ }
public void setPositivePrefix (String newValue)
- {
- positivePrefix = newValue;
- }
+ {
+ positivePrefix = newValue;
+ }
public void setPositiveSuffix (String newValue)
- {
- positiveSuffix = newValue;
- }
+ {
+ positiveSuffix = newValue;
+ }
private final void quoteFix (StringBuffer buf, String text, String patChars)
- {
- int len = text.length();
- for (int index = 0; index < len; ++index)
- {
- char c = text.charAt(index);
- if (patChars.indexOf(c) != -1)
- {
- buf.append('\'');
- buf.append(c);
- buf.append('\'');
- }
- else
+ {
+ int len = text.length();
+ for (int index = 0; index < len; ++index)
+ {
+ char c = text.charAt(index);
+ if (patChars.indexOf(c) != -1)
+ {
+ buf.append('\'');
buf.append(c);
- }
- }
+ buf.append('\'');
+ }
+ else
+ buf.append(c);
+ }
+ }
private final String computePattern (DecimalFormatSymbols syms)
- {
- StringBuffer mainPattern = new StringBuffer ();
- // We have to at least emit a zero for the minimum number of
- // digits. Past that we need hash marks up to the grouping
- // separator (and one beyond).
- int total_digits = Math.max(minimumIntegerDigits,
- groupingUsed ? groupingSize + 1: 0);
- for (int i = 0; i < total_digits - minimumIntegerDigits; ++i)
- mainPattern.append(syms.getDigit());
- for (int i = total_digits - minimumIntegerDigits; i < total_digits; ++i)
- mainPattern.append(syms.getZeroDigit());
- // Inserting the gropuing operator afterwards is easier.
- if (groupingUsed)
- mainPattern.insert(mainPattern.length() - groupingSize,
- syms.getGroupingSeparator());
- // See if we need decimal info.
- if (minimumFractionDigits > 0 || maximumFractionDigits > 0
- || decimalSeparatorAlwaysShown)
- mainPattern.append(syms.getDecimalSeparator());
- for (int i = 0; i < minimumFractionDigits; ++i)
- mainPattern.append(syms.getZeroDigit());
- for (int i = minimumFractionDigits; i < maximumFractionDigits; ++i)
- mainPattern.append(syms.getDigit());
- if (useExponentialNotation)
- {
- mainPattern.append(syms.getExponential());
- for (int i = 0; i < minExponentDigits; ++i)
- mainPattern.append(syms.getZeroDigit());
- if (minExponentDigits == 0)
- mainPattern.append(syms.getDigit());
- }
-
- String main = mainPattern.toString();
- String patChars = patternChars (syms);
- mainPattern.setLength(0);
-
- quoteFix (mainPattern, positivePrefix, patChars);
- mainPattern.append(main);
- quoteFix (mainPattern, positiveSuffix, patChars);
-
- if (negativePrefix != null)
- {
- quoteFix (mainPattern, negativePrefix, patChars);
- mainPattern.append(main);
- quoteFix (mainPattern, negativeSuffix, patChars);
- }
-
- return mainPattern.toString();
- }
+ {
+ StringBuffer mainPattern = new StringBuffer ();
+ // We have to at least emit a zero for the minimum number of
+ // digits. Past that we need hash marks up to the grouping
+ // separator (and one beyond).
+ int total_digits = Math.max(minimumIntegerDigits,
+ groupingUsed ? groupingSize + 1: 0);
+ for (int i = 0; i < total_digits - minimumIntegerDigits; ++i)
+ mainPattern.append(syms.getDigit());
+ for (int i = total_digits - minimumIntegerDigits; i < total_digits; ++i)
+ mainPattern.append(syms.getZeroDigit());
+ // Inserting the gropuing operator afterwards is easier.
+ if (groupingUsed)
+ mainPattern.insert(mainPattern.length() - groupingSize,
+ syms.getGroupingSeparator());
+ // See if we need decimal info.
+ if (minimumFractionDigits > 0 || maximumFractionDigits > 0
+ || decimalSeparatorAlwaysShown)
+ mainPattern.append(syms.getDecimalSeparator());
+ for (int i = 0; i < minimumFractionDigits; ++i)
+ mainPattern.append(syms.getZeroDigit());
+ for (int i = minimumFractionDigits; i < maximumFractionDigits; ++i)
+ mainPattern.append(syms.getDigit());
+ if (useExponentialNotation)
+ {
+ mainPattern.append(syms.getExponential());
+ for (int i = 0; i < minExponentDigits; ++i)
+ mainPattern.append(syms.getZeroDigit());
+ if (minExponentDigits == 0)
+ mainPattern.append(syms.getDigit());
+ }
+
+ String main = mainPattern.toString();
+ String patChars = patternChars (syms);
+ mainPattern.setLength(0);
+
+ quoteFix (mainPattern, positivePrefix, patChars);
+ mainPattern.append(main);
+ quoteFix (mainPattern, positiveSuffix, patChars);
+
+ if (negativePrefix != null)
+ {
+ quoteFix (mainPattern, negativePrefix, patChars);
+ mainPattern.append(main);
+ quoteFix (mainPattern, negativeSuffix, patChars);
+ }
+
+ return mainPattern.toString();
+ }
public String toLocalizedPattern ()
- {
- return computePattern (symbols);
- }
+ {
+ return computePattern (symbols);
+ }
public String toPattern ()
- {
- return computePattern (nonLocalizedSymbols);
- }
+ {
+ return computePattern (nonLocalizedSymbols);
+ }
// These names are fixed by the serialization spec.
private boolean decimalSeparatorAlwaysShown;
-// DecimalFormatSymbols.java - Symbols used to format numbers.
+/* DecimalFormatSymbols.java -- Format symbols used by DecimalFormat
+ Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999, 2000 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
import java.io.IOException;
/**
+ * This class is a container for the symbols used by
+ * <code>DecimalFormat</code> to format numbers and currency. These are
+ * normally handled automatically, but an application can override
+ * values as desired using this class.
+ *
* @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @date February 24, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct to 1.2.
*/
-
public final class DecimalFormatSymbols implements Cloneable, Serializable
{
public Object clone ()
- {
- return new DecimalFormatSymbols (this);
- }
-
- private DecimalFormatSymbols (DecimalFormatSymbols orig)
- {
- this.currencySymbol = orig.currencySymbol;
- this.decimalSeparator = orig.decimalSeparator;
- this.digit = orig.digit;
- this.exponential = orig.exponential;
- this.groupingSeparator = orig.groupingSeparator;
- this.infinity = orig.infinity;
- this.intlCurrencySymbol = orig.intlCurrencySymbol;
- this.monetarySeparator = orig.monetarySeparator;
- this.minusSign = orig.minusSign;
- this.NaN = orig.NaN;
- this.patternSeparator = orig.patternSeparator;
- this.percent = orig.percent;
- this.perMill = orig.perMill;
- this.zeroDigit = orig.zeroDigit;
- }
+ {
+ try
+ {
+ return super.clone ();
+ }
+ catch(CloneNotSupportedException e)
+ {
+ return null;
+ }
+ }
+ /**
+ * This method initializes a new instance of
+ * <code>DecimalFormatSymbols</code> for the default locale.
+ */
public DecimalFormatSymbols ()
- {
- this (Locale.getDefault());
- }
+ {
+ this (Locale.getDefault());
+ }
private final String safeGetString (ResourceBundle bundle,
String name, String def)
- {
- if (bundle != null)
- {
- try
- {
- return bundle.getString(name);
- }
- catch (MissingResourceException x)
- {
- }
- }
- return def;
- }
+ {
+ if (bundle != null)
+ {
+ try
+ {
+ return bundle.getString(name);
+ }
+ catch (MissingResourceException x)
+ {
+ }
+ }
+ return def;
+ }
private final char safeGetChar (ResourceBundle bundle,
String name, char def)
- {
- String r = null;
- if (bundle != null)
- {
- try
- {
- r = bundle.getString(name);
- }
- catch (MissingResourceException x)
- {
- }
- }
- if (r == null || r.length() < 1)
- return def;
- return r.charAt(0);
- }
+ {
+ String r = null;
+ if (bundle != null)
+ {
+ try
+ {
+ r = bundle.getString(name);
+ }
+ catch (MissingResourceException x)
+ {
+ }
+ }
+ if (r == null || r.length() < 1)
+ return def;
+ return r.charAt(0);
+ }
+ /**
+ * This method initializes a new instance of
+ * <code>DecimalFormatSymbols</code> for the specified locale.
+ *
+ * @param locale The local to load symbols for.
+ */
public DecimalFormatSymbols (Locale loc)
- {
- ResourceBundle res;
- try
- {
- res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
- }
- catch (MissingResourceException x)
- {
- res = null;
- }
- currencySymbol = safeGetString (res, "currencySymbol", "$");
- decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
- digit = safeGetChar (res, "digit", '#');
- exponential = safeGetChar (res, "exponential", 'E');
- groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
- infinity = safeGetString (res, "infinity", "\u221e");
- // FIXME: default?
- intlCurrencySymbol = safeGetString (res, "intlCurrencySymbol", "$");
- try
- {
- monetarySeparator = safeGetChar (res, "monetarySeparator", '.');
- }
- catch (MissingResourceException x)
- {
- monetarySeparator = decimalSeparator;
- }
- minusSign = safeGetChar (res, "minusSign", '-');
- NaN = safeGetString (res, "NaN", "\ufffd");
- patternSeparator = safeGetChar (res, "patternSeparator", ';');
- percent = safeGetChar (res, "percent", '%');
- perMill = safeGetChar (res, "perMill", '\u2030');
- zeroDigit = safeGetChar (res, "zeroDigit", '0');
- }
+ {
+ ResourceBundle res;
+ try
+ {
+ res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc);
+ }
+ catch (MissingResourceException x)
+ {
+ res = null;
+ }
+ currencySymbol = safeGetString (res, "currencySymbol", "$");
+ decimalSeparator = safeGetChar (res, "decimalSeparator", '.');
+ digit = safeGetChar (res, "digit", '#');
+ exponential = safeGetChar (res, "exponential", 'E');
+ groupingSeparator = safeGetChar (res, "groupingSeparator", ',');
+ infinity = safeGetString (res, "infinity", "\u221e");
+ // FIXME: default?
+ intlCurrencySymbol = safeGetString (res, "intlCurrencySymbol", "$");
+ try
+ {
+ monetarySeparator = safeGetChar (res, "monetarySeparator", '.');
+ }
+ catch (MissingResourceException x)
+ {
+ monetarySeparator = decimalSeparator;
+ }
+ minusSign = safeGetChar (res, "minusSign", '-');
+ NaN = safeGetString (res, "NaN", "\ufffd");
+ patternSeparator = safeGetChar (res, "patternSeparator", ';');
+ percent = safeGetChar (res, "percent", '%');
+ perMill = safeGetChar (res, "perMill", '\u2030');
+ zeroDigit = safeGetChar (res, "zeroDigit", '0');
+ }
+ /**
+ * This method this this object for equality against the specified object.
+ * This will be true if and only if the following criteria are met with
+ * regard to the specified object:
+ * <p>
+ * <ul>
+ * <li>It is not <code>null</code>.
+ * <li>It is an instance of <code>DecimalFormatSymbols</code>
+ * <li>All of its symbols are identical to the symbols in this object.
+ * </ul>
+ *
+ * @return <code>true</code> if the specified object is equal to this
+ * object, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
- {
- if (! (obj instanceof DecimalFormatSymbols))
- return false;
- DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj;
- return (currencySymbol.equals(dfs.currencySymbol)
- && decimalSeparator == dfs.decimalSeparator
- && digit == dfs.digit
- && exponential == dfs.exponential
- && groupingSeparator == dfs.groupingSeparator
- && infinity.equals(dfs.infinity)
- && intlCurrencySymbol.equals(dfs.intlCurrencySymbol)
- && minusSign == dfs.minusSign
- && monetarySeparator == dfs.monetarySeparator
- && NaN.equals(dfs.NaN)
- && patternSeparator == dfs.patternSeparator
- && percent == dfs.percent
- && perMill == dfs.perMill
- && zeroDigit == dfs.zeroDigit);
- }
+ {
+ if (! (obj instanceof DecimalFormatSymbols))
+ return false;
+ DecimalFormatSymbols dfs = (DecimalFormatSymbols) obj;
+ return (currencySymbol.equals(dfs.currencySymbol)
+ && decimalSeparator == dfs.decimalSeparator
+ && digit == dfs.digit
+ && exponential == dfs.exponential
+ && groupingSeparator == dfs.groupingSeparator
+ && infinity.equals(dfs.infinity)
+ && intlCurrencySymbol.equals(dfs.intlCurrencySymbol)
+ && minusSign == dfs.minusSign
+ && monetarySeparator == dfs.monetarySeparator
+ && NaN.equals(dfs.NaN)
+ && patternSeparator == dfs.patternSeparator
+ && percent == dfs.percent
+ && perMill == dfs.perMill
+ && zeroDigit == dfs.zeroDigit);
+ }
+ /**
+ * This method returns the currency symbol in local format. For example,
+ * "$" for Canadian dollars.
+ *
+ * @return The currency symbol in local format.
+ */
public String getCurrencySymbol ()
- {
- return currencySymbol;
- }
+ {
+ return currencySymbol;
+ }
+ /**
+ * This method returns the character used as the decimal point.
+ *
+ * @return The character used as the decimal point.
+ */
public char getDecimalSeparator ()
- {
- return decimalSeparator;
- }
+ {
+ return decimalSeparator;
+ }
+ /**
+ * This method returns the character used to represent a digit in a
+ * format pattern string.
+ *
+ * @return The character used to represent a digit in a format
+ * pattern string.
+ */
public char getDigit ()
- {
- return digit;
- }
+ {
+ return digit;
+ }
// This is our own extension.
char getExponential ()
- {
- return exponential;
- }
+ {
+ return exponential;
+ }
+ /**
+ * This method sets the character used to separate groups of digits. For
+ * example, the United States uses a comma (,) to separate thousands in
+ * a number.
+ *
+ * @return The character used to separate groups of digits.
+ */
public char getGroupingSeparator ()
- {
- return groupingSeparator;
- }
+ {
+ return groupingSeparator;
+ }
+ /**
+ * This method returns the character used to represent infinity.
+ *
+ * @return The character used to represent infinity.
+ */
public String getInfinity ()
- {
- return infinity;
- }
+ {
+ return infinity;
+ }
+ /**
+ * This method returns the currency symbol in international format. For
+ * example, "C$" for Canadian dollars.
+ *
+ * @return The currency symbol in international format.
+ */
public String getInternationalCurrencySymbol ()
- {
- return intlCurrencySymbol;
- }
+ {
+ return intlCurrencySymbol;
+ }
+ /**
+ * This method returns the character used to represent the minus sign.
+ *
+ * @return The character used to represent the minus sign.
+ */
public char getMinusSign ()
- {
- return minusSign;
- }
+ {
+ return minusSign;
+ }
+ /**
+ * This method returns the character used to represent the decimal
+ * point for currency values.
+ *
+ * @return The decimal point character used in currency values.
+ */
public char getMonetaryDecimalSeparator ()
- {
- return monetarySeparator;
- }
+ {
+ return monetarySeparator;
+ }
+ /**
+ * This method returns the string used to represent the NaN (not a number)
+ * value.
+ *
+ * @return The string used to represent NaN
+ */
public String getNaN ()
- {
- return NaN;
- }
+ {
+ return NaN;
+ }
+ /**
+ * This method returns the character used to separate positive and negative
+ * subpatterns in a format pattern.
+ *
+ * @return The character used to separate positive and negative subpatterns
+ * in a format pattern.
+ */
public char getPatternSeparator ()
- {
- return patternSeparator;
- }
+ {
+ return patternSeparator;
+ }
+ /**
+ * This method returns the character used as the percent sign.
+ *
+ * @return The character used as the percent sign.
+ */
public char getPercent ()
- {
- return percent;
- }
+ {
+ return percent;
+ }
+ /**
+ * This method returns the character used as the per mille character.
+ *
+ * @return The per mille character.
+ */
public char getPerMill ()
- {
- return perMill;
- }
+ {
+ return perMill;
+ }
+ /**
+ * This method returns the character used to represent the digit zero.
+ *
+ * @return The character used to represent the digit zero.
+ */
public char getZeroDigit ()
- {
- return zeroDigit;
- }
+ {
+ return zeroDigit;
+ }
+ /**
+ * This method returns a hash value for this object.
+ *
+ * @return A hash value for this object.
+ */
public int hashCode ()
- {
- // Compute based on zero digit, grouping separator, and decimal
- // separator -- JCL book. This probably isn't a very good hash
- // code.
- return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator;
- }
+ {
+ // Compute based on zero digit, grouping separator, and decimal
+ // separator -- JCL book. This probably isn't a very good hash
+ // code.
+ return zeroDigit << 16 + groupingSeparator << 8 + decimalSeparator;
+ }
+ /**
+ * This method sets the currency symbol to the specified value.
+ *
+ * @param currencySymbol The new currency symbol
+ */
public void setCurrencySymbol (String currency)
- {
- currencySymbol = currency;
- }
+ {
+ currencySymbol = currency;
+ }
+ /**
+ * This method sets the decimal point character to the specified value.
+ *
+ * @param decimalSeparator The new decimal point character
+ */
public void setDecimalSeparator (char decimalSep)
- {
- decimalSeparator = decimalSep;
- }
+ {
+ decimalSeparator = decimalSep;
+ }
+ /**
+ * This method sets the character used to represents a digit in a format
+ * string to the specified value.
+ *
+ * @param digit The character used to represent a digit in a format pattern.
+ */
public void setDigit (char digit)
- {
- this.digit = digit;
- }
+ {
+ this.digit = digit;
+ }
// This is our own extension.
void setExponential (char exp)
- {
- exponential = exp;
- }
+ {
+ exponential = exp;
+ }
+ /**
+ * This method sets the character used to separate groups of digits.
+ *
+ * @param groupingSeparator The character used to separate groups of digits.
+ */
public void setGroupingSeparator (char groupSep)
- {
- groupingSeparator = groupSep;
- }
+ {
+ groupingSeparator = groupSep;
+ }
+ /**
+ * This method sets the string used to represents infinity.
+ *
+ * @param infinity The string used to represent infinity.
+ */
public void setInfinity (String infinity)
- {
- this.infinity = infinity;
- }
+ {
+ this.infinity = infinity;
+ }
+ /**
+ * This method sets the international currency symbols to the
+ * specified value.
+ *
+ * @param intlCurrencySymbol The new international currency symbol.
+ */
public void setInternationalCurrencySymbol (String currency)
- {
- intlCurrencySymbol = currency;
- }
+ {
+ intlCurrencySymbol = currency;
+ }
+ /**
+ * This method sets the character used to represent the minus sign.
+ *
+ * @param minusSign The character used to represent the minus sign.
+ */
public void setMinusSign (char minusSign)
- {
- this.minusSign = minusSign;
- }
+ {
+ this.minusSign = minusSign;
+ }
+ /**
+ * This method sets the character used for the decimal point in currency
+ * values.
+ *
+ * @param monetarySeparator The decimal point character used in
+ * currency values.
+ */
public void setMonetaryDecimalSeparator (char decimalSep)
- {
- monetarySeparator = decimalSep;
- }
+ {
+ monetarySeparator = decimalSep;
+ }
+ /**
+ * This method sets the string used to represent the NaN (not a
+ * number) value.
+ *
+ * @param NaN The string used to represent NaN
+ */
public void setNaN (String nan)
- {
- NaN = nan;
- }
+ {
+ NaN = nan;
+ }
+ /**
+ * This method sets the character used to separate positive and negative
+ * subpatterns in a format pattern.
+ *
+ * @param patternSeparator The character used to separate positive and
+ * negative subpatterns in a format pattern.
+ */
public void setPatternSeparator (char patternSep)
- {
- patternSeparator = patternSep;
- }
+ {
+ patternSeparator = patternSep;
+ }
+ /**
+ * This method sets the character used as the percent sign.
+ *
+ * @param percent The character used as the percent sign.
+ */
public void setPercent (char percent)
- {
- this.percent = percent;
- }
+ {
+ this.percent = percent;
+ }
+ /**
+ * This method sets the character used as the per mille character.
+ *
+ * @param perMill The per mille character.
+ */
public void setPerMill (char perMill)
- {
- this.perMill = perMill;
- }
+ {
+ this.perMill = perMill;
+ }
+ /**
+ * This method sets the charcter used to represen the digit zero.
+ *
+ * @param zeroDigit The character used to represent the digit zero.
+ */
public void setZeroDigit (char zeroDigit)
- {
- this.zeroDigit = zeroDigit;
- }
+ {
+ this.zeroDigit = zeroDigit;
+ }
- // The names of the instance variables are fixed by the
- // serialization spec.
+ /**
+ * @serial A string used for the local currency
+ */
private String currencySymbol;
+ /**
+ * @serial The <code>char</code> used to separate decimals in a number.
+ */
private char decimalSeparator;
+ /**
+ * @serial This is the <code>char</code> used to represent a digit in
+ * a format specification.
+ */
private char digit;
+ /**
+ * @serial This is the <code>char</code> used to represent the exponent
+ * separator in exponential notation.
+ */
private char exponential;
+ /**
+ * @serial This separates groups of thousands in numbers.
+ */
private char groupingSeparator;
+ /**
+ * @serial This string represents infinity.
+ */
private String infinity;
+ /**
+ * @serial This string represents the local currency in an international
+ * context, eg, "C$" for Canadian dollars.
+ */
private String intlCurrencySymbol;
+ /**
+ * @serial This is the character used to represent the minus sign.
+ */
private char minusSign;
+ /**
+ * @serial This character is used to separate decimals when formatting
+ * currency values.
+ */
private char monetarySeparator;
+ /**
+ * @serial This string is used the represent the Java NaN value for
+ * "not a number".
+ */
private String NaN;
+ /**
+ * @serial This is the character used to separate positive and negative
+ * subpatterns in a format pattern.
+ */
private char patternSeparator;
+ /**
+ * @serial This is the percent symbols
+ */
private char percent;
+ /**
+ * @serial This character is used for the mille percent sign.
+ */
private char perMill;
+ /**
+ * @serial This value represents the type of object being de-serialized.
+ * 0 indicates a pre-Java 1.1.6 version, 1 indicates 1.1.6 or later.
+ */
private int serialVersionOnStream = 1;
+ /**
+ * @serial This is the character used to represent 0.
+ */
private char zeroDigit;
+
private static final long serialVersionUID = 5772796243397350300L;
private void readObject(ObjectInputStream stream)
-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* FieldPosition.java -- Keeps track of field positions while formatting
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
/**
+ * This class is used by the java.text formatting classes to track
+ * field positions. A field position is defined by an identifier value
+ * and begin and end index positions. The formatting classes in java.text
+ * typically define constant values for the field identifiers.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @author Per Bothner <bothner@cygnus.com>
- * @date October 25, 1998.
- */
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct.
- * Includes JDK 1.2 methods.
*/
-
public class FieldPosition
{
- int field;
- int beginIndex;
- int endIndex;
+ /**
+ * This is the field identifier value.
+ */
+ private int field_id;
+
+ /**
+ * This is the beginning index of the field.
+ */
+ private int begin;
+
+ /**
+ * This is the ending index of the field.
+ */
+ private int end;
- public FieldPosition (int field)
+ /**
+ * This method initializes a new instance of <code>FieldPosition</code> to
+ * have the specified field id.
+ *
+ * @param field_id The field identifier value.
+ */
+ public FieldPosition (int field_id)
{
- this.field = field;
+ this.field_id = field_id;
}
+ /**
+ * This method returns the field identifier value for this object.
+ *
+ * @return The field identifier.
+ */
public int getField ()
{
- return field;
+ return field_id;
}
+ /**
+ * This method returns the beginning index for this field.
+ *
+ * @return The beginning index.
+ */
public int getBeginIndex ()
{
- return beginIndex;
+ return begin;
}
- public int getEndIndex ()
+ /**
+ * This method sets the beginning index of this field to the specified value.
+ *
+ * @param begin The new beginning index.
+ */
+ public void setBeginIndex (int begin)
{
- return endIndex;
+ this.begin = begin;
}
- public void setBeginIndex (int index)
+ /**
+ * This method returns the ending index for the field.
+ *
+ * @return The ending index.
+ */
+ public int getEndIndex ()
{
- beginIndex = index;
+ return end;
}
- public void setEndIndex (int index)
+ /**
+ * This method sets the ending index of this field to the specified value.
+ *
+ * @param end The new ending index.
+ */
+ public void setEndIndex (int end)
{
- endIndex = index;
+ this.end = end;
}
+ /**
+ * This method tests this object for equality against the specified object.
+ * The objects will be considered equal if and only if:
+ * <p>
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>FieldPosition</code>.
+ * <li>The specified object has the same field identifier and beginning
+ * and ending index as this object.
+ * </ul>
+ *
+ * @param obj The object to test for equality to this object.
+ *
+ * @return <code>true</code> if the specified object is equal to
+ * this object, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
if (! (obj instanceof FieldPosition))
return false;
- FieldPosition other = (FieldPosition) obj;
- return (field == other.field
- && beginIndex == other.beginIndex && endIndex == other.endIndex);
+
+ FieldPosition fp = (FieldPosition) obj;
+ return (field_id == fp.field_id
+ && begin == fp.begin
+ && end == fp.end);
+ }
+
+ /**
+ * This method returns a <code>String</code> representation of this
+ * object.
+ *
+ * @return A <code>String</code> representation of this object.
+ */
+ public String toString ()
+ {
+ return (getClass ().getName () + "[field=" + getField () + ",beginIndex="
+ + getBeginIndex () + ",endIndex=" + getEndIndex () + "]");
}
}
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* Format.java -- Abstract superclass for formatting/parsing strings.
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
+import java.io.Serializable;
+
/**
+ * This class is the abstract superclass of classes that format and parse
+ * data to/from <code>Strings</code>. It is guaranteed that any
+ * <code>String</code> produced by a concrete subclass of <code>Format</code>
+ * will be parseable by that same subclass.
+ * <p>
+ * In addition to implementing the abstract methods in this class, subclasses
+ * should provide static factory methods of the form
+ * <code>getInstance()</code> and <code>getInstance(Locale)</code> if the
+ * subclass loads different formatting/parsing schemes based on locale.
+ * These subclasses should also implement a static method called
+ * <code>getAvailableLocales()</code> which returns an array of
+ * available locales in the current runtime environment.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @author Per Bothner <bothner@cygnus.com>
- * @date October 25, 1998.
- */
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct.
*/
-
-public abstract class Format implements java.io.Serializable, Cloneable
+public abstract class Format implements Serializable, Cloneable
{
+ /**
+ * This method initializes a new instance of <code>Format</code>.
+ * It performs no actions, but acts as a default constructor for
+ * subclasses.
+ */
public Format ()
{
}
- public abstract StringBuffer format (Object obj,
- StringBuffer sbuf, FieldPosition pos);
-
- public final String format (Object obj)
+ /**
+ * This method formats an <code>Object</code> into a <code>String</code>.
+ *
+ * @param obj The <code>Object</code> to format.
+ *
+ * @return The formatted <code>String</code>.
+ *
+ * @exception IllegalArgumentException If the <code>Object</code>
+ * cannot be formatted.
+ */
+ public final String format(Object obj) throws IllegalArgumentException
{
- StringBuffer sbuf = new StringBuffer();
- format(obj, sbuf, new FieldPosition(0));
- return sbuf.toString();
+ StringBuffer sb = new StringBuffer ();
+ format (obj, sb, new FieldPosition (0));
+ return sb.toString ();
}
- public abstract Object parseObject (String source, ParsePosition pos);
+ /**
+ * This method formats an <code>Object</code> into a <code>String</code> and
+ * appends the <code>String</code> to a <code>StringBuffer</code>.
+ *
+ * @param obj The <code>Object</code> to format.
+ * @param sb The <code>StringBuffer</code> to append to.
+ * @param pos The desired <code>FieldPosition</code>, which is also
+ * updated by this call.
+ *
+ * @return The updated <code>StringBuffer</code>.
+ *
+ * @exception IllegalArgumentException If the <code>Object</code>
+ * cannot be formatted.
+ */
+ public abstract StringBuffer format (Object obj, StringBuffer sb,
+ FieldPosition pos)
+ throws IllegalArgumentException;
- public Object parseObject (String source) throws ParseException
+ /**
+ * This method parses a <code>String</code> and converts the parsed
+ * contents into an <code>Object</code>.
+ *
+ * @param str The <code>String to parse.
+ *
+ * @return The resulting <code>Object</code>.
+ *
+ * @exception ParseException If the <code>String</code> cannot be parsed.
+ */
+ public Object parseObject (String str) throws ParseException
{
ParsePosition pos = new ParsePosition(0);
- Object result = parseObject (source, pos);
+ Object result = parseObject (str, pos);
if (result == null)
{
int index = pos.getErrorIndex();
return result;
}
+ /**
+ * This method parses a <code>String</code> and converts the parsed
+ * contents into an <code>Object</code>.
+ *
+ * @param str The <code>String</code> to parse.
+ * @param pos The starting parse index on input, the ending parse
+ * index on output.
+ *
+ * @return The parsed <code>Object</code>, or <code>null</code> in
+ * case of error.
+ */
+ public abstract Object parseObject (String str, ParsePosition pos);
+
+ /**
+ * Creates a copy of this object.
+ *
+ * @return The copied <code>Object</code>.
+ */
public Object clone ()
{
- return super.clone ();
+ try
+ {
+ return super.clone ();
+ }
+ catch (CloneNotSupportedException e)
+ {
+ return null;
+ }
}
}
-// MessageFormat.java - Localized message formatting.
+/* MessageFormat.java - Localized message formatting.
+ Copyright (C) 1999, 2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-/* Copyright (C) 1999, 2001 Free Software Foundation
-
- This file is part of libgcj.
-
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
-/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
+/* NumberFormat.java -- Formats and parses numbers
+ Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
import java.io.IOException;
/**
+ * This is the abstract superclass of all classes which format and
+ * parse numeric values such as decimal numbers, integers, currency values,
+ * and percentages. These classes perform their parsing and formatting
+ * in a locale specific manner, accounting for such items as differing
+ * currency symbols and thousands separators.
+ * <p>
+ * To create an instance of a concrete subclass of <code>NumberFormat</code>,
+ * do not call a class constructor directly. Instead, use one of the
+ * static factory methods in this class such as
+ * <code>getCurrencyInstance</code>.
+ *
* @author Tom Tromey <tromey@cygnus.com>
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @date March 4, 1999
*/
/* Written using "Java Class Libraries", 2nd edition, plus online
* API docs for JDK 1.2 from http://www.javasoft.com.
* Status: Believed complete and correct to 1.2, except getAvailableLocales.
*/
-
public abstract class NumberFormat extends Format implements Cloneable
{
+ /**
+ * This is a constant used to create a <code>FieldPosition</code> object
+ * that will return the integer portion of a formatted number.
+ */
public static final int INTEGER_FIELD = 0;
+
+ /**
+ * This is a constant used to create a <code>FieldPosition</code> object
+ * that will return the fractional portion of a formatted number.
+ */
public static final int FRACTION_FIELD = 1;
+ /**
+ * This method is a specialization of the format method that performs
+ * a simple formatting of the specified <code>long</code> number.
+ *
+ * @param number The <code>long</code> to format.
+ *
+ * @return The formatted number
+ */
public final String format (long number)
- {
- StringBuffer sbuf = new StringBuffer(50);
- format (number, sbuf, null);
- return sbuf.toString();
- }
+ {
+ StringBuffer sbuf = new StringBuffer(50);
+ format (number, sbuf, null);
+ return sbuf.toString();
+ }
public final StringBuffer format (Object obj, StringBuffer sbuf,
FieldPosition pos)
- {
- if (obj instanceof Number)
- return format(((Number) obj).doubleValue(), sbuf, pos);
- else
- throw new IllegalArgumentException
- ("Cannot format given Object as a Number");
- }
+ {
+ if (obj instanceof Number)
+ return format(((Number) obj).doubleValue(), sbuf, pos);
+ else
+ throw new IllegalArgumentException
+ ("Cannot format given Object as a Number");
+ }
+ /**
+ * This method formats the specified <code>double</code> and appends it to
+ * a <code>StringBuffer</code>.
+ *
+ * @param number The <code>double</code> to format.
+ * @param sb The <code>StringBuffer</code> to append the formatted number to.
+ * @param pos The desired <code>FieldPosition</code>.
+ *
+ * @return The <code>StringBuffer</code> with the appended number.
+ */
public abstract StringBuffer format (double number,
StringBuffer sbuf, FieldPosition pos);
+ /**
+ * This method formats the specified <code>long</code> and appends it to
+ * a <code>StringBuffer</code>.
+ *
+ * @param number The <code>long</code> to format.
+ * @param sb The <code>StringBuffer</code> to append the formatted number to.
+ * @param pos The desired <code>FieldPosition</code>.
+ *
+ * @return The <code>StringBuffer</code> with the appended number.
+ */
public abstract StringBuffer format (long number,
StringBuffer sbuf, FieldPosition pos);
- public Object clone ()
- {
- // We know the superclass just uses Object's generic cloner.
- // Why not just inherit? Because the online docs specify that
- // this method exists for this class.
- return super.clone ();
- }
-
+ /**
+ * This method tests the specified object for equality against this object.
+ * This will be <code>true</code> if the following conditions are met:
+ * <p>
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>NumberFormat</code>.
+ * </ul>
+ * <p>
+ * Since this method does not test much, it is highly advised that
+ * concrete subclasses override this method.
+ *
+ * @param obj The <code>Object</code> to test against equality with
+ * this object.
+ *
+ * @return <code>true</code> if the specified object is equal to
+ * this object, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
if (! (obj instanceof NumberFormat))
&& parseIntegerOnly == nf.parseIntegerOnly);
}
+ /**
+ * This method returns a list of locales for which concrete instances
+ * of <code>NumberFormat</code> subclasses may be created.
+ *
+ * @return The list of available locales.
+ */
public static Locale[] getAvailableLocales ()
- {
- // FIXME.
- return null;
- }
+ {
+ Locale[] list = new Locale[1];
+ list[0] = Locale.US;
+ return list;
+ }
private static final NumberFormat computeInstance (Locale loc,
String resource,
String def)
- {
- ResourceBundle res;
- try
- {
- res = ResourceBundle.getBundle("gnu.gcj.text.LocaleData", loc);
- }
- catch (MissingResourceException x)
- {
- res = null;
- }
- String fmt;
- try
- {
- fmt = res == null ? def : res.getString(resource);
- }
- catch (MissingResourceException x)
- {
- fmt = def;
- }
- DecimalFormatSymbols dfs = new DecimalFormatSymbols (loc);
- return new DecimalFormat (fmt, dfs);
- }
+ {
+ ResourceBundle res;
+ try
+ {
+ res = ResourceBundle.getBundle("gnu.java.locale.LocaleInformation",
+ loc);
+ }
+ catch (MissingResourceException x)
+ {
+ res = null;
+ }
+ String fmt;
+ try
+ {
+ fmt = res == null ? def : res.getString(resource);
+ }
+ catch (MissingResourceException x)
+ {
+ fmt = def;
+ }
+ DecimalFormatSymbols dfs = new DecimalFormatSymbols (loc);
+ return new DecimalFormat (fmt, dfs);
+ }
+ /**
+ * This method returns an instance of <code>NumberFormat</code> suitable
+ * for formatting and parsing currency values in the default locale.
+ *
+ * @return An instance of <code>NumberFormat</code> for handling currencies.
+ */
public static final NumberFormat getCurrencyInstance ()
- {
- return getCurrencyInstance (Locale.getDefault());
- }
+ {
+ return getCurrencyInstance (Locale.getDefault());
+ }
+ /**
+ * This method returns an instance of <code>NumberFormat</code> suitable
+ * for formatting and parsing currency values in the specified locale.
+ *
+ * @return An instance of <code>NumberFormat</code> for handling currencies.
+ */
public static NumberFormat getCurrencyInstance (Locale loc)
- {
- return computeInstance (loc, "currencyFormat", "$#,##0.00;($#,##0.00)");
- }
+ {
+ return computeInstance (loc, "currencyFormat", "$#,##0.00;($#,##0.00)");
+ }
+ /**
+ * This method returns a default instance for the default locale. This
+ * will be a concrete subclass of <code>NumberFormat</code>, but the
+ * actual class returned is dependent on the locale.
+ *
+ * @return An instance of the default <code>NumberFormat</code> class.
+ */
public static final NumberFormat getInstance ()
- {
- return getInstance (Locale.getDefault());
- }
+ {
+ return getInstance (Locale.getDefault());
+ }
+ /**
+ * This method returns a default instance for the specified locale. This
+ * will be a concrete subclass of <code>NumberFormat</code>, but the
+ * actual class returned is dependent on the locale.
+ *
+ * @param locale The desired locale.
+ *
+ * @return An instance of the default <code>NumberFormat</code> class.
+ */
public static NumberFormat getInstance (Locale loc)
- {
- // For now always return a number instance.
- return getNumberInstance (loc);
- }
+ {
+ // For now always return a number instance.
+ return getNumberInstance (loc);
+ }
+ /**
+ * This method returns the maximum number of digits allowed in the fraction
+ * portion of a number.
+ *
+ * @return The maximum number of digits allowed in the fraction
+ * portion of a number.
+ */
public int getMaximumFractionDigits ()
- {
- return maximumFractionDigits;
- }
+ {
+ return maximumFractionDigits;
+ }
+ /**
+ * This method returns the maximum number of digits allowed in the integer
+ * portion of a number.
+ *
+ * @return The maximum number of digits allowed in the integer
+ * portion of a number.
+ */
public int getMaximumIntegerDigits ()
- {
- return maximumIntegerDigits;
- }
+ {
+ return maximumIntegerDigits;
+ }
+ /**
+ * This method returns the minimum number of digits allowed in the fraction
+ * portion of a number.
+ *
+ * @return The minimum number of digits allowed in the fraction
+ * portion of a number.
+ */
public int getMinimumFractionDigits ()
- {
- return minimumFractionDigits;
- }
+ {
+ return minimumFractionDigits;
+ }
+ /**
+ * This method returns the minimum number of digits allowed in the integer
+ * portion of a number.
+ *
+ * @return The minimum number of digits allowed in the integer
+ * portion of a number.
+ */
public int getMinimumIntegerDigits ()
- {
- return minimumIntegerDigits;
- }
+ {
+ return minimumIntegerDigits;
+ }
+ /**
+ * This method returns a default instance for the specified locale. This
+ * will be a concrete subclass of <code>NumberFormat</code>, but the
+ * actual class returned is dependent on the locale.
+ *
+ * @param locale The desired locale.
+ *
+ * @return An instance of the default <code>NumberFormat</code> class.
+ */
public static final NumberFormat getNumberInstance ()
- {
- return getNumberInstance (Locale.getDefault());
- }
+ {
+ return getNumberInstance (Locale.getDefault());
+ }
+ /**
+ * This method returns a general purpose number formatting and parsing
+ * class for the default locale. This will be a concrete subclass of
+ * <code>NumberFormat</code>, but the actual class returned is dependent
+ * on the locale.
+ *
+ * @return An instance of a generic number formatter for the default locale.
+ */
public static NumberFormat getNumberInstance (Locale loc)
- {
- return computeInstance (loc, "numberFormat", "#,##0.###");
- }
+ {
+ return computeInstance (loc, "numberFormat", "#,##0.###");
+ }
+ /**
+ * This method returns an instance of <code>NumberFormat</code> suitable
+ * for formatting and parsing percentage values in the default locale.
+ *
+ * @return An instance of <code>NumberFormat</code> for handling percentages.
+ */
public static final NumberFormat getPercentInstance ()
- {
- return getPercentInstance (Locale.getDefault());
- }
+ {
+ return getPercentInstance (Locale.getDefault());
+ }
+ /**
+ * This method returns an instance of <code>NumberFormat</code> suitable
+ * for formatting and parsing percentage values in the specified locale.
+ *
+ * @param locale The desired locale.
+ *
+ * @return An instance of <code>NumberFormat</code> for handling percentages.
+ */
public static NumberFormat getPercentInstance (Locale loc)
- {
- return computeInstance (loc, "percentFormat", "#,##0%");
- }
+ {
+ return computeInstance (loc, "percentFormat", "#,##0%");
+ }
+ /**
+ * This method returns a hash value for this object.
+ *
+ * @return The hash code.
+ */
public int hashCode ()
- {
- int hash = super.hashCode();
- hash ^= (maximumFractionDigits + maximumIntegerDigits
- + minimumFractionDigits + minimumIntegerDigits);
- if (groupingUsed)
- hash ^= 0xf0f0;
- if (parseIntegerOnly)
- hash ^= 0x0f0f;
- return hash;
- }
+ {
+ int hash = super.hashCode();
+ hash ^= (maximumFractionDigits + maximumIntegerDigits
+ + minimumFractionDigits + minimumIntegerDigits);
+ if (groupingUsed)
+ hash ^= 0xf0f0;
+ if (parseIntegerOnly)
+ hash ^= 0x0f0f;
+ return hash;
+ }
+ /**
+ * This method tests whether or not grouping is in use. Grouping is
+ * a method of marking separations in numbers, such as thousand separators
+ * in the US English locale. The grouping positions and symbols are all
+ * locale specific. As an example, with grouping disabled, the number one
+ * million would appear as "1000000". With grouping enabled, this number
+ * might appear as "1,000,000". (Both of these assume the US English
+ * locale).
+ *
+ * @return <code>true</code> if grouping is enabled,
+ * <code>false</code> otherwise.
+ */
public boolean isGroupingUsed ()
- {
- return groupingUsed;
- }
+ {
+ return groupingUsed;
+ }
+ /**
+ * This method tests whether or not only integer values should be parsed.
+ * If this class is parsing only integers, parsing stops at the decimal
+ * point.
+ *
+ * @return <code>true</code> if only integers are parsed,
+ * <code>false</code> otherwise.
+ */
public boolean isParseIntegerOnly ()
- {
- return parseIntegerOnly;
- }
+ {
+ return parseIntegerOnly;
+ }
+ /**
+ * This is a default constructor for use by subclasses.
+ */
public NumberFormat ()
- {
- }
+ {
+ }
+ /**
+ * This method parses the specified string into a <code>Number</code>. This
+ * will be a <code>Long</code> if possible, otherwise it will be a
+ * <code>Double</code>. If no number can be parsed, no exception is
+ * thrown. Instead, the parse position remains at its initial index.
+ *
+ * @param str The string to parse.
+ * @param pp The desired <code>ParsePosition</code>.
+ *
+ * @return The parsed <code>Number</code>
+ */
public abstract Number parse (String sourceStr, ParsePosition pos);
+ /**
+ * This method parses the specified string into a <code>Number</code>. This
+ * will be a <code>Long</code> if possible, otherwise it will be a
+ * <code>Double</code>. If no number can be parsed, an exception will be
+ * thrown.
+ *
+ * @param str The string to parse.
+ *
+ * @return The parsed <code>Number</code>
+ *
+ * @exception ParseException If no number can be parsed.
+ */
public Number parse (String sourceStr) throws ParseException
- {
- ParsePosition pp = new ParsePosition (0);
- Number r = parse (sourceStr, pp);
- if (r == null)
- {
- int index = pp.getErrorIndex();
- if (index < 0)
- index = pp.getIndex();
- throw new ParseException ("couldn't parse number", index);
- }
- return r;
- }
+ {
+ ParsePosition pp = new ParsePosition (0);
+ Number r = parse (sourceStr, pp);
+ if (r == null)
+ {
+ int index = pp.getErrorIndex();
+ if (index < 0)
+ index = pp.getIndex();
+ throw new ParseException ("couldn't parse number", index);
+ }
+ return r;
+ }
+ /**
+ * This method parses the specified string into an <code>Object</code>. This
+ * will be a <code>Long</code> if possible, otherwise it will be a
+ * <code>Double</code>. If no number can be parsed, no exception is
+ * thrown. Instead, the parse position remains at its initial index.
+ *
+ * @param str The string to parse.
+ * @param pp The desired <code>ParsePosition</code>.
+ *
+ * @return The parsed <code>Object</code>
+ */
public final Object parseObject (String sourceStr, ParsePosition pos)
- {
- return parse (sourceStr, pos);
- }
+ {
+ return parse (sourceStr, pos);
+ }
+ /**
+ * This method sets the grouping behavior of this formatter. Grouping is
+ * a method of marking separations in numbers, such as thousand separators
+ * in the US English locale. The grouping positions and symbols are all
+ * locale specific. As an example, with grouping disabled, the number one
+ * million would appear as "1000000". With grouping enabled, this number
+ * might appear as "1,000,000". (Both of these assume the US English
+ * locale).
+ *
+ * @param groupingUsed <code>true</code> to enable grouping,
+ * <code>false</code> to disable it.
+ */
public void setGroupingUsed (boolean newValue)
- {
- groupingUsed = newValue;
- }
+ {
+ groupingUsed = newValue;
+ }
+ /**
+ * This method sets the maximum number of digits allowed in the fraction
+ * portion of a number to the specified value. If this is less than the
+ * current minimum allowed digits, the minimum allowed digits value will
+ * be lowered to be equal to the new maximum allowed digits value.
+ *
+ * @param maximumFractionDigits The new maximum fraction digits value.
+ */
public void setMaximumFractionDigits (int newValue)
- {
- maximumFractionDigits = newValue;
- }
+ {
+ maximumFractionDigits = newValue;
+ if (getMinimumFractionDigits () > maximumFractionDigits)
+ setMinimumFractionDigits (maximumFractionDigits);
+ }
+ /**
+ * This method sets the maximum number of digits allowed in the integer
+ * portion of a number to the specified value. If this is less than the
+ * current minimum allowed digits, the minimum allowed digits value will
+ * be lowered to be equal to the new maximum allowed digits value.
+ *
+ * @param maximumIntegerDigits The new maximum integer digits value.
+ */
public void setMaximumIntegerDigits (int newValue)
- {
- maximumIntegerDigits = newValue;
- }
+ {
+ maximumIntegerDigits = newValue;
+ if (getMinimumIntegerDigits () > maximumIntegerDigits)
+ setMinimumIntegerDigits (maximumIntegerDigits);
+ }
+ /**
+ * This method sets the minimum number of digits allowed in the fraction
+ * portion of a number to the specified value. If this is greater than the
+ * current maximum allowed digits, the maximum allowed digits value will
+ * be raised to be equal to the new minimum allowed digits value.
+ *
+ * @param minimumFractionDigits The new minimum fraction digits value.
+ */
public void setMinimumFractionDigits (int newValue)
- {
- minimumFractionDigits = newValue;
- }
+ {
+ minimumFractionDigits = newValue;
+ if (getMaximumFractionDigits () < minimumFractionDigits)
+ setMaximumFractionDigits (minimumFractionDigits);
+ }
+ /**
+ * This method sets the minimum number of digits allowed in the integer
+ * portion of a number to the specified value. If this is greater than the
+ * current maximum allowed digits, the maximum allowed digits value will
+ * be raised to be equal to the new minimum allowed digits value.
+ *
+ * @param minimumIntegerDigits The new minimum integer digits value.
+ */
public void setMinimumIntegerDigits (int newValue)
- {
- minimumIntegerDigits = newValue;
- }
+ {
+ minimumIntegerDigits = newValue;
+ if (getMaximumIntegerDigits () < minimumIntegerDigits)
+ setMaximumIntegerDigits (minimumIntegerDigits);
+ }
+ /**
+ * This method sets the parsing behavior of this object to parse only
+ * integers or not.
+ *
+ * @param parseIntegerOnly <code>true</code> to parse only integers,
+ * <code>false</code> otherwise.
+ */
public void setParseIntegerOnly (boolean value)
- {
- parseIntegerOnly = value;
- }
+ {
+ parseIntegerOnly = value;
+ }
+ /**
+ * This method is a specialization of the format method that performs
+ * a simple formatting of the specified <code>double</code> number.
+ *
+ * @param number The <code>double</code> to format.
+ *
+ * @return The formatted number
+ */
public final String format (double number)
- {
- StringBuffer sbuf = new StringBuffer(50);
- format (number, sbuf, null);
- return sbuf.toString();
- }
+ {
+ StringBuffer sbuf = new StringBuffer(50);
+ format (number, sbuf, null);
+ return sbuf.toString();
+ }
// These field names are fixed by the serialization spec.
boolean groupingUsed;
-/* Copyright (C) 1998, 1999 Free Software Foundation
+/* ParsePosition.java -- Keep track of position while parsing.
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
- This file is part of libgcj.
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
/**
+ * This class is used to keep track of the current position during parsing
+ * operations.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @author Per Bothner <bothner@cygnus.com>
- * @date October 25, 1998.
*/
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct.
- * Includes JDK 1.2 methods.
- */
-
public class ParsePosition
{
- int index;
- int errorIndex;
+ /**
+ * This is the index of the current parse position.
+ */
+ private int index;
+ /**
+ * This is the index of the position where an error occurred during parsing.
+ */
+ private int error_index;
+
+ /**
+ * This method initializes a new instance of <code>ParsePosition</code> to
+ * have the specified initial index value.
+ *
+ * @param index The initial parsing index.
+ */
public ParsePosition (int index)
{
this.index = index;
- errorIndex = -1;
+ error_index = -1;
}
+ /**
+ * This method returns the current parsing index.
+ *
+ * @return The current parsing index
+ */
public int getIndex ()
{
return index;
}
+ /**
+ * This method sets the current parsing index to the specified value.
+ *
+ * @param index The new parsing index.
+ */
public void setIndex (int index)
{
this.index = index;
}
+ /**
+ * This method returns the error index value. This value defaults to -1
+ * unless explicitly set to another value.
+ *
+ * @return The error index.
+ */
public int getErrorIndex ()
{
- return errorIndex;
+ return error_index;
}
- public void setErrorIndex (int ei)
+ /**
+ * This method sets the error index to the specified value.
+ *
+ * @param error_index The new error index
+ */
+ public void setErrorIndex (int error_index)
{
- errorIndex = ei;
+ this.error_index = error_index;
}
+ /**
+ * This method tests the specified object for equality with this
+ * object. The two objects will be considered equal if and only if
+ * all of the following conditions are met.
+ * <p>
+ * <ul>
+ * <li>The specified object is not <code>null</code>.
+ * <li>The specified object is an instance of <code>ParsePosition</code>.
+ * <li>The specified object has the same index and error index as
+ * this object.
+ * </ul>
+ *
+ * @param obj The <code>Object</code> to test for equality against
+ * this object.
+ *
+ * @return <code>true</code> if the specified object is equal to
+ * this object, <code>false</code> otherwise.
+ */
public boolean equals (Object obj)
{
- if (obj != null || ! (obj instanceof ParsePosition))
+ if (! (obj instanceof ParsePosition))
return false;
+
ParsePosition other = (ParsePosition) obj;
- return index == other.index && errorIndex == other.errorIndex;
+ return index == other.index && error_index == other.error_index;
+ }
+
+ /**
+ * This method returns a <code>String</code> representation of this
+ * object.
+ *
+ * @return A <code>String</code> that represents this object.
+ */
+ public String toString ()
+ {
+ return (getClass ().getName () + "[index=" + getIndex ()
+ + ",errorIndex=" + getErrorIndex () + "]");
}
}
{
super();
calendar = new GregorianCalendar();
+ computeCenturyStart ();
tokens = new Vector();
this.formatData = formatData;
compileFormat(pattern);
-// StringCharacterIterator.java - Iterate over string of Unicode characters.
+/* StringCharacterIterator.java -- Iterate over a character range in a string
+ Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
-/* Copyright (C) 1999, 2000 Free Software Foundation
+This file is part of GNU Classpath.
- This file is part of libgcj.
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+As a special exception, if you link this library with other files to
+produce an executable, this library does not by itself cause the
+resulting executable to be covered by the GNU General Public License.
+This exception does not however invalidate any other reasons why the
+executable file might be covered by the GNU General Public License. */
-This software is copyrighted work licensed under the terms of the
-Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
-details. */
package java.text;
/**
+ * This class iterates over a range of characters in a <code>String</code>.
+ * For a given range of text, a beginning and ending index,
+ * as well as a current index are defined. These values can be queried
+ * by the methods in this interface. Additionally, various methods allow
+ * the index to be set.
+ *
+ * @author Aaron M. Renn (arenn@urbanophile.com)
* @author Tom Tromey <tromey@cygnus.com>
- * @date February 22, 1999
- */
-/* Written using "Java Class Libraries", 2nd edition, plus online
- * API docs for JDK 1.2 beta from http://www.javasoft.com.
- * Status: Believed complete and correct to 1.1.
*/
-
public final class StringCharacterIterator implements CharacterIterator
{
- public Object clone ()
+ /**
+ * This is the string to iterate over
+ */
+ private String text;
+
+ /**
+ * This is the value of the start position of the text range.
+ */
+ private int begin;
+
+ /**
+ * This is the value of the ending position of the text range.
+ */
+ private int end;
+
+ /**
+ * This is the current value of the scan index.
+ */
+ private int index;
+
+ /**
+ * This method initializes a new instance of
+ * <code>StringCharacterIterator</code> to iterate over the entire
+ * text of the specified <code>String</code>. The initial index
+ * value will be set to the first character in the string.
+ *
+ * @param text The <code>String</code> to iterate through.
+ */
+ public StringCharacterIterator (String text)
{
- return (Object) new StringCharacterIterator (text, begin, end, pos);
+ this (text, 0, text.length (), 0);
}
- public char current ()
+ /*************************************************************************/
+
+ /**
+ * This method initializes a new instance of
+ * <code>StringCharacterIterator</code> to iterate over the entire
+ * text of the specified <code>String</code>. The initial index
+ * value will be set to the specified value.
+ *
+ * @param text The <code>String</code> to iterate through.
+ * @param index The initial index position.
+ */
+ public StringCharacterIterator (String text, int index)
{
- // This follows JDK 1.2 semantics and not 1.1 semantics.
- // In 1.1 we would throw an exception if begin==end.
- return (pos < end) ? text.charAt(pos) : CharacterIterator.DONE;
+ this (text, 0, text.length (), index);
}
- public boolean equals (Object obj)
+ /*************************************************************************/
+
+ /**
+ * This method initializes a new instance of
+ * <code>StringCharacterIterator</code> that iterates over the text
+ * in a subrange of the specified <code>String</code>. The
+ * beginning and end of the range are specified by the caller, as is
+ * the initial index position.
+ *
+ * @param text The <code>String</code> to iterate through.
+ * @param begin The beginning position in the character range.
+ * @param end The ending position in the character range.
+ * @param index The initial index position.
+ *
+ * @param IllegalArgumentException If any of the range values are
+ * invalid.
+ */
+ public StringCharacterIterator (String text, int begin, int end, int index)
{
- if (! (obj instanceof StringCharacterIterator))
- return false;
- StringCharacterIterator sci = (StringCharacterIterator) obj;
- // The spec says "the same text". We take this to mean equals,
- // not ==.
- return (pos == sci.pos
- && begin == sci.begin
- && end == sci.end
- && text.equals(sci.text));
+ int len = text.length ();
+
+ if ((begin < 0) || (begin > len))
+ throw new IllegalArgumentException ("Bad begin position");
+
+ if ((end < begin) || (end > len))
+ throw new IllegalArgumentException ("Bad end position");
+
+ if ((index < begin) || (index > end))
+ throw new IllegalArgumentException ("Bad initial index position");
+
+ this.text = text;
+ this.begin = begin;
+ this.end = end;
+ this.index = index;
}
- public char first ()
+ /**
+ * This is a package level constructor that copies the text out of
+ * an existing StringCharacterIterator and resets the beginning and
+ * ending index.
+ *
+ * @param scci The StringCharacterIterator to copy the info from
+ * @param begin The beginning index of the range we are interested in.
+ * @param end The ending index of the range we are interested in.
+ */
+ StringCharacterIterator (StringCharacterIterator sci, int begin, int end)
{
- pos = begin;
- return current ();
+ this (sci.text, begin, end, begin);
}
- public int getBeginIndex ()
+ /**
+ * This method returns the character at the current index position
+ *
+ * @return The character at the current index position.
+ */
+ public char current ()
{
- return begin;
+ return (index < end) ? text.charAt (index) : DONE;
}
- public int getEndIndex ()
+ /*************************************************************************/
+
+ /**
+ * This method increments the current index and then returns the
+ * character at the new index value. If the index is already at
+ * <code>getEndIndex () - 1</code>, it will not be incremented.
+ *
+ * @return The character at the position of the incremented index
+ * value, or <code>DONE</code> if the index has reached
+ * getEndIndex () - 1.
+ */
+ public char next ()
{
- return end;
+ if (index == end)
+ return DONE;
+
+ ++index;
+ return current ();
}
- public int getIndex ()
+ /*************************************************************************/
+
+ /**
+ * This method decrements the current index and then returns the
+ * character at the new index value. If the index value is already
+ * at the beginning index, it will not be decremented.
+ *
+ * @return The character at the position of the decremented index
+ * value, or <code>DONE</code> if index was already equal to the
+ * beginning index value.
+ */
+ public char previous ()
{
- return pos;
+ if (index == begin)
+ return DONE;
+
+ --index;
+ return current ();
}
- public int hashCode ()
+ /*************************************************************************/
+
+ /**
+ * This method sets the index value to the beginning of the range and returns
+ * the character there.
+ *
+ * @return The character at the beginning of the range, or
+ * <code>DONE</code> if the range is empty.
+ */
+ public char first ()
{
- // FIXME: this is a terrible hash code. Find a better one.
- return text.hashCode() + pos + begin + end;
+ index = begin;
+ return current ();
}
+ /*************************************************************************/
+
+ /**
+ * This method sets the index value to <code>getEndIndex () - 1</code> and
+ * returns the character there. If the range is empty, then the index value
+ * will be set equal to the beginning index.
+ *
+ * @return The character at the end of the range, or
+ * <code>DONE</code> if the range is empty.
+ */
public char last ()
{
- pos = end;
+ if (end == begin)
+ return DONE;
+
+ index = end - 1;
return current ();
}
- public char next ()
+ /*************************************************************************/
+
+ /**
+ * This method returns the current value of the index.
+ *
+ * @return The current index value
+ */
+ public int getIndex ()
{
- if (pos == end)
- return CharacterIterator.DONE;
- ++pos;
- return current ();
+ return index;
}
- public char previous ()
+ /*************************************************************************/
+
+ /**
+ * This method sets the value of the index to the specified value, then
+ * returns the character at that position.
+ *
+ * @param index The new index value.
+ *
+ * @return The character at the new index value or <code>DONE</code>
+ * if the index value is equal to <code>getEndIndex</code>.
+ *
+ * @exception IllegalArgumentException If the specified index is not valid
+ */
+ public char setIndex (int index)
{
- if (pos == begin)
- return CharacterIterator.DONE;
- --pos;
+ if ((index < begin) || (index > end))
+ throw new IllegalArgumentException ("Bad index specified");
+
+ this.index = index;
return current ();
}
- public char setIndex (int idx)
+ /*************************************************************************/
+
+ /**
+ * This method returns the character position of the first character in the
+ * range.
+ *
+ * @return The index of the first character in the range.
+ */
+ public int getBeginIndex ()
{
- // In 1.1 we would throw an error if `idx == end'.
- if (idx < begin || idx > end)
- throw new IllegalArgumentException ();
- pos = idx;
- return current ();
+ return begin;
}
- public StringCharacterIterator (String text)
+ /*************************************************************************/
+
+ /**
+ * This method returns the character position of the end of the text range.
+ * This will actually be the index of the first character following the
+ * end of the range. In the event the text range is empty, this will be
+ * equal to the first character in the range.
+ *
+ * @return The index of the end of the range.
+ */
+ public int getEndIndex ()
{
- this (text, 0, text.length(), 0);
+ return end;
}
- public StringCharacterIterator (String text, int pos)
+ /*************************************************************************/
+
+ /**
+ * This method creates a copy of this <code>CharacterIterator</code>.
+ *
+ * @return A copy of this <code>CharacterIterator</code>.
+ */
+ public Object clone ()
{
- this (text, 0, text.length(), pos);
+ return new StringCharacterIterator (text, begin, end, index);
}
- public StringCharacterIterator (String text, int begin, int end, int pos)
+ /*************************************************************************/
+
+ /**
+ * This method tests this object for equality againt the specified
+ * object. This will be true if and only if the specified object:
+ * <p>
+ * <ul>
+ * <li>is not <code>null</code>.
+ * <li>is an instance of <code>StringCharacterIterator</code>
+ * <li>has the same text as this object
+ * <li>has the same beginning, ending, and current index as this object.
+ * </ul>
+ *
+ * @param obj The object to test for equality against.
+ *
+ * @return <code>true</code> if the specified object is equal to this
+ * object, <code>false</code> otherwise.
+ */
+ public boolean equals (Object obj)
{
- if (begin < 0 || begin > end || end > text.length()
- // In 1.1 we would also throw if `pos == end'.
- || pos < begin || pos > end)
- throw new IllegalArgumentException ();
+ if (! (obj instanceof StringCharacterIterator))
+ return false;
- this.text = text;
- this.begin = begin;
- this.end = end;
- this.pos = pos;
+ StringCharacterIterator sci = (StringCharacterIterator) obj;
+
+ return (begin == sci.begin
+ && end == sci.end
+ && index == sci.index
+ && text.equals (sci.text));
}
- // The online 1.2 docs say that this is "package visible" in the
- // method description, but they also say it is public. We choose
- // the latter for compatibility with the actual implementation.
+ /*************************************************************************/
+
+ /**
+ * This method allows other classes in java.text to change the value
+ * of the underlying text being iterated through.
+ *
+ * @param text The new <code>String</code> to iterate through.
+ */
public void setText (String text)
{
this.text = text;
this.begin = 0;
this.end = text.length ();
- this.pos = 0;
+ this.index = 0;
}
-
- // String to iterate over.
- private String text;
- // Current position.
- private int pos;
- // Start position in string.
- private int begin;
- // End position in string.
- private int end;
}
OSDN Git Service
