1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.logging.log4j.core.util.datetime;
18
19 import java.io.IOException;
20 import java.io.ObjectInputStream;
21 import java.io.Serializable;
22 import java.text.DateFormat;
23 import java.text.DateFormatSymbols;
24 import java.text.FieldPosition;
25 import java.util.ArrayList;
26 import java.util.Calendar;
27 import java.util.Date;
28 import java.util.GregorianCalendar;
29 import java.util.List;
30 import java.util.Locale;
31 import java.util.TimeZone;
32 import java.util.concurrent.ConcurrentHashMap;
33 import java.util.concurrent.ConcurrentMap;
34
35
36
37
38 public class FastDatePrinter implements DatePrinter, Serializable {
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54 public static final int FULL = DateFormat.FULL;
55
56
57
58 public static final int LONG = DateFormat.LONG;
59
60
61
62 public static final int MEDIUM = DateFormat.MEDIUM;
63
64
65
66 public static final int SHORT = DateFormat.SHORT;
67
68
69
70
71
72
73 private static final long serialVersionUID = 1L;
74
75
76
77
78 private final String mPattern;
79
80
81
82 private final TimeZone mTimeZone;
83
84
85
86 private final Locale mLocale;
87
88
89
90 private transient Rule[] mRules;
91
92
93
94 private transient int mMaxLengthEstimate;
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110 protected FastDatePrinter(final String pattern, final TimeZone timeZone, final Locale locale) {
111 mPattern = pattern;
112 mTimeZone = timeZone;
113 mLocale = locale;
114
115 init();
116 }
117
118
119
120
121
122
123 private void init() {
124 final List<Rule> rulesList = parsePattern();
125 mRules = rulesList.toArray(new Rule[rulesList.size()]);
126
127 int len = 0;
128 for (int i = mRules.length; --i >= 0;) {
129 len += mRules[i].estimateLength();
130 }
131
132 mMaxLengthEstimate = len;
133 }
134
135
136
137
138
139
140
141
142
143
144
145 protected List<Rule> parsePattern() {
146 final DateFormatSymbols symbols = new DateFormatSymbols(mLocale);
147 final List<Rule> rules = new ArrayList<Rule>();
148
149 final String[] ERAs = symbols.getEras();
150 final String[] months = symbols.getMonths();
151 final String[] shortMonths = symbols.getShortMonths();
152 final String[] weekdays = symbols.getWeekdays();
153 final String[] shortWeekdays = symbols.getShortWeekdays();
154 final String[] AmPmStrings = symbols.getAmPmStrings();
155
156 final int length = mPattern.length();
157 final int[] indexRef = new int[1];
158
159 for (int i = 0; i < length; i++) {
160 indexRef[0] = i;
161 final String token = parseToken(mPattern, indexRef);
162 i = indexRef[0];
163
164 final int tokenLen = token.length();
165 if (tokenLen == 0) {
166 break;
167 }
168
169 Rule rule;
170 final char c = token.charAt(0);
171
172 switch (c) {
173 case 'G':
174 rule = new TextField(Calendar.ERA, ERAs);
175 break;
176 case 'y':
177 if (tokenLen == 2) {
178 rule = TwoDigitYearField.INSTANCE;
179 } else {
180 rule = selectNumberRule(Calendar.YEAR, tokenLen < 4 ? 4 : tokenLen);
181 }
182 break;
183 case 'M':
184 if (tokenLen >= 4) {
185 rule = new TextField(Calendar.MONTH, months);
186 } else if (tokenLen == 3) {
187 rule = new TextField(Calendar.MONTH, shortMonths);
188 } else if (tokenLen == 2) {
189 rule = TwoDigitMonthField.INSTANCE;
190 } else {
191 rule = UnpaddedMonthField.INSTANCE;
192 }
193 break;
194 case 'd':
195 rule = selectNumberRule(Calendar.DAY_OF_MONTH, tokenLen);
196 break;
197 case 'h':
198 rule = new TwelveHourField(selectNumberRule(Calendar.HOUR, tokenLen));
199 break;
200 case 'H':
201 rule = selectNumberRule(Calendar.HOUR_OF_DAY, tokenLen);
202 break;
203 case 'm':
204 rule = selectNumberRule(Calendar.MINUTE, tokenLen);
205 break;
206 case 's':
207 rule = selectNumberRule(Calendar.SECOND, tokenLen);
208 break;
209 case 'S':
210 rule = selectNumberRule(Calendar.MILLISECOND, tokenLen);
211 break;
212 case 'E':
213 rule = new TextField(Calendar.DAY_OF_WEEK, tokenLen < 4 ? shortWeekdays : weekdays);
214 break;
215 case 'D':
216 rule = selectNumberRule(Calendar.DAY_OF_YEAR, tokenLen);
217 break;
218 case 'F':
219 rule = selectNumberRule(Calendar.DAY_OF_WEEK_IN_MONTH, tokenLen);
220 break;
221 case 'w':
222 rule = selectNumberRule(Calendar.WEEK_OF_YEAR, tokenLen);
223 break;
224 case 'W':
225 rule = selectNumberRule(Calendar.WEEK_OF_MONTH, tokenLen);
226 break;
227 case 'a':
228 rule = new TextField(Calendar.AM_PM, AmPmStrings);
229 break;
230 case 'k':
231 rule = new TwentyFourHourField(selectNumberRule(Calendar.HOUR_OF_DAY, tokenLen));
232 break;
233 case 'K':
234 rule = selectNumberRule(Calendar.HOUR, tokenLen);
235 break;
236 case 'X':
237 rule = Iso8601_Rule.getRule(tokenLen);
238 break;
239 case 'z':
240 if (tokenLen >= 4) {
241 rule = new TimeZoneNameRule(mTimeZone, mLocale, TimeZone.LONG);
242 } else {
243 rule = new TimeZoneNameRule(mTimeZone, mLocale, TimeZone.SHORT);
244 }
245 break;
246 case 'Z':
247 if (tokenLen == 1) {
248 rule = TimeZoneNumberRule.INSTANCE_NO_COLON;
249 } else if (tokenLen == 2) {
250 rule = Iso8601_Rule.ISO8601_HOURS_COLON_MINUTES;
251 } else {
252 rule = TimeZoneNumberRule.INSTANCE_COLON;
253 }
254 break;
255 case '\'':
256 final String sub = token.substring(1);
257 if (sub.length() == 1) {
258 rule = new CharacterLiteral(sub.charAt(0));
259 } else {
260 rule = new StringLiteral(sub);
261 }
262 break;
263 default:
264 throw new IllegalArgumentException("Illegal pattern component: " + token);
265 }
266
267 rules.add(rule);
268 }
269
270 return rules;
271 }
272
273
274
275
276
277
278
279
280
281
282 protected String parseToken(final String pattern, final int[] indexRef) {
283 final StringBuilder buf = new StringBuilder();
284
285 int i = indexRef[0];
286 final int length = pattern.length();
287
288 char c = pattern.charAt(i);
289 if (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z') {
290
291
292 buf.append(c);
293
294 while (i + 1 < length) {
295 final char peek = pattern.charAt(i + 1);
296 if (peek == c) {
297 buf.append(c);
298 i++;
299 } else {
300 break;
301 }
302 }
303 } else {
304
305 buf.append('\'');
306
307 boolean inLiteral = false;
308
309 for (; i < length; i++) {
310 c = pattern.charAt(i);
311
312 if (c == '\'') {
313 if (i + 1 < length && pattern.charAt(i + 1) == '\'') {
314
315 i++;
316 buf.append(c);
317 } else {
318 inLiteral = !inLiteral;
319 }
320 } else if (!inLiteral && (c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z')) {
321 i--;
322 break;
323 } else {
324 buf.append(c);
325 }
326 }
327 }
328
329 indexRef[0] = i;
330 return buf.toString();
331 }
332
333
334
335
336
337
338
339
340
341
342 protected NumberRule selectNumberRule(final int field, final int padding) {
343 switch (padding) {
344 case 1:
345 return new UnpaddedNumberField(field);
346 case 2:
347 return new TwoDigitNumberField(field);
348 default:
349 return new PaddedNumberField(field, padding);
350 }
351 }
352
353
354
355
356
357
358
359
360
361
362
363
364
365 @Override
366 public StringBuilder format(final Object obj, final StringBuilder toAppendTo, final FieldPosition pos) {
367 if (obj instanceof Date) {
368 return format((Date) obj, toAppendTo);
369 } else if (obj instanceof Calendar) {
370 return format((Calendar) obj, toAppendTo);
371 } else if (obj instanceof Long) {
372 return format(((Long) obj).longValue(), toAppendTo);
373 } else {
374 throw new IllegalArgumentException("Unknown class: " + (obj == null ? "<null>" : obj.getClass().getName()));
375 }
376 }
377
378
379
380
381
382
383 @Override
384 public String format(final long millis) {
385 final Calendar c = newCalendar();
386 c.setTimeInMillis(millis);
387 return applyRulesToString(c);
388 }
389
390
391
392
393
394
395
396 private String applyRulesToString(final Calendar c) {
397 return applyRules(c, new StringBuilder(mMaxLengthEstimate)).toString();
398 }
399
400
401
402
403
404
405 private GregorianCalendar newCalendar() {
406
407 return new GregorianCalendar(mTimeZone, mLocale);
408 }
409
410
411
412
413
414
415 @Override
416 public String format(final Date date) {
417 final Calendar c = newCalendar();
418 c.setTime(date);
419 return applyRulesToString(c);
420 }
421
422
423
424
425
426
427 @Override
428 public String format(final Calendar calendar) {
429 return format(calendar, new StringBuilder(mMaxLengthEstimate)).toString();
430 }
431
432
433
434
435
436
437 @Override
438 public StringBuilder format(final long millis, final StringBuilder buf) {
439 return format(new Date(millis), buf);
440 }
441
442
443
444
445
446
447 @Override
448 public StringBuilder format(final Date date, final StringBuilder buf) {
449 final Calendar c = newCalendar();
450 c.setTime(date);
451 return applyRules(c, buf);
452 }
453
454
455
456
457
458
459 @Override
460 public StringBuilder format(final Calendar calendar, final StringBuilder buf) {
461
462 return format(calendar.getTime(), buf);
463 }
464
465
466
467
468
469
470
471
472
473
474 protected StringBuilder applyRules(final Calendar calendar, final StringBuilder buf) {
475 for (final Rule rule : mRules) {
476 rule.appendTo(buf, calendar);
477 }
478 return buf;
479 }
480
481
482
483
484
485
486
487
488 @Override
489 public String getPattern() {
490 return mPattern;
491 }
492
493
494
495
496
497
498 @Override
499 public TimeZone getTimeZone() {
500 return mTimeZone;
501 }
502
503
504
505
506
507
508 @Override
509 public Locale getLocale() {
510 return mLocale;
511 }
512
513
514
515
516
517
518
519
520
521
522
523
524 public int getMaxLengthEstimate() {
525 return mMaxLengthEstimate;
526 }
527
528
529
530
531
532
533
534
535
536
537
538 @Override
539 public boolean equals(final Object obj) {
540 if (obj instanceof FastDatePrinter == false) {
541 return false;
542 }
543 final FastDatePrinter other = (FastDatePrinter) obj;
544 return mPattern.equals(other.mPattern) && mTimeZone.equals(other.mTimeZone) && mLocale.equals(other.mLocale);
545 }
546
547
548
549
550
551
552
553
554 @Override
555 public int hashCode() {
556 return mPattern.hashCode() + 13 * (mTimeZone.hashCode() + 13 * mLocale.hashCode());
557 }
558
559
560
561
562
563
564
565
566 @Override
567 public String toString() {
568 return "FastDatePrinter[" + mPattern + "," + mLocale + "," + mTimeZone.getID() + "]";
569 }
570
571
572
573
574
575
576
577
578
579
580 private void readObject(final ObjectInputStream in) throws IOException, ClassNotFoundException {
581 in.defaultReadObject();
582 init();
583 }
584
585
586
587
588
589
590
591 private static void appendDigits(final StringBuilder buffer, final int value) {
592 buffer.append((char) (value / 10 + '0'));
593 buffer.append((char) (value % 10 + '0'));
594 }
595
596
597
598
599
600
601
602
603 private interface Rule {
604
605
606
607
608
609 int estimateLength();
610
611
612
613
614
615
616
617 void appendTo(StringBuilder buffer, Calendar calendar);
618 }
619
620
621
622
623
624
625 private interface NumberRule extends Rule {
626
627
628
629
630
631
632 void appendTo(StringBuilder buffer, int value);
633 }
634
635
636
637
638
639
640 private static class CharacterLiteral implements Rule {
641 private final char mValue;
642
643
644
645
646
647
648 CharacterLiteral(final char value) {
649 mValue = value;
650 }
651
652
653
654
655 @Override
656 public int estimateLength() {
657 return 1;
658 }
659
660
661
662
663 @Override
664 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
665 buffer.append(mValue);
666 }
667 }
668
669
670
671
672
673
674 private static class StringLiteral implements Rule {
675 private final String mValue;
676
677
678
679
680
681
682 StringLiteral(final String value) {
683 mValue = value;
684 }
685
686
687
688
689 @Override
690 public int estimateLength() {
691 return mValue.length();
692 }
693
694
695
696
697 @Override
698 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
699 buffer.append(mValue);
700 }
701 }
702
703
704
705
706
707
708 private static class TextField implements Rule {
709 private final int mField;
710 private final String[] mValues;
711
712
713
714
715
716
717
718 TextField(final int field, final String[] values) {
719 mField = field;
720 mValues = values;
721 }
722
723
724
725
726 @Override
727 public int estimateLength() {
728 int max = 0;
729 for (int i = mValues.length; --i >= 0;) {
730 final int len = mValues[i].length();
731 if (len > max) {
732 max = len;
733 }
734 }
735 return max;
736 }
737
738
739
740
741 @Override
742 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
743 buffer.append(mValues[calendar.get(mField)]);
744 }
745 }
746
747
748
749
750
751
752 private static class UnpaddedNumberField implements NumberRule {
753 private final int mField;
754
755
756
757
758
759
760 UnpaddedNumberField(final int field) {
761 mField = field;
762 }
763
764
765
766
767 @Override
768 public int estimateLength() {
769 return 4;
770 }
771
772
773
774
775 @Override
776 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
777 appendTo(buffer, calendar.get(mField));
778 }
779
780
781
782
783 @Override
784 public final void appendTo(final StringBuilder buffer, final int value) {
785 if (value < 10) {
786 buffer.append((char) (value + '0'));
787 } else if (value < 100) {
788 appendDigits(buffer, value);
789 } else {
790 buffer.append(value);
791 }
792 }
793 }
794
795
796
797
798
799
800 private static class UnpaddedMonthField implements NumberRule {
801 static final UnpaddedMonthField INSTANCE = new UnpaddedMonthField();
802
803
804
805
806
807 UnpaddedMonthField() {
808 super();
809 }
810
811
812
813
814 @Override
815 public int estimateLength() {
816 return 2;
817 }
818
819
820
821
822 @Override
823 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
824 appendTo(buffer, calendar.get(Calendar.MONTH) + 1);
825 }
826
827
828
829
830 @Override
831 public final void appendTo(final StringBuilder buffer, final int value) {
832 if (value < 10) {
833 buffer.append((char) (value + '0'));
834 } else {
835 appendDigits(buffer, value);
836 }
837 }
838 }
839
840
841
842
843
844
845 private static class PaddedNumberField implements NumberRule {
846 private final int mField;
847 private final int mSize;
848
849
850
851
852
853
854
855 PaddedNumberField(final int field, final int size) {
856 if (size < 3) {
857
858 throw new IllegalArgumentException();
859 }
860 mField = field;
861 mSize = size;
862 }
863
864
865
866
867 @Override
868 public int estimateLength() {
869 return mSize;
870 }
871
872
873
874
875 @Override
876 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
877 appendTo(buffer, calendar.get(mField));
878 }
879
880
881
882
883 @Override
884 public final void appendTo(final StringBuilder buffer, int value) {
885
886 for (int digit = 0; digit < mSize; ++digit) {
887 buffer.append('0');
888 }
889
890 int index = buffer.length();
891 for (; value > 0; value /= 10) {
892 buffer.setCharAt(--index, (char) ('0' + value % 10));
893 }
894 }
895 }
896
897
898
899
900
901
902 private static class TwoDigitNumberField implements NumberRule {
903 private final int mField;
904
905
906
907
908
909
910 TwoDigitNumberField(final int field) {
911 mField = field;
912 }
913
914
915
916
917 @Override
918 public int estimateLength() {
919 return 2;
920 }
921
922
923
924
925 @Override
926 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
927 appendTo(buffer, calendar.get(mField));
928 }
929
930
931
932
933 @Override
934 public final void appendTo(final StringBuilder buffer, final int value) {
935 if (value < 100) {
936 appendDigits(buffer, value);
937 } else {
938 buffer.append(value);
939 }
940 }
941 }
942
943
944
945
946
947
948 private static class TwoDigitYearField implements NumberRule {
949 static final TwoDigitYearField INSTANCE = new TwoDigitYearField();
950
951
952
953
954 TwoDigitYearField() {
955 super();
956 }
957
958
959
960
961 @Override
962 public int estimateLength() {
963 return 2;
964 }
965
966
967
968
969 @Override
970 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
971 appendTo(buffer, calendar.get(Calendar.YEAR) % 100);
972 }
973
974
975
976
977 @Override
978 public final void appendTo(final StringBuilder buffer, final int value) {
979 appendDigits(buffer, value);
980 }
981 }
982
983
984
985
986
987
988 private static class TwoDigitMonthField implements NumberRule {
989 static final TwoDigitMonthField INSTANCE = new TwoDigitMonthField();
990
991
992
993
994 TwoDigitMonthField() {
995 super();
996 }
997
998
999
1000
1001 @Override
1002 public int estimateLength() {
1003 return 2;
1004 }
1005
1006
1007
1008
1009 @Override
1010 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1011 appendTo(buffer, calendar.get(Calendar.MONTH) + 1);
1012 }
1013
1014
1015
1016
1017 @Override
1018 public final void appendTo(final StringBuilder buffer, final int value) {
1019 appendDigits(buffer, value);
1020 }
1021 }
1022
1023
1024
1025
1026
1027
1028 private static class TwelveHourField implements NumberRule {
1029 private final NumberRule mRule;
1030
1031
1032
1033
1034
1035
1036 TwelveHourField(final NumberRule rule) {
1037 mRule = rule;
1038 }
1039
1040
1041
1042
1043 @Override
1044 public int estimateLength() {
1045 return mRule.estimateLength();
1046 }
1047
1048
1049
1050
1051 @Override
1052 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1053 int value = calendar.get(Calendar.HOUR);
1054 if (value == 0) {
1055 value = calendar.getLeastMaximum(Calendar.HOUR) + 1;
1056 }
1057 mRule.appendTo(buffer, value);
1058 }
1059
1060
1061
1062
1063 @Override
1064 public void appendTo(final StringBuilder buffer, final int value) {
1065 mRule.appendTo(buffer, value);
1066 }
1067 }
1068
1069
1070
1071
1072
1073
1074 private static class TwentyFourHourField implements NumberRule {
1075 private final NumberRule mRule;
1076
1077
1078
1079
1080
1081
1082 TwentyFourHourField(final NumberRule rule) {
1083 mRule = rule;
1084 }
1085
1086
1087
1088
1089 @Override
1090 public int estimateLength() {
1091 return mRule.estimateLength();
1092 }
1093
1094
1095
1096
1097 @Override
1098 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1099 int value = calendar.get(Calendar.HOUR_OF_DAY);
1100 if (value == 0) {
1101 value = calendar.getMaximum(Calendar.HOUR_OF_DAY) + 1;
1102 }
1103 mRule.appendTo(buffer, value);
1104 }
1105
1106
1107
1108
1109 @Override
1110 public void appendTo(final StringBuilder buffer, final int value) {
1111 mRule.appendTo(buffer, value);
1112 }
1113 }
1114
1115
1116
1117 private static final ConcurrentMap<TimeZoneDisplayKey, String> cTimeZoneDisplayCache = new ConcurrentHashMap<TimeZoneDisplayKey, String>(
1118 7);
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131 static String getTimeZoneDisplay(final TimeZone tz, final boolean daylight, final int style, final Locale locale) {
1132 final TimeZoneDisplayKey key = new TimeZoneDisplayKey(tz, daylight, style, locale);
1133 String value = cTimeZoneDisplayCache.get(key);
1134 if (value == null) {
1135
1136 value = tz.getDisplayName(daylight, style, locale);
1137 final String prior = cTimeZoneDisplayCache.putIfAbsent(key, value);
1138 if (prior != null) {
1139 value = prior;
1140 }
1141 }
1142 return value;
1143 }
1144
1145
1146
1147
1148
1149
1150 private static class TimeZoneNameRule implements Rule {
1151 private final Locale mLocale;
1152 private final int mStyle;
1153 private final String mStandard;
1154 private final String mDaylight;
1155
1156
1157
1158
1159
1160
1161
1162
1163 TimeZoneNameRule(final TimeZone timeZone, final Locale locale, final int style) {
1164 mLocale = locale;
1165 mStyle = style;
1166
1167 mStandard = getTimeZoneDisplay(timeZone, false, style, locale);
1168 mDaylight = getTimeZoneDisplay(timeZone, true, style, locale);
1169 }
1170
1171
1172
1173
1174 @Override
1175 public int estimateLength() {
1176
1177
1178
1179 return Math.max(mStandard.length(), mDaylight.length());
1180 }
1181
1182
1183
1184
1185 @Override
1186 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1187 final TimeZone zone = calendar.getTimeZone();
1188 if (calendar.get(Calendar.DST_OFFSET) != 0) {
1189 buffer.append(getTimeZoneDisplay(zone, true, mStyle, mLocale));
1190 } else {
1191 buffer.append(getTimeZoneDisplay(zone, false, mStyle, mLocale));
1192 }
1193 }
1194 }
1195
1196
1197
1198
1199
1200
1201 private static class TimeZoneNumberRule implements Rule {
1202 static final TimeZoneNumberRule INSTANCE_COLON = new TimeZoneNumberRule(true);
1203 static final TimeZoneNumberRule INSTANCE_NO_COLON = new TimeZoneNumberRule(false);
1204
1205 final boolean mColon;
1206
1207
1208
1209
1210
1211
1212 TimeZoneNumberRule(final boolean colon) {
1213 mColon = colon;
1214 }
1215
1216
1217
1218
1219 @Override
1220 public int estimateLength() {
1221 return 5;
1222 }
1223
1224
1225
1226
1227 @Override
1228 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1229
1230 int offset = calendar.get(Calendar.ZONE_OFFSET) + calendar.get(Calendar.DST_OFFSET);
1231
1232 if (offset < 0) {
1233 buffer.append('-');
1234 offset = -offset;
1235 } else {
1236 buffer.append('+');
1237 }
1238
1239 final int hours = offset / (60 * 60 * 1000);
1240 appendDigits(buffer, hours);
1241
1242 if (mColon) {
1243 buffer.append(':');
1244 }
1245
1246 final int minutes = offset / (60 * 1000) - 60 * hours;
1247 appendDigits(buffer, minutes);
1248 }
1249 }
1250
1251
1252
1253
1254
1255
1256 private static class Iso8601_Rule implements Rule {
1257
1258
1259 static final Iso8601_Rule ISO8601_HOURS = new Iso8601_Rule(3);
1260
1261 static final Iso8601_Rule ISO8601_HOURS_MINUTES = new Iso8601_Rule(5);
1262
1263 static final Iso8601_Rule ISO8601_HOURS_COLON_MINUTES = new Iso8601_Rule(6);
1264
1265
1266
1267
1268
1269
1270
1271
1272 static Iso8601_Rule getRule(final int tokenLen) {
1273 switch (tokenLen) {
1274 case 1:
1275 return Iso8601_Rule.ISO8601_HOURS;
1276 case 2:
1277 return Iso8601_Rule.ISO8601_HOURS_MINUTES;
1278 case 3:
1279 return Iso8601_Rule.ISO8601_HOURS_COLON_MINUTES;
1280 default:
1281 throw new IllegalArgumentException("invalid number of X");
1282 }
1283 }
1284
1285 final int length;
1286
1287
1288
1289
1290
1291
1292 Iso8601_Rule(final int length) {
1293 this.length = length;
1294 }
1295
1296
1297
1298
1299 @Override
1300 public int estimateLength() {
1301 return length;
1302 }
1303
1304
1305
1306
1307 @Override
1308 public void appendTo(final StringBuilder buffer, final Calendar calendar) {
1309 int offset = calendar.get(Calendar.ZONE_OFFSET) + calendar.get(Calendar.DST_OFFSET);
1310 if (offset == 0) {
1311 buffer.append("Z");
1312 return;
1313 }
1314
1315 if (offset < 0) {
1316 buffer.append('-');
1317 offset = -offset;
1318 } else {
1319 buffer.append('+');
1320 }
1321
1322 final int hours = offset / (60 * 60 * 1000);
1323 appendDigits(buffer, hours);
1324
1325 if (length < 5) {
1326 return;
1327 }
1328
1329 if (length == 6) {
1330 buffer.append(':');
1331 }
1332
1333 final int minutes = offset / (60 * 1000) - 60 * hours;
1334 appendDigits(buffer, minutes);
1335 }
1336 }
1337
1338
1339
1340
1341
1342
1343
1344 private static class TimeZoneDisplayKey {
1345 private final TimeZone mTimeZone;
1346 private final int mStyle;
1347 private final Locale mLocale;
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357 TimeZoneDisplayKey(final TimeZone timeZone, final boolean daylight, final int style, final Locale locale) {
1358 mTimeZone = timeZone;
1359 if (daylight) {
1360 mStyle = style | 0x80000000;
1361 } else {
1362 mStyle = style;
1363 }
1364 mLocale = locale;
1365 }
1366
1367
1368
1369
1370 @Override
1371 public int hashCode() {
1372 return (mStyle * 31 + mLocale.hashCode()) * 31 + mTimeZone.hashCode();
1373 }
1374
1375
1376
1377
1378 @Override
1379 public boolean equals(final Object obj) {
1380 if (this == obj) {
1381 return true;
1382 }
1383 if (obj instanceof TimeZoneDisplayKey) {
1384 final TimeZoneDisplayKey other = (TimeZoneDisplayKey) obj;
1385 return mTimeZone.equals(other.mTimeZone) && mStyle == other.mStyle && mLocale.equals(other.mLocale);
1386 }
1387 return false;
1388 }
1389 }
1390 }