Java > Open Source Codes > com > go > trove > util > FastDateFormat


1 /* ====================================================================
2  * Trove - Copyright (c) 1997-2001 Walt Disney Internet Group
3  * ====================================================================
4  * The Tea Software License, Version 1.1
5  *
6  * Copyright (c) 2000 Walt Disney Internet Group. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * 3. The end-user documentation included with the redistribution,
21  * if any, must include the following acknowledgment:
22  * "This product includes software developed by the
23  * Walt Disney Internet Group (http://opensource.go.com/)."
24  * Alternately, this acknowledgment may appear in the software itself,
25  * if and wherever such third-party acknowledgments normally appear.
26  *
27  * 4. The names "Tea", "TeaServlet", "Kettle", "Trove" and "BeanDoc" must
28  * not be used to endorse or promote products derived from this
29  * software without prior written permission. For written
30  * permission, please contact opensource@dig.com.
31  *
32  * 5. Products derived from this software may not be called "Tea",
33  * "TeaServlet", "Kettle" or "Trove", nor may "Tea", "TeaServlet",
34  * "Kettle", "Trove" or "BeanDoc" appear in their name, without prior
35  * written permission of the Walt Disney Internet Group.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40  * DISCLAIMED. IN NO EVENT SHALL THE WALT DISNEY INTERNET GROUP OR ITS
41  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
42  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
43  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
44  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
45  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
47  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
48  * ====================================================================
49  *
50  * For more information about Tea, please see http://opensource.go.com/.
51  */
52
53 package com.go.trove.util;
54
55 import java.util.Date ;
56 import java.util.Calendar ;
57 import java.util.GregorianCalendar ;
58 import java.util.Locale ;
59 import java.util.TimeZone ;
60 import java.util.List ;
61 import java.util.ArrayList ;
62 import java.util.Map ;
63 import java.util.HashMap ;
64 import java.text.DateFormatSymbols ;
65 import java.text.DateFormat ;
66 import java.text.SimpleDateFormat ;
67
68 /******************************************************************************
69  * Similar to {@link java.text.SimpleDateFormat}, but faster and thread-safe.
70  * Only formatting is supported, but all patterns are compatible with
71  * SimpleDateFormat.
72  *
73  * @author Brian S O'Neill
74  * @version
75  * <!--$$Revision:--> 4 <!-- $-->, <!--$$JustDate:--> 01/07/03 <!-- $-->
76  */
77 public class FastDateFormat {
78     /** Style pattern */
79     public static final Object
80         FULL = new Integer (SimpleDateFormat.FULL),
81         LONG = new Integer (SimpleDateFormat.LONG),
82         MEDIUM = new Integer (SimpleDateFormat.MEDIUM),
83         SHORT = new Integer (SimpleDateFormat.SHORT);
84
85     private static final double LOG_10 = Math.log(10);
86
87     private static String cDefaultPattern;
88     private static TimeZone cDefaultTimeZone = TimeZone.getDefault();
89
90     private static Map cTimeZoneDisplayCache = new HashMap ();
91
92     private static Map cInstanceCache = new HashMap (7);
93     private static Map cDateInstanceCache = new HashMap (7);
94     private static Map cTimeInstanceCache = new HashMap (7);
95     private static Map cDateTimeInstanceCache = new HashMap (7);
96
97     public static FastDateFormat getInstance() {
98         return getInstance(getDefaultPattern(), null, null, null);
99     }
100
101     /**
102      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
103      */
104     public static FastDateFormat getInstance(String pattern)
105         throws IllegalArgumentException
106     {
107         return getInstance(pattern, null, null, null);
108     }
109
110     /**
111      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
112      * @param timeZone optional time zone, overrides time zone of formatted
113      * date
114      */
115     public static FastDateFormat getInstance
116         (String pattern, TimeZone timeZone) throws IllegalArgumentException
117     {
118         return getInstance(pattern, timeZone, null, null);
119     }
120
121     /**
122      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
123      * @param locale optional locale, overrides system locale
124      */
125     public static FastDateFormat getInstance
126         (String pattern, Locale locale) throws IllegalArgumentException
127     {
128         return getInstance(pattern, null, locale, null);
129     }
130
131     /**
132      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
133      * @param symbols optional date format symbols, overrides symbols for
134      * system locale
135      */
136     public static FastDateFormat getInstance
137         (String pattern, DateFormatSymbols symbols)
138         throws IllegalArgumentException
139     {
140         return getInstance(pattern, null, null, symbols);
141     }
142
143     /**
144      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
145      * @param timeZone optional time zone, overrides time zone of formatted
146      * date
147      * @param locale optional locale, overrides system locale
148      */
149     public static FastDateFormat getInstance
150         (String pattern, TimeZone timeZone, Locale locale)
151         throws IllegalArgumentException
152     {
153         return getInstance(pattern, timeZone, locale, null);
154     }
155
156     /**
157      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
158      * @param timeZone optional time zone, overrides time zone of formatted
159      * date
160      * @param locale optional locale, overrides system locale
161      * @param symbols optional date format symbols, overrides symbols for
162      * provided locale
163      */
164     public static synchronized FastDateFormat getInstance
165         (String pattern, TimeZone timeZone, Locale locale,
166          DateFormatSymbols symbols)
167         throws IllegalArgumentException
168     {
169         Object key = pattern;
170
171         if (timeZone != null) {
172             key = new Pair(key, timeZone);
173         }
174         if (locale != null) {
175             key = new Pair(key, locale);
176         }
177         if (symbols != null) {
178             key = new Pair(key, symbols);
179         }
180
181         FastDateFormat format = (FastDateFormat)cInstanceCache.get(key);
182         if (format == null) {
183             if (locale == null) {
184                 locale = Locale.getDefault();
185             }
186             if (symbols == null) {
187                 symbols = new DateFormatSymbols (locale);
188             }
189             format = new FastDateFormat(pattern, timeZone, locale, symbols);
190             cInstanceCache.put(key, format);
191         }
192         return format;
193     }
194
195     /**
196      * @param style date style: FULL, LONG, MEDIUM, or SHORT
197      * @param timeZone optional time zone, overrides time zone of formatted
198      * date
199      * @param locale optional locale, overrides system locale
200      */
201     public static synchronized FastDateFormat getDateInstance
202         (Object style, TimeZone timeZone, Locale locale)
203         throws IllegalArgumentException
204     {
205         Object key = style;
206
207         if (timeZone != null) {
208             key = new Pair(key, timeZone);
209         }
210         if (locale == null) {
211             key = new Pair(key, locale);
212         }
213
214         FastDateFormat format = (FastDateFormat)cDateInstanceCache.get(key);
215
216         if (format == null) {
217             int ds;
218             try {
219                 ds = ((Integer )style).intValue();
220             }
221             catch (ClassCastException e) {
222                 throw new IllegalArgumentException
223                     ("Illegal date style: " + style);
224             }
225
226             if (locale == null) {
227                 locale = Locale.getDefault();
228             }
229
230             try {
231                 String pattern = ((SimpleDateFormat )DateFormat.getDateInstance(ds, locale)).toPattern();
232                 format = getInstance(pattern, timeZone, locale);
233                 cDateInstanceCache.put(key, format);
234             }
235             catch (ClassCastException e) {
236                 throw new IllegalArgumentException
237                     ("No date pattern for locale: " + locale);
238             }
239         }
240
241         return format;
242     }
243
244     /**
245      * @param style time style: FULL, LONG, MEDIUM, or SHORT
246      * @param timeZone optional time zone, overrides time zone of formatted
247      * date
248      * @param locale optional locale, overrides system locale
249      */
250     public static synchronized FastDateFormat getTimeInstance
251         (Object style, TimeZone timeZone, Locale locale)
252         throws IllegalArgumentException
253     {
254         Object key = style;
255
256         if (timeZone != null) {
257             key = new Pair(key, timeZone);
258         }
259         if (locale != null) {
260             key = new Pair(key, locale);
261         }
262
263         FastDateFormat format = (FastDateFormat)cTimeInstanceCache.get(key);
264
265         if (format == null) {
266             int ts;
267             try {
268                 ts = ((Integer )style).intValue();
269             }
270             catch (ClassCastException e) {
271                 throw new IllegalArgumentException
272                     ("Illegal time style: " + style);
273             }
274
275             if (locale == null) {
276                 locale = Locale.getDefault();
277             }
278
279             try {
280                 String pattern = ((SimpleDateFormat )DateFormat.getTimeInstance(ts, locale)).toPattern();
281                 format = getInstance(pattern, timeZone, locale);
282                 cTimeInstanceCache.put(key, format);
283             }
284             catch (ClassCastException e) {
285                 throw new IllegalArgumentException
286                     ("No date pattern for locale: " + locale);
287             }
288         }
289
290         return format;
291     }
292
293     /**
294      * @param dateStyle date style: FULL, LONG, MEDIUM, or SHORT
295      * @param timeStyle time style: FULL, LONG, MEDIUM, or SHORT
296      * @param timeZone optional time zone, overrides time zone of formatted
297      * date
298      * @param locale optional locale, overrides system locale
299      */
300     public static synchronized FastDateFormat getDateTimeInstance
301         (Object dateStyle, Object timeStyle, TimeZone timeZone, Locale locale)
302         throws IllegalArgumentException
303     {
304         Object key = new Pair(dateStyle, timeStyle);
305
306         if (timeZone != null) {
307             key = new Pair(key, timeZone);
308         }
309         if (locale != null) {
310             key = new Pair(key, locale);
311         }
312
313         FastDateFormat format =
314             (FastDateFormat)cDateTimeInstanceCache.get(key);
315
316         if (format == null) {
317             int ds;
318             try {
319                 ds = ((Integer )dateStyle).intValue();
320             }
321             catch (ClassCastException e) {
322                 throw new IllegalArgumentException
323                     ("Illegal date style: " + dateStyle);
324             }
325
326             int ts;
327             try {
328                 ts = ((Integer )timeStyle).intValue();
329             }
330             catch (ClassCastException e) {
331                 throw new IllegalArgumentException
332                     ("Illegal time style: " + timeStyle);
333             }
334             
335             if (locale == null) {
336                 locale = Locale.getDefault();
337             }
338             
339             try {
340                 String pattern = ((SimpleDateFormat )DateFormat.getDateTimeInstance(ds, ts, locale)).toPattern();
341                 format = getInstance(pattern, timeZone, locale);
342                 cDateTimeInstanceCache.put(key, format);
343             }
344             catch (ClassCastException e) {
345                 throw new IllegalArgumentException
346                     ("No date time pattern for locale: " + locale);
347             }
348         }
349
350         return format;
351     }
352
353     static synchronized String getTimeZoneDisplay(TimeZone tz,
354                                                   boolean daylight,
355                                                   int style,
356                                                   Locale locale) {
357         Object key = new TimeZoneDisplayKey(tz, daylight, style, locale);
358         String value = (String )cTimeZoneDisplayCache.get(key);
359         if (value == null) {
360             // This is a very slow call, so cache the results.
361 value = tz.getDisplayName(daylight, style, locale);
362             cTimeZoneDisplayCache.put(key, value);
363         }
364         return value;
365     }
366
367     private static synchronized String getDefaultPattern() {
368         if (cDefaultPattern == null) {
369             cDefaultPattern = new SimpleDateFormat ().toPattern();
370         }
371         return cDefaultPattern;
372     }
373
374     /**
375      * Returns a list of Rules.
376      */
377     private static List parse(String pattern, TimeZone timeZone, Locale locale,
378                               DateFormatSymbols symbols) {
379         List rules = new ArrayList ();
380
381         String [] ERAs = symbols.getEras();
382         String [] months = symbols.getMonths();
383         String [] shortMonths = symbols.getShortMonths();
384         String [] weekdays = symbols.getWeekdays();
385         String [] shortWeekdays = symbols.getShortWeekdays();
386         String [] AmPmStrings = symbols.getAmPmStrings();
387
388         int length = pattern.length();
389         int[] indexRef = new int[1];
390
391         for (int i=0; i<length; i++) {
392             indexRef[0] = i;
393             String token = parseToken(pattern, indexRef);
394             i = indexRef[0];
395
396             int tokenLen = token.length();
397             if (tokenLen == 0) {
398                 break;
399             }
400
401             Rule rule;
402             char c = token.charAt(0);
403
404             switch (c) {
405             case 'G': // era designator (text)
406 rule = new TextField(Calendar.ERA, ERAs);
407                 break;
408             case 'y': // year (number)
409 if (tokenLen >= 4) {
410                     rule = new UnpaddedNumberField(Calendar.YEAR);
411                 }
412                 else {
413                     rule = new TwoDigitYearField();
414                 }
415                 break;
416             case 'M': // month in year (text and number)
417 if (tokenLen >= 4) {
418                     rule = new TextField(Calendar.MONTH, months);
419                 }
420                 else if (tokenLen == 3) {
421                     rule = new TextField(Calendar.MONTH, shortMonths);
422                 }
423                 else if (tokenLen == 2) {
424                     rule = new TwoDigitMonthField();
425                 }
426                 else {
427                     rule = new UnpaddedMonthField();
428                 }
429                 break;
430             case 'd': // day in month (number)
431 rule = selectNumberRule(Calendar.DAY_OF_MONTH, tokenLen);
432                 break;
433             case 'h': // hour in am/pm (number, 1..12)
434 rule = new TwelveHourField
435                     (selectNumberRule(Calendar.HOUR, tokenLen));
436                 break;
437             case 'H': // hour in day (number, 0..23)
438 rule = selectNumberRule(Calendar.HOUR_OF_DAY, tokenLen);
439                 break;
440             case 'm': // minute in hour (number)
441 rule = selectNumberRule(Calendar.MINUTE, tokenLen);
442                 break;
443             case 's': // second in minute (number)
444 rule = selectNumberRule(Calendar.SECOND, tokenLen);
445                 break;
446             case 'S': // millisecond (number)
447 rule = selectNumberRule(Calendar.MILLISECOND, tokenLen);
448                 break;
449             case 'E': // day in week (text)
450 rule = new TextField
451                     (Calendar.DAY_OF_WEEK,
452                      tokenLen < 4 ? shortWeekdays : weekdays);
453                 break;
454             case 'D': // day in year (number)
455 rule = selectNumberRule(Calendar.DAY_OF_YEAR, tokenLen);
456                 break;
457             case 'F': // day of week in month (number)
458 rule = selectNumberRule
459                     (Calendar.DAY_OF_WEEK_IN_MONTH, tokenLen);
460                 break;
461             case 'w': // week in year (number)
462 rule = selectNumberRule(Calendar.WEEK_OF_YEAR, tokenLen);
463                 break;
464             case 'W': // week in month (number)
465 rule = selectNumberRule(Calendar.WEEK_OF_MONTH, tokenLen);
466                 break;
467             case 'a': // am/pm marker (text)
468 rule = new TextField(Calendar.AM_PM, AmPmStrings);
469                 break;
470             case 'k': // hour in day (1..24)
471 rule = new TwentyFourHourField
472                     (selectNumberRule(Calendar.HOUR_OF_DAY, tokenLen));
473                 break;
474             case 'K': // hour in am/pm (0..11)
475 rule = selectNumberRule(Calendar.HOUR, tokenLen);
476                 break;
477             case 'z': // time zone (text)
478 if (tokenLen >= 4) {
479                     rule = new TimeZoneRule(timeZone, locale, TimeZone.LONG);
480                 }
481                 else {
482                     rule = new TimeZoneRule(timeZone, locale, TimeZone.SHORT);
483                 }
484                 break;
485             case '\'': // literal text
486 String sub = token.substring(1);
487                 if (sub.length() == 1) {
488                     rule = new CharacterLiteral(sub.charAt(0));
489                 }
490                 else {
491                     rule = new StringLiteral(new String (sub));
492                 }
493                 break;
494             default:
495                 throw new IllegalArgumentException
496                     ("Illegal pattern component: " + token);
497             }
498
499             rules.add(rule);
500         }
501
502         return rules;
503     }
504
505     private static String parseToken(String pattern, int[] indexRef) {
506         StringBuffer buf = new StringBuffer ();
507
508         int i = indexRef[0];
509         int length = pattern.length();
510
511         char c = pattern.charAt(i);
512         if (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z') {
513             // Scan a run of the same character, which indicates a time
514 // pattern.
515 buf.append(c);
516
517             while (i + 1 < length) {
518                 char peek = pattern.charAt(i + 1);
519                 if (peek == c) {
520                     buf.append(c);
521                     i++;
522                 }
523                 else {
524                     break;
525                 }
526             }
527         }
528         else {
529             // This will identify token as text.
530 buf.append('\'');
531
532             boolean inLiteral = false;
533
534             for (; i < length; i++) {
535                 c = pattern.charAt(i);
536                 
537                 if (c == '\'') {
538                     if (i + 1 < length && pattern.charAt(i + 1) == '\'') {
539                         // '' is treated as escaped '
540 i++;
541                         buf.append(c);
542                     }
543                     else {
544                         inLiteral = !inLiteral;
545                     }
546                 }
547                 else if (!inLiteral &&
548                          (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z')) {
549                     i--;
550                     break;
551                 }
552                 else {
553                     buf.append(c);
554                 }
555             }
556         }
557
558         indexRef[0] = i;
559         return buf.toString();
560     }
561
562     private static NumberRule selectNumberRule(int field, int padding) {
563         switch (padding) {
564         case 1:
565             return new UnpaddedNumberField(field);
566         case 2:
567             return new TwoDigitNumberField(field);
568         default:
569             return new PaddedNumberField(field, padding);
570         }
571     }
572
573     private final String mPattern;
574     private final TimeZone mTimeZone;
575     private final Locale mLocale;
576     private final Rule[] mRules;
577     private final int mMaxLengthEstimate;
578
579     private FastDateFormat() {
580         this(getDefaultPattern(), null, null, null);
581     }
582
583     /**
584      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
585      */
586     private FastDateFormat(String pattern) throws IllegalArgumentException {
587         this(pattern, null, null, null);
588     }
589
590     /**
591      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
592      * @param timeZone optional time zone, overrides time zone of formatted
593      * date
594      */
595     private FastDateFormat(String pattern, TimeZone timeZone)
596         throws IllegalArgumentException
597     {
598         this(pattern, timeZone, null, null);
599     }
600
601     /**
602      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
603      * @param locale optional locale, overrides system locale
604      */
605     private FastDateFormat(String pattern, Locale locale)
606         throws IllegalArgumentException
607     {
608         this(pattern, null, locale, null);
609     }
610
611     /**
612      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
613      * @param symbols optional date format symbols, overrides symbols for
614      * system locale
615      */
616     private FastDateFormat(String pattern, DateFormatSymbols symbols)
617         throws IllegalArgumentException
618     {
619         this(pattern, null, null, symbols);
620     }
621
622     /**
623      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
624      * @param timeZone optional time zone, overrides time zone of formatted
625      * date
626      * @param locale optional locale, overrides system locale
627      */
628     private FastDateFormat(String pattern, TimeZone timeZone, Locale locale)
629         throws IllegalArgumentException
630     {
631         this(pattern, timeZone, locale, null);
632     }
633
634     /**
635      * @param pattern {@link java.text.SimpleDateFormat} compatible pattern
636      * @param timeZone optional time zone, overrides time zone of formatted
637      * date
638      * @param locale optional locale, overrides system locale
639      * @param symbols optional date format symbols, overrides symbols for
640      * provided locale
641      */
642     private FastDateFormat(String pattern, TimeZone timeZone, Locale locale,
643                            DateFormatSymbols symbols)
644         throws IllegalArgumentException
645     {
646         if (locale == null) {
647             locale = Locale.getDefault();
648         }
649
650         mPattern = pattern;
651         mTimeZone = timeZone;
652         mLocale = locale;
653
654         if (symbols == null) {
655             symbols = new DateFormatSymbols (locale);
656         }
657
658         List rulesList = parse(pattern, timeZone, locale, symbols);
659         mRules = (Rule[])rulesList.toArray(new Rule[rulesList.size()]);
660
661         int len = 0;
662         for (int i=mRules.length; --i >= 0; ) {
663             len += mRules[i].estimateLength();
664         }
665
666         mMaxLengthEstimate = len;
667     }
668
669     public String format(Date date) {
670         Calendar c = new GregorianCalendar (cDefaultTimeZone);
671         c.setTime(date);
672         if (mTimeZone != null) {
673             c.setTimeZone(mTimeZone);
674         }
675         return applyRules(c, new StringBuffer (mMaxLengthEstimate)).toString();
676     }
677
678     public String format(Calendar calendar) {
679         return format(calendar, new StringBuffer (mMaxLengthEstimate))
680             .toString();
681     }
682
683     public StringBuffer format(Date date, StringBuffer buf) {
684         Calendar c = new GregorianCalendar (cDefaultTimeZone);
685         c.setTime(date);
686         if (mTimeZone != null) {
687             c.setTimeZone(mTimeZone);
688         }
689         return applyRules(c, buf);
690     }
691
692     public StringBuffer format(Calendar calendar, StringBuffer buf) {
693         if (mTimeZone != null) {
694             calendar = (Calendar )calendar.clone();
695             calendar.setTimeZone(mTimeZone);
696         }
697         return applyRules(calendar, buf);
698     }
699
700     private StringBuffer applyRules(Calendar calendar, StringBuffer buf) {
701         Rule[] rules = mRules;
702         int len = mRules.length;
703         for (int i=0; i<len; i++) {
704             rules[i].appendTo(buf, calendar);
705         }
706         return buf;
707     }
708
709     public String getPattern() {
710         return mPattern;
711     }
712     
713     /**
714      * Returns the time zone used by this formatter, or null if time zone of
715      * formatted dates is used instead.
716      */
717     public TimeZone getTimeZone() {
718         return mTimeZone;
719     }
720
721     public Locale getLocale() {
722         return mLocale;
723     }
724
725     /**
726      * Returns an estimate for the maximum length date that this date
727      * formatter will produce. The actual formatted length will almost always
728      * be less than or equal to this amount.
729      */
730     public int getMaxLengthEstimate() {
731         return mMaxLengthEstimate;
732     }
733
734     private interface Rule {
735         int estimateLength();
736
737         void appendTo(StringBuffer buffer, Calendar calendar);
738     }
739
740     private interface NumberRule extends Rule {
741         void appendTo(StringBuffer buffer, int value);
742     }
743
744     private static class CharacterLiteral implements Rule {
745         private final char mValue;
746
747         CharacterLiteral(char value) {
748             mValue = value;
749         }
750
751         public int estimateLength() {
752             return 1;
753         }
754
755         public void appendTo(StringBuffer buffer, Calendar calendar) {
756             buffer.append(mValue);
757         }
758     }
759
760     private static class StringLiteral implements Rule {
761         private final String mValue;
762
763         StringLiteral(String value) {
764             mValue = value;
765         }
766
767         public int estimateLength() {
768             return mValue.length();
769         }
770
771         public void appendTo(StringBuffer buffer, Calendar calendar) {
772             buffer.append(mValue);
773         }
774     }
775
776     private static class TextField implements Rule {
777         private final int mField;
778         private final String [] mValues;
779
780         TextField(int field, String [] values) {
781             mField = field;
782             mValues = values;
783         }
784
785         public int estimateLength() {
786             int max = 0;
787             for (int i=mValues.length; --i >= 0; ) {
788                 int len = mValues[i].length();
789                 if (len > max) {
790                     max = len;
791                 }
792             }
793             return max;
794         }
795
796         public void appendTo(StringBuffer buffer, Calendar calendar) {
797             buffer.append(mValues[calendar.get(mField)]);
798         }
799     }
800
801     private static class UnpaddedNumberField implements NumberRule {
802         private final int mField;
803
804         UnpaddedNumberField(int field) {
805             mField = field;
806         }
807
808         public int estimateLength() {
809             return 4;
810         }
811
812         public void appendTo(StringBuffer buffer, Calendar calendar) {
813             appendTo(buffer, calendar.get(mField));
814         }
815
816         public final void appendTo(StringBuffer buffer, int value) {
817             if (value < 10) {
818                 buffer.append((char)(value + '0'));
819             }
820             else if (value < 100) {
821                 buffer.append((char)(value / 10 + '0'));
822                 buffer.append((char)(value % 10 + '0'));
823             }
824             else {
825                 buffer.append(Integer.toString(value));
826             }
827         }
828     }
829
830     private static class UnpaddedMonthField implements NumberRule {
831         UnpaddedMonthField() {
832         }
833
834         public int estimateLength() {
835             return 2;
836         }
837
838         public void appendTo(StringBuffer buffer, Calendar calendar) {
839             appendTo(buffer, calendar.get(Calendar.MONTH) + 1);
840         }
841
842         public final void appendTo(StringBuffer buffer, int value) {
843             if (value < 10) {
844                 buffer.append((char)(value + '0'));
845             }
846             else {
847                 buffer.append((char)(value / 10 + '0'));
848                 buffer.append((char)(value % 10 + '0'));
849             }
850         }
851     }
852
853     private static class PaddedNumberField implements NumberRule {
854         private final int mField;
855         private final int mSize;
856
857         PaddedNumberField(int field, int size) {
858             if (size < 3) {
859                 // Should use UnpaddedNumberField or TwoDigitNumberField.
860 throw new IllegalArgumentException ();
861             }
862             mField = field;
863             mSize = size;
864         }
865
866         public int estimateLength() {
867             return 4;
868         }
869
870         public void appendTo(StringBuffer buffer, Calendar calendar) {
871             appendTo(buffer, calendar.get(mField));
872         }
873
874         public final void appendTo(StringBuffer buffer, int value) {
875             if (value < 100) {
876                 for (int i = mSize; --i >= 2; ) {
877                     buffer.append('0');
878                 }
879                 buffer.append((char)(value / 10 + '0'));
880                 buffer.append((char)(value % 10 + '0'));
881             }
882             else {
883                 int digits;
884                 if (value < 1000) {
885                     digits = 3;
886                 }
887                 else {
888                     digits = (int)(Math.log(value) / LOG_10) + 1;
889                 }
890                 for (int i = mSize; --i >= digits; ) {
891                     buffer.append('0');
892                 }
893                 buffer.append(Integer.toString(value));
894             }
895         }
896     }
897     
898     private static class TwoDigitNumberField implements NumberRule {
899         private final int mField;
900         
901         TwoDigitNumberField(int field) {
902             mField = field;
903         }
904
905         public int estimateLength() {
906             return 2;
907         }
908
909         public void appendTo(StringBuffer buffer, Calendar calendar) {
910             appendTo(buffer, calendar.get(mField));
911         }
912
913         public final void appendTo(StringBuffer buffer, int value) {
914             if (value < 100) {
915                 buffer.append((char)(value / 10 + '0'));
916                 buffer.append((char)(value % 10 + '0'));
917             }
918             else {
919                 buffer.append(Integer.toString(value));
920             }
921         }
922     }
923
924     private static class TwoDigitYearField implements NumberRule {
925         TwoDigitYearField() {
926         }
927
928         public int estimateLength() {
929             return 2;
930         }
931
932         public void appendTo(StringBuffer buffer, Calendar calendar) {
933             appendTo(buffer, calendar.get(Calendar.YEAR) % 100);
934         }
935
936         public final void appendTo(StringBuffer buffer, int value) {
937             buffer.append((char)(value / 10 + '0'));
938             buffer.append((char)(value % 10 + '0'));
939         }
940     }
941
942     private static class TwoDigitMonthField implements NumberRule {
943         TwoDigitMonthField() {
944         }
945
946         public int estimateLength() {
947             return 2;
948         }
949
950         public void appendTo(StringBuffer buffer, Calendar calendar) {
951             appendTo(buffer, calendar.get(Calendar.MONTH) + 1);
952         }
953         
954         public final void appendTo(StringBuffer buffer, int value) {
955             buffer.append((char)(value / 10 + '0'));
956             buffer.append((char)(value % 10 + '0'));
957         }
958     }
959
960     private static class TwelveHourField implements NumberRule {
961         private final NumberRule mRule;
962
963         TwelveHourField(NumberRule rule) {
964             mRule = rule;
965         }
966
967         public int estimateLength() {
968             return mRule.estimateLength();
969         }
970
971         public void appendTo(StringBuffer buffer, Calendar calendar) {
972             int value = calendar.get(Calendar.HOUR);
973             if (value == 0) {
974                 value = calendar.getLeastMaximum(Calendar.HOUR) + 1;
975             }
976             mRule.appendTo(buffer, value);
977         }
978
979         public void appendTo(StringBuffer buffer, int value) {
980             mRule.appendTo(buffer, value);
981         }
982     }
983
984     private static class TwentyFourHourField implements NumberRule {
985         private final NumberRule mRule;
986
987         TwentyFourHourField(NumberRule rule) {
988             mRule = rule;
989         }
990
991         public int estimateLength() {
992             return mRule.estimateLength();
993         }
994
995         public void appendTo(StringBuffer buffer, Calendar calendar) {
996             int value = calendar.get(Calendar.HOUR_OF_DAY);
997             if (value == 0) {
998                 value = calendar.getMaximum(Calendar.HOUR_OF_DAY) + 1;
999             }
1000            mRule.appendTo(buffer, value);
1001        }
1002
1003        public void appendTo(StringBuffer buffer, int value) {
1004            mRule.appendTo(buffer, value);
1005        }
1006    }
1007
1008    private static class TimeZoneRule implements Rule {
1009        private final TimeZone mTimeZone;
1010        private final Locale mLocale;
1011        private final int mStyle;
1012        private final String mStandard;
1013        private final String mDaylight;
1014
1015        TimeZoneRule(TimeZone timeZone, Locale locale, int style) {
1016            mTimeZone = timeZone;
1017            mLocale = locale;
1018            mStyle = style;
1019
1020            if (timeZone != null) {
1021                mStandard = getTimeZoneDisplay(timeZone, false, style, locale);
1022                mDaylight = getTimeZoneDisplay(timeZone, true, style, locale);
1023            }
1024            else {
1025                mStandard = null;
1026                mDaylight = null;
1027            }
1028        }
1029
1030        public int estimateLength() {
1031            if (mTimeZone != null) {
1032                return Math.max(mStandard.length(), mDaylight.length());
1033            }
1034            else if (mStyle == TimeZone.SHORT) {
1035                return 4;
1036            }
1037            else {
1038                return 40;
1039            }
1040        }
1041
1042        public void appendTo(StringBuffer buffer, Calendar calendar) {
1043            TimeZone timeZone;
1044            if ((timeZone = mTimeZone) != null) {
1045                if (timeZone.useDaylightTime() &&
1046                    calendar.get(Calendar.DST_OFFSET) != 0) {
1047
1048                    buffer.append(mDaylight);
1049                }
1050                else {
1051                    buffer.append(mStandard);
1052                }
1053            }
1054            else {
1055                timeZone = calendar.getTimeZone();
1056                if (timeZone.useDaylightTime() &&
1057                    calendar.get(Calendar.DST_OFFSET) != 0) {
1058
1059                    buffer.append(getTimeZoneDisplay
1060                                  (timeZone, true, mStyle, mLocale));
1061                }
1062                else {
1063                    buffer.append(getTimeZoneDisplay
1064                                  (timeZone, false, mStyle, mLocale));
1065                }
1066            }
1067        }
1068    }
1069
1070    private static class TimeZoneDisplayKey {
1071        private final TimeZone mTimeZone;
1072        private final int mStyle;
1073        private final Locale mLocale;
1074
1075        TimeZoneDisplayKey(TimeZone timeZone,
1076                           boolean daylight, int style, Locale locale) {
1077            mTimeZone = timeZone;
1078            if (daylight) {
1079                style |= 0x80000000;
1080            }
1081            mStyle = style;
1082            mLocale = locale;
1083        }
1084
1085        public int hashCode() {
1086            return mStyle * 31 + mLocale.hashCode();
1087        }
1088
1089        public boolean equals(Object obj) {
1090            if (this == obj) {
1091                return true;
1092            }
1093            if (obj instanceof TimeZoneDisplayKey) {
1094                TimeZoneDisplayKey other = (TimeZoneDisplayKey)obj;
1095                return
1096                    mTimeZone.equals(other.mTimeZone) &&
1097                    mStyle == other.mStyle &&
1098                    mLocale.equals(other.mLocale);
1099            }
1100            return false;
1101        }
1102    }
1103}
1104

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags