Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    *  Copyright 2001-2013 Stephen Colebourne
3
    *
4
    *  Licensed under the Apache License, Version 2.0 (the "License");
5
    *  you may not use this file except in compliance with the License.
6
    *  You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   *  Unless required by applicable law or agreed to in writing, software
11
   *  distributed under the License is distributed on an "AS IS" BASIS,
12
   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   *  See the License for the specific language governing permissions and
14
   *  limitations under the License.
15
   */
16
  package org.joda.time.tz;
17
  
18
  import java.io.DataInput;
27
  import java.util.Arrays;
28
  import java.util.HashSet;
30
  import java.util.Locale;
31
  import java.util.Set;
32
  
DateTimeZoneBuilder allows complex DateTimeZones to be constructed. Since creating a new DateTimeZone this way is a relatively expensive operation, built zones can be written to a file. Reading back the encoded data is a quick operation.

DateTimeZoneBuilder itself is mutable and not thread-safe, but the DateTimeZone objects that it builds are thread-safe and immutable.

It is intended that ZoneInfoCompiler be used to read time zone data files, indirectly calling DateTimeZoneBuilder. The following complex example defines the America/Los_Angeles time zone, with all historical transitions: 

 DateTimeZone America_Los_Angeles = new DateTimeZoneBuilder()
     .addCutover(-2147483648, 'w', 1, 1, 0, false, 0)
     .setStandardOffset(-28378000)
     .setFixedSavings("LMT", 0)
     .addCutover(1883, 'w', 11, 18, 0, false, 43200000)
     .setStandardOffset(-28800000)
     .addRecurringSavings("PDT", 3600000, 1918, 1919, 'w',  3, -1, 7, false, 7200000)
     .addRecurringSavings("PST",       0, 1918, 1919, 'w', 10, -1, 7, false, 7200000)
     .addRecurringSavings("PWT", 3600000, 1942, 1942, 'w',  2,  9, 0, false, 7200000)
     .addRecurringSavings("PPT", 3600000, 1945, 1945, 'u',  8, 14, 0, false, 82800000)
     .addRecurringSavings("PST",       0, 1945, 1945, 'w',  9, 30, 0, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1948, 1948, 'w',  3, 14, 0, false, 7200000)
     .addRecurringSavings("PST",       0, 1949, 1949, 'w',  1,  1, 0, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1950, 1966, 'w',  4, -1, 7, false, 7200000)
     .addRecurringSavings("PST",       0, 1950, 1961, 'w',  9, -1, 7, false, 7200000)
     .addRecurringSavings("PST",       0, 1962, 1966, 'w', 10, -1, 7, false, 7200000)
     .addRecurringSavings("PST",       0, 1967, 2147483647, 'w', 10, -1, 7, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1967, 1973, 'w', 4, -1,  7, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1974, 1974, 'w', 1,  6,  0, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1975, 1975, 'w', 2, 23,  0, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1976, 1986, 'w', 4, -1,  7, false, 7200000)
     .addRecurringSavings("PDT", 3600000, 1987, 2147483647, 'w', 4, 1, 7, true, 7200000)
     .toDateTimeZone("America/Los_Angeles", true);

Author(s):
Brian S O'Neill
Since:
1.0
See also:
ZoneInfoCompiler
ZoneInfoProvider
85
  
86
  public class DateTimeZoneBuilder {
    
Decodes a built DateTimeZone from the given stream, as encoded by writeTo.

Parameters:
in input stream to read encoded DateTimeZone from.
id time zone id to assign
93
  
94
      public static DateTimeZone readFrom(InputStream in, String id) throws IOException {
95
          if (in instanceof DataInput) {
96
              return readFrom((DataInput)in, id);
97
          } else {
98
              return readFrom((DataInput)new DataInputStream(in), id);
99
          }
100
     }

    
Decodes a built DateTimeZone from the given stream, as encoded by writeTo.

Parameters:
in input stream to read encoded DateTimeZone from.
id time zone id to assign
108
 
109
     public static DateTimeZone readFrom(DataInput in, String id) throws IOException {
110
         switch (in.readUnsignedByte()) {
111
         case 'F':
112
             DateTimeZone fixed = new FixedDateTimeZone
113
                 (id, in.readUTF(), (int)readMillis(in), (int)readMillis(in));
114
             if (fixed.equals(.)) {
115
                 fixed = .;
116
             }
117
             return fixed;
118
         case 'C':
119
             return CachedDateTimeZone.forZone(PrecalculatedZone.readFrom(in, id));
120
         case 'P':
121
             return PrecalculatedZone.readFrom(in, id);
122
         default:
123
             throw new IOException("Invalid encoding");
124
         }
125
     }

    
Millisecond encoding formats: upper two bits units field length approximate range --------------------------------------------------------------- 00 30 minutes 1 byte +/- 16 hours 01 minutes 4 bytes +/- 1020 years 10 seconds 5 bytes +/- 4355 years 11 millis 9 bytes +/- 292,000,000 years Remaining bits in field form signed offset from 1970-01-01T00:00:00Z. 
138
 
139
     static void writeMillis(DataOutput out, long millis) throws IOException {
140
         if (millis % (30 * 60000L) == 0) {
141
             // Try to write in 30 minute units.
142
             long units = millis / (30 * 60000L);
143
             if (((units << (64 - 6)) >> (64 - 6)) == units) {
144
                 // Form 00 (6 bits effective precision)
145
                 out.writeByte((int)(units & 0x3f));
146
                 return;
147
             }
148
         }
149
 
150
         if (millis % 60000L == 0) {
151
             // Try to write minutes.
152
             long minutes = millis / 60000L;
153
             if (((minutes << (64 - 30)) >> (64 - 30)) == minutes) {
154
                 // Form 01 (30 bits effective precision)
155
                 out.writeInt(0x40000000 | (int)(minutes & 0x3fffffff));
156
                 return;
157
             }
158
         }
159
         
160
         if (millis % 1000L == 0) {
161
             // Try to write seconds.
162
             long seconds = millis / 1000L;
163
             if (((seconds << (64 - 38)) >> (64 - 38)) == seconds) {
164
                 // Form 10 (38 bits effective precision)
165
                 out.writeByte(0x80 | (int)((seconds >> 32) & 0x3f));
166
                 out.writeInt((int)(seconds & 0xffffffff));
167
                 return;
168
             }
169
         }
170
 
171
         // Write milliseconds either because the additional precision is
172
         // required or the minutes didn't fit in the field.
173
         
174
         // Form 11 (64 bits effective precision, but write as if 70 bits)
175
         out.writeByte(millis < 0 ? 0xff : 0xc0);
176
         out.writeLong(millis);
177
     }

    
Reads encoding generated by writeMillis. 
181
 
182
     static long readMillis(DataInput in) throws IOException {
183
         int v = in.readUnsignedByte();
184
         switch (v >> 6) {
185
         case 0: default:
186
             // Form 00 (6 bits effective precision)
187
             v = (v << (32 - 6)) >> (32 - 6);
188
             return v * (30 * 60000L);
189
 
190
         case 1:
191
             // Form 01 (30 bits effective precision)
192
             v = (v << (32 - 6)) >> (32 - 30);
193
             v |= (in.readUnsignedByte()) << 16;
194
             v |= (in.readUnsignedByte()) << 8;
195
             v |= (in.readUnsignedByte());
196
             return v * 60000L;
197
 
198
         case 2:
199
             // Form 10 (38 bits effective precision)
200
             long w = (((long)v) << (64 - 6)) >> (64 - 38);
201
             w |= (in.readUnsignedByte()) << 24;
202
             w |= (in.readUnsignedByte()) << 16;
203
             w |= (in.readUnsignedByte()) << 8;
204
             w |= (in.readUnsignedByte());
205
             return w * 1000L;
206
 
207
         case 3:
208
             // Form 11 (64 bits effective precision)
209
             return in.readLong();
210
         }
211
     }
212
 
213
     private static DateTimeZone buildFixedZone(String id, String nameKey,
214
                                                int wallOffset, int standardOffset) {
215
         if ("UTC".equals(id) && id.equals(nameKey) &&
216
             wallOffset == 0 && standardOffset == 0) {
217
             return .;
218
         }
219
         return new FixedDateTimeZone(id, nameKey, wallOffset, standardOffset);
220
     }
221
 
222
     // List of RuleSets.
223
     private final ArrayList<RuleSet> iRuleSets;
224
 
225
     public DateTimeZoneBuilder() {
226
          = new ArrayList<RuleSet>(10);
227
     }

    
Adds a cutover for added rules. The standard offset at the cutover defaults to 0. Call setStandardOffset afterwards to change it.

Parameters:
year the year of cutover
mode 'u' - cutover is measured against UTC, 'w' - against wall offset, 's' - against standard offset
monthOfYear the month from 1 (January) to 12 (December)
dayOfMonth if negative, set to ((last day of month) - ~dayOfMonth). For example, if -1, set to last day of month
dayOfWeek from 1 (Monday) to 7 (Sunday), if 0 then ignore
advanceDayOfWeek if dayOfMonth does not fall on dayOfWeek, advance to dayOfWeek when true, retreat when false.
millisOfDay additional precision for specifying time of day of cutover
243
 
244
     public DateTimeZoneBuilder addCutover(int year,
245
                                           char mode,
246
                                           int monthOfYear,
247
                                           int dayOfMonth,
248
                                           int dayOfWeek,
249
                                           boolean advanceDayOfWeek,
250
                                           int millisOfDay)
251
     {
252
         if (.size() > 0) {
253
             OfYear ofYear = new OfYear
254
                 (mode, monthOfYear, dayOfMonth, dayOfWeek, advanceDayOfWeek, millisOfDay);
255
             RuleSet lastRuleSet = .get(.size() - 1);
256
             lastRuleSet.setUpperLimit(year, ofYear);
257
         }
258
         .add(new RuleSet());
259
         return this;
260
     }

    
Sets the standard offset to use for newly added rules until the next cutover is added.

Parameters:
standardOffset the standard offset in millis
266
 
267
     public DateTimeZoneBuilder setStandardOffset(int standardOffset) {
268
         getLastRuleSet().setStandardOffset(standardOffset);
269
         return this;
270
     }

    
Set a fixed savings rule at the cutover. 
274
 
275
     public DateTimeZoneBuilder setFixedSavings(String nameKey, int saveMillis) {
276
         getLastRuleSet().setFixedSavings(nameKey, saveMillis);
277
         return this;
278
     }

    
Add a recurring daylight saving time rule.

Parameters:
nameKey the name key of new rule
saveMillis the milliseconds to add to standard offset
fromYear the first year that rule is in effect, MIN_VALUE indicates beginning of time
toYear the last year (inclusive) that rule is in effect, MAX_VALUE indicates end of time
mode 'u' - transitions are calculated against UTC, 'w' - transitions are calculated against wall offset, 's' - transitions are calculated against standard offset
monthOfYear the month from 1 (January) to 12 (December)
dayOfMonth if negative, set to ((last day of month) - ~dayOfMonth). For example, if -1, set to last day of month
dayOfWeek from 1 (Monday) to 7 (Sunday), if 0 then ignore
advanceDayOfWeek if dayOfMonth does not fall on dayOfWeek, advance to dayOfWeek when true, retreat when false.
millisOfDay additional precision for specifying time of day of transitions
299
 
300
     public DateTimeZoneBuilder addRecurringSavings(String nameKey, int saveMillis,
301
                                                    int fromYear, int toYear,
302
                                                    char mode,
303
                                                    int monthOfYear,
304
                                                    int dayOfMonth,
305
                                                    int dayOfWeek,
306
                                                    boolean advanceDayOfWeek,
307
                                                    int millisOfDay)
308
     {
309
         if (fromYear <= toYear) {
310
             OfYear ofYear = new OfYear
311
                 (mode, monthOfYear, dayOfMonth, dayOfWeek, advanceDayOfWeek, millisOfDay);
312
             Recurrence recurrence = new Recurrence(ofYear, nameKey, saveMillis);
313
             Rule rule = new Rule(recurrence, fromYear, toYear);
314
             getLastRuleSet().addRule(rule);
315
         }
316
         return this;
317
     }
318
 
319
     private RuleSet getLastRuleSet() {
320
         if (.size() == 0) {
321
             addCutover(., 'w', 1, 1, 0, false, 0);
322
         }
323
         return .get(.size() - 1);
324
     }
    
    
Processes all the rules and builds a DateTimeZone.

Parameters:
id time zone id to assign
outputID true if the zone id should be output
331
 
332
     public DateTimeZone toDateTimeZone(String id, boolean outputID) {
333
         if (id == null) {
334
             throw new IllegalArgumentException();
335
         }
336
 
337
         // Discover where all the transitions occur and store the results in
338
         // these lists.
339
         ArrayList<Transition> transitions = new ArrayList<Transition>();
340
 
341
         // Tail zone picks up remaining transitions in the form of an endless
342
         // DST cycle.
343
         DSTZone tailZone = null;
344
 
345
         long millis = .;
346
         int saveMillis = 0;
347
             
348
         int ruleSetCount = .size();
349
         for (int i=0; i<ruleSetCount; i++) {
350
             RuleSet rs = .get(i);
351
             Transition next = rs.firstTransition(millis);
352
             if (next == null) {
353
                 continue;
354
             }
355
             addTransition(transitions, next);
356
             millis = next.getMillis();
357
             saveMillis = next.getSaveMillis();
358
 
359
             // Copy it since we're going to destroy it.
360
             rs = new RuleSet(rs);
361
 
362
             while ((next = rs.nextTransition(millis, saveMillis)) != null) {
363
                 if (addTransition(transitions, next)) {
364
                     if (tailZone != null) {
365
                         // Got the extra transition before DSTZone.
366
                         break;
367
                     }
368
                 }
369
                 millis = next.getMillis();
370
                 saveMillis = next.getSaveMillis();
371
                 if (tailZone == null && i == ruleSetCount - 1) {
372
                     tailZone = rs.buildTailZone(id);
373
                     // If tailZone is not null, don't break out of main loop until
374
                     // at least one more transition is calculated. This ensures a
375
                     // correct 'seam' to the DSTZone.
376
                 }
377
             }
378
 
379
             millis = rs.getUpperLimit(saveMillis);
380
         }
381
 
382
         // Check if a simpler zone implementation can be returned.
383
         if (transitions.size() == 0) {
384
             if (tailZone != null) {
385
                 // This shouldn't happen, but handle just in case.
386
                 return tailZone;
387
             }
388
             return buildFixedZone(id, "UTC", 0, 0);
389
         }
390
         if (transitions.size() == 1 && tailZone == null) {
391
             Transition tr = transitions.get(0);
392
             return buildFixedZone(id, tr.getNameKey(),
393
                                   tr.getWallOffset(), tr.getStandardOffset());
394
         }
395
 
396
         PrecalculatedZone zone = PrecalculatedZone.create(id, outputID, transitions, tailZone);
397
         if (zone.isCachable()) {
398
             return CachedDateTimeZone.forZone(zone);
399
         }
400
         return zone;
401
     }
402
 
403
     private boolean addTransition(ArrayList<Transition> transitions, Transition tr) {
404
         int size = transitions.size();
405
         if (size == 0) {
406
             transitions.add(tr);
407
             return true;
408
         }
409
 
410
         Transition last = transitions.get(size - 1);
411
         if (!tr.isTransitionFrom(last)) {
412
             return false;
413
         }
414
 
415
         // If local time of new transition is same as last local time, just
416
         // replace last transition with new one.
417
         int offsetForLast = 0;
418
         if (size >= 2) {
419
             offsetForLast = transitions.get(size - 2).getWallOffset();
420
         }
421
         int offsetForNew = last.getWallOffset();
422
 
423
         long lastLocal = last.getMillis() + offsetForLast;
424
         long newLocal = tr.getMillis() + offsetForNew;
425
 
426
         if (newLocal != lastLocal) {
427
             transitions.add(tr);
428
             return true;
429
         }
430
 
431
         transitions.remove(size - 1);
432
         return addTransition(transitions, tr);
433
     }

    
Encodes a built DateTimeZone to the given stream. Call readFrom to decode the data into a DateTimeZone object.

Parameters:
out the output stream to receive the encoded DateTimeZone
Since:
1.5 (parameter added)
441
 
442
     public void writeTo(String zoneID, OutputStream out) throws IOException {
443
         if (out instanceof DataOutput) {
444
             writeTo(zoneID, (DataOutput)out);
445
         } else {
446
             writeTo(zoneID, (DataOutput)new DataOutputStream(out));
447
         }
448
     }

    
Encodes a built DateTimeZone to the given stream. Call readFrom to decode the data into a DateTimeZone object.

Parameters:
out the output stream to receive the encoded DateTimeZone
Since:
1.5 (parameter added)
456
 
457
     public void writeTo(String zoneID, DataOutput out) throws IOException {
458
         // pass false so zone id is not written out
459
         DateTimeZone zone = toDateTimeZone(zoneID, false);
460
 
461
         if (zone instanceof FixedDateTimeZone) {
462
             out.writeByte('F'); // 'F' for fixed
463
             out.writeUTF(zone.getNameKey(0));
464
             writeMillis(out, zone.getOffset(0));
465
             writeMillis(out, zone.getStandardOffset(0));
466
         } else {
467
             if (zone instanceof CachedDateTimeZone) {
468
                 out.writeByte('C'); // 'C' for cached, precalculated
469
                 zone = ((CachedDateTimeZone)zone).getUncachedZone();
470
             } else {
471
                 out.writeByte('P'); // 'P' for precalculated, uncached
472
             }
473
             ((PrecalculatedZone)zone).writeTo(out);
474
         }
475
     }

    
Supports setting fields of year and moving between transitions. 
479
 
480
     private static final class OfYear {
481
         static OfYear readFrom(DataInput in) throws IOException {
482
             return new OfYear((char)in.readUnsignedByte(),
483
                               (int)in.readUnsignedByte(),
484
                               (int)in.readByte(),
485
                               (int)in.readUnsignedByte(),
486
                               in.readBoolean(),
487
                               (int)readMillis(in));
488
         }
489
 
490
         // Is 'u', 'w', or 's'.
491
         final char iMode;
492
 
493
         final int iMonthOfYear;
494
         final int iDayOfMonth;
495
         final int iDayOfWeek;
496
         final boolean iAdvance;
497
         final int iMillisOfDay;
498
 
499
         OfYear(char mode,
500
                int monthOfYear,
501
                int dayOfMonth,
502
                int dayOfWeek, boolean advanceDayOfWeek,
503
                int millisOfDay)
504
         {
505
             if (mode != 'u' && mode != 'w' && mode != 's') {
506
                 throw new IllegalArgumentException("Unknown mode: " + mode);
507
             }
508
 
509
              = mode;
510
              = monthOfYear;
511
              = dayOfMonth;
512
              = dayOfWeek;
513
              = advanceDayOfWeek;
514
              = millisOfDay;
515
         }

        

Parameters:
standardOffset standard offset just before instant
519
 
520
         public long setInstant(int year, int standardOffset, int saveMillis) {
521
             int offset;
522
             if ( == 'w') {
523
                 offset = standardOffset + saveMillis;
524
             } else if ( == 's') {
525
                 offset = standardOffset;
526
             } else {
527
                 offset = 0;
528
             }
529
 
530
             Chronology chrono = ISOChronology.getInstanceUTC();
531
             long millis = chrono.year().set(0, year);
532
             millis = chrono.monthOfYear().set(millis, );
533
             millis = chrono.millisOfDay().set(millis, );
534
             millis = setDayOfMonth(chrono, millis);
535
 
536
             if ( != 0) {
537
                 millis = setDayOfWeek(chrono, millis);
538
             }
539
 
540
             // Convert from local time to UTC.
541
             return millis - offset;
542
         }

        

Parameters:
standardOffset standard offset just before next recurrence
546
 
547
         public long next(long instant, int standardOffset, int saveMillis) {
548
             int offset;
549
             if ( == 'w') {
550
                 offset = standardOffset + saveMillis;
551
             } else if ( == 's') {
552
                 offset = standardOffset;
553
             } else {
554
                 offset = 0;
555
             }
556
 
557
             // Convert from UTC to local time.
558
             instant += offset;
559
 
560
             Chronology chrono = ISOChronology.getInstanceUTC();
561
             long next = chrono.monthOfYear().set(instant, );
562
             // Be lenient with millisOfDay.
563
             next = chrono.millisOfDay().set(next, 0);
564
             next = chrono.millisOfDay().add(next, );
565
             next = setDayOfMonthNext(chrono, next);
566
 
567
             if ( == 0) {
568
                 if (next <= instant) {
569
                     next = chrono.year().add(next, 1);
570
                     next = setDayOfMonthNext(chrono, next);
571
                 }
572
             } else {
573
                 next = setDayOfWeek(chrono, next);
574
                 if (next <= instant) {
575
                     next = chrono.year().add(next, 1);
576
                     next = chrono.monthOfYear().set(next, );
577
                     next = setDayOfMonthNext(chrono, next);
578
                     next = setDayOfWeek(chrono, next);
579
                 }
580
             }
581
 
582
             // Convert from local time to UTC.
583
             return next - offset;
584
         }

        

Parameters:
standardOffset standard offset just before previous recurrence
588
 
589
         public long previous(long instant, int standardOffset, int saveMillis) {
590
             int offset;
591
             if ( == 'w') {
592
                 offset = standardOffset + saveMillis;
593
             } else if ( == 's') {
594
                 offset = standardOffset;
595
             } else {
596
                 offset = 0;
597
             }
598
 
599
             // Convert from UTC to local time.
600
             instant += offset;
601
 
602
             Chronology chrono = ISOChronology.getInstanceUTC();
603
             long prev = chrono.monthOfYear().set(instant, );
604
             // Be lenient with millisOfDay.
605
             prev = chrono.millisOfDay().set(prev, 0);
606
             prev = chrono.millisOfDay().add(prev, );
607
             prev = setDayOfMonthPrevious(chrono, prev);
608
 
609
             if ( == 0) {
610
                 if (prev >= instant) {
611
                     prev = chrono.year().add(prev, -1);
612
                     prev = setDayOfMonthPrevious(chrono, prev);
613
                 }
614
             } else {
615
                 prev = setDayOfWeek(chrono, prev);
616
                 if (prev >= instant) {
617
                     prev = chrono.year().add(prev, -1);
618
                     prev = chrono.monthOfYear().set(prev, );
619
                     prev = setDayOfMonthPrevious(chrono, prev);
620
                     prev = setDayOfWeek(chrono, prev);
621
                 }
622
             }
623
 
624
             // Convert from local time to UTC.
625
             return prev - offset;
626
         }
627
 
628
         public boolean equals(Object obj) {
629
             if (this == obj) {
630
                 return true;
631
             }
632
             if (obj instanceof OfYear) {
633
                 OfYear other = (OfYear)obj;
634
                 return
635
                      == other.iMode &&
636
                      == other.iMonthOfYear &&
637
                      == other.iDayOfMonth &&
638
                      == other.iDayOfWeek &&
639
                      == other.iAdvance &&
640
                      == other.iMillisOfDay;
641
             }
642
             return false;
643
         }
644
 
645
         /*
646
         public String toString() {
647
             return
648
                 "[OfYear]\n" + 
649
                 "Mode: " + iMode + '\n' +
650
                 "MonthOfYear: " + iMonthOfYear + '\n' +
651
                 "DayOfMonth: " + iDayOfMonth + '\n' +
652
                 "DayOfWeek: " + iDayOfWeek + '\n' +
653
                 "AdvanceDayOfWeek: " + iAdvance + '\n' +
654
                 "MillisOfDay: " + iMillisOfDay + '\n';
655
         }
656
         */
657
 
658
         public void writeTo(DataOutput out) throws IOException {
659
             out.writeByte();
660
             out.writeByte();
661
             out.writeByte();
662
             out.writeByte();
663
             out.writeBoolean();
664
             writeMillis(out, );
665
         }

        
If month-day is 02-29 and year isn't leap, advances to next leap year. 
669
 
670
         private long setDayOfMonthNext(Chronology chrono, long next) {
671
             try {
672
                 next = setDayOfMonth(chrono, next);
673
             } catch (IllegalArgumentException e) {
674
                 if ( == 2 &&  == 29) {
675
                     while (chrono.year().isLeap(next) == false) {
676
                         next = chrono.year().add(next, 1);
677
                     }
678
                     next = setDayOfMonth(chrono, next);
679
                 } else {
680
                     throw e;
681
                 }
682
             }
683
             return next;
684
         }

        
If month-day is 02-29 and year isn't leap, retreats to previous leap year. 
688
 
689
         private long setDayOfMonthPrevious(Chronology chrono, long prev) {
690
             try {
691
                 prev = setDayOfMonth(chrono, prev);
692
             } catch (IllegalArgumentException e) {
693
                 if ( == 2 &&  == 29) {
694
                     while (chrono.year().isLeap(prev) == false) {
695
                         prev = chrono.year().add(prev, -1);
696
                     }
697
                     prev = setDayOfMonth(chrono, prev);
698
                 } else {
699
                     throw e;
700
                 }
701
             }
702
             return prev;
703
         }
704
 
705
         private long setDayOfMonth(Chronology chrono, long instant) {
706
             if ( >= 0) {
707
                 instant = chrono.dayOfMonth().set(instant, );
708
             } else {
709
                 instant = chrono.dayOfMonth().set(instant, 1);
710
                 instant = chrono.monthOfYear().add(instant, 1);
711
                 instant = chrono.dayOfMonth().add(instant, );
712
             }
713
             return instant;
714
         }
715
 
716
         private long setDayOfWeek(Chronology chrono, long instant) {
717
             int dayOfWeek = chrono.dayOfWeek().get(instant);
718
             int daysToAdd =  - dayOfWeek;
719
             if (daysToAdd != 0) {
720
                 if () {
721
                     if (daysToAdd < 0) {
722
                         daysToAdd += 7;
723
                     }
724
                 } else {
725
                     if (daysToAdd > 0) {
726
                         daysToAdd -= 7;
727
                     }
728
                 }
729
                 instant = chrono.dayOfWeek().add(instant, daysToAdd);
730
             }
731
             return instant;
732
         }
733
     }

    
Extends OfYear with a nameKey and savings. 
737
 
738
     private static final class Recurrence {
739
         static Recurrence readFrom(DataInput in) throws IOException {
740
             return new Recurrence(OfYear.readFrom(in), in.readUTF(), (int)readMillis(in));
741
         }
742
 
743
         final OfYear iOfYear;
744
         final String iNameKey;
745
         final int iSaveMillis;
746
 
747
         Recurrence(OfYear ofYear, String nameKey, int saveMillis) {
748
              = ofYear;
749
              = nameKey;
750
              = saveMillis;
751
         }
752
 
753
         public OfYear getOfYear() {
754
             return ;
755
         }

        

Parameters:
standardOffset standard offset just before next recurrence
759
 
760
         public long next(long instant, int standardOffset, int saveMillis) {
761
             return .next(instant, standardOffset, saveMillis);
762
         }

        

Parameters:
standardOffset standard offset just before previous recurrence
766
 
767
         public long previous(long instant, int standardOffset, int saveMillis) {
768
             return .previous(instant, standardOffset, saveMillis);
769
         }
770
 
771
         public String getNameKey() {
772
             return ;
773
         }
774
 
775
         public int getSaveMillis() {
776
             return ;
777
         }
778
 
779
         public boolean equals(Object obj) {
780
             if (this == obj) {
781
                 return true;
782
             }
783
             if (obj instanceof Recurrence) {
784
                 Recurrence other = (Recurrence)obj;
785
                 return
786
                      == other.iSaveMillis &&
787
                     .equals(other.iNameKey) &&
788
                     .equals(other.iOfYear);
789
             }
790
             return false;
791
         }
792
 
793
         public void writeTo(DataOutput out) throws IOException {
794
             .writeTo(out);
795
             out.writeUTF();
796
             writeMillis(out, );
797
         }
798
 
799
         Recurrence rename(String nameKey) {
800
             return new Recurrence(, nameKey, );
801
         }
802
 
803
         Recurrence renameAppend(String appendNameKey) {
804
             return rename(( + appendNameKey).intern());
805
         }
806
     }

    
Extends Recurrence with inclusive year limits. 
810
 
811
     private static final class Rule {
812
         final Recurrence iRecurrence;
813
         final int iFromYear; // inclusive
814
         final int iToYear;   // inclusive
815
 
816
         Rule(Recurrence recurrence, int fromYear, int toYear) {
817
              = recurrence;
818
              = fromYear;
819
              = toYear;
820
         }
821
 
822
         @SuppressWarnings("unused")
823
         public int getFromYear() {
824
             return ;
825
         }
826
 
827
         public int getToYear() {
828
             return ;
829
         }
830
 
831
         @SuppressWarnings("unused")
832
         public OfYear getOfYear() {
833
             return .getOfYear();
834
         }
835
 
836
         public String getNameKey() {
837
             return .getNameKey();
838
         }
839
 
840
         public int getSaveMillis() {
841
             return .getSaveMillis();
842
         }
843
 
844
         public long next(final long instant, int standardOffset, int saveMillis) {
845
             Chronology chrono = ISOChronology.getInstanceUTC();
846
 
847
             final int wallOffset = standardOffset + saveMillis;
848
             long testInstant = instant;
849
 
850
             int year;
851
             if (instant == .) {
852
                 year = .;
853
             } else {
854
                 year = chrono.year().get(instant + wallOffset);
855
             }
856
 
857
             if (year < ) {
858
                 // First advance instant to start of from year.
859
                 testInstant = chrono.year().set(0, ) - wallOffset;
860
                 // Back off one millisecond to account for next recurrence
861
                 // being exactly at the beginning of the year.
862
                 testInstant -= 1;
863
             }
864
 
865
             long next = .next(testInstant, standardOffset, saveMillis);
866
 
867
             if (next > instant) {
868
                 year = chrono.year().get(next + wallOffset);
869
                 if (year > ) {
870
                     // Out of range, return original value.
871
                     next = instant;
872
                 }
873
             }
874
 
875
             return next;
876
         }
877
     }
878
 
879
     private static final class Transition {
880
         private final long iMillis;
881
         private final String iNameKey;
882
         private final int iWallOffset;
883
         private final int iStandardOffset;
884
 
885
         Transition(long millis, Transition tr) {
886
              = millis;
887
              = tr.iNameKey;
888
              = tr.iWallOffset;
889
              = tr.iStandardOffset;
890
         }
891
 
892
         Transition(long millis, Rule rule, int standardOffset) {
893
              = millis;
894
              = rule.getNameKey();
895
              = standardOffset + rule.getSaveMillis();
896
              = standardOffset;
897
         }
898
 
899
         Transition(long millis, String nameKey,
900
                    int wallOffset, int standardOffset) {
901
              = millis;
902
              = nameKey;
903
              = wallOffset;
904
              = standardOffset;
905
         }
906
 
907
         public long getMillis() {
908
             return ;
909
         }
910
 
911
         public String getNameKey() {
912
             return ;
913
         }
914
 
915
         public int getWallOffset() {
916
             return ;
917
         }
918
 
919
         public int getStandardOffset() {
920
             return ;
921
         }
922
 
923
         public int getSaveMillis() {
924
             return  - ;
925
         }

        
There must be a change in the millis, wall offsets or name keys. 
929
 
930
         public boolean isTransitionFrom(Transition other) {
931
             if (other == null) {
932
                 return true;
933
             }
934
             return  > other.iMillis &&
935
                 ( != other.iWallOffset ||
936
                  //iStandardOffset != other.iStandardOffset ||
937
                  !(.equals(other.iNameKey)));
938
         }
939
     }
940
 
941
     private static final class RuleSet {
942
         private static final int YEAR_LIMIT;
943
 
944
         static {
945
             // Don't pre-calculate more than 100 years into the future. Almost
946
             // all zones will stop pre-calculating far sooner anyhow. Either a
947
             // simple DST cycle is detected or the last rule is a fixed
948
             // offset. If a zone has a fixed offset set more than 100 years
949
             // into the future, then it won't be observed.
950
             long now = DateTimeUtils.currentTimeMillis();
951
              = ISOChronology.getInstanceUTC().year().get(now) + 100;
952
         }
953
 
954
         private int iStandardOffset;
955
         private ArrayList<Rule> iRules;
956
 
957
         // Optional.
958
         private String iInitialNameKey;
959
         private int iInitialSaveMillis;
960
 
961
         // Upper limit is exclusive.
962
         private int iUpperYear;
963
         private OfYear iUpperOfYear;
964
 
965
         RuleSet() {
966
              = new ArrayList<Rule>(10);
967
              = .;
968
         }

        
Copy constructor. 
972
 
973
         RuleSet(RuleSet rs) {
974
              = rs.iStandardOffset;
975
              = new ArrayList<Rule>(rs.iRules);
976
              = rs.iInitialNameKey;
977
              = rs.iInitialSaveMillis;
978
              = rs.iUpperYear;
979
              = rs.iUpperOfYear;
980
         }
981
 
982
         @SuppressWarnings("unused")
983
         public int getStandardOffset() {
984
             return ;
985
         }
986
 
987
         public void setStandardOffset(int standardOffset) {
988
              = standardOffset;
989
         }
990
 
991
         public void setFixedSavings(String nameKey, int saveMillis) {
992
              = nameKey;
993
              = saveMillis;
994
         }
995
 
996
         public void addRule(Rule rule) {
997
             if (!.contains(rule)) {
998
                 .add(rule);
999
             }
1000
        }
1002
        public void setUpperLimit(int year, OfYear ofYear) {
1003
             = year;
1004
             = ofYear;
1005
        }

        
Returns a transition at firstMillis with the first name key and offsets for this rule set. This method may return null.

Parameters:
firstMillis millis of first transition
1013
        public Transition firstTransition(final long firstMillis) {
1014
            if ( != null) {
1015
                // Initial zone info explicitly set, so don't search the rules.
1016
                return new Transition(firstMillis, ,
1017
                                       + , );
1018
            }
1020
            // Make a copy before we destroy the rules.
1021
            ArrayList<Rule> copy = new ArrayList<Rule>();
1023
            // Iterate through all the transitions until firstMillis is
1024
            // reached. Use the name key and savings for whatever rule reaches
1025
            // the limit.
1027
            long millis = .;
1028
            int saveMillis = 0;
1029
            Transition first = null;
1031
            Transition next;
1032
            while ((next = nextTransition(millis, saveMillis)) != null) {
1033
                millis = next.getMillis();
1035
                if (millis == firstMillis) {
1036
                    first = new Transition(firstMillis, next);
1037
                    break;
1038
                }
1040
                if (millis > firstMillis) {
1041
                    if (first == null) {
1042
                        // Find first rule without savings. This way a more
1043
                        // accurate nameKey is found even though no rule
1044
                        // extends to the RuleSet's lower limit.
1045
                        for (Rule rule : copy) {
1046
                            if (rule.getSaveMillis() == 0) {
1047
                                first = new Transition(firstMillis, rule, );
1048
                                break;
1049
                            }
1050
                        }
1051
                    }
1052
                    if (first == null) {
1053
                        // Found no rule without savings. Create a transition
1054
                        // with no savings anyhow, and use the best available
1055
                        // name key.
1056
                        first = new Transition(firstMillis, next.getNameKey(),
1057
                                               , );
1058
                    }
1059
                    break;
1060
                }
1061
                
1062
                // Set first to the best transition found so far, but next
1063
                // iteration may find something closer to lower limit.
1064
                first = new Transition(firstMillis, next);
1066
                saveMillis = next.getSaveMillis();
1067
            }
1069
             = copy;
1070
            return first;
1071
        }

        
Returns null if RuleSet is exhausted or upper limit reached. Calling this method will throw away rules as they each become exhausted. Copy the RuleSet before using it to compute transitions. Returned transition may be a duplicate from previous transition. Caller must call isTransitionFrom to filter out duplicates.

Parameters:
saveMillis savings before next transition
1084
        public Transition nextTransition(final long instant, final int saveMillis) {
1085
            Chronology chrono = ISOChronology.getInstanceUTC();
1087
            // Find next matching rule.
1088
            Rule nextRule = null;
1089
            long nextMillis = .;
1090
            
1091
            Iterator<Rule> it = .iterator();
1092
            while (it.hasNext()) {
1093
                Rule rule = it.next();
1094
                long next = rule.next(instant, , saveMillis);
1095
                if (next <= instant) {
1096
                    it.remove();
1097
                    continue;
1098
                }
1099
                // Even if next is same as previous next, choose the rule
1100
                // in order for more recently added rules to override.
1101
                if (next <= nextMillis) {
1102
                    // Found a better match.
1103
                    nextRule = rule;
1104
                    nextMillis = next;
1105
                }
1106
            }
1107
            
1108
            if (nextRule == null) {
1109
                return null;
1110
            }
1111
            
1112
            // Stop precalculating if year reaches some arbitrary limit.
1113
            if (chrono.year().get(nextMillis) >= ) {
1114
                return null;
1115
            }
1116
            
1117
            // Check if upper limit reached or passed.
1118
            if ( < .) {
1119
                long upperMillis =
1120
                    .setInstant(, , saveMillis);
1121
                if (nextMillis >= upperMillis) {
1122
                    // At or after upper limit.
1123
                    return null;
1124
                }
1125
            }
1126
            
1127
            return new Transition(nextMillis, nextRule, );
1128
        }

        

Parameters:
saveMillis savings before upper limit
1133
        public long getUpperLimit(int saveMillis) {
1134
            if ( == .) {
1135
                return .;
1136
            }
1137
            return .setInstant(, , saveMillis);
1138
        }

        
Returns null if none can be built. 
1143
        public DSTZone buildTailZone(String id) {
1144
            if (.size() == 2) {
1145
                Rule startRule = .get(0);
1146
                Rule endRule = .get(1);
1147
                if (startRule.getToYear() == . &&
1148
                    endRule.getToYear() == .) {
1150
                    // With exactly two infinitely recurring rules left, a
1151
                    // simple DSTZone can be formed.
1153
                    // The order of rules can come in any order, and it doesn't
1154
                    // really matter which rule was chosen the 'start' and
1155
                    // which is chosen the 'end'. DSTZone works properly either
1156
                    // way.
1157
                    return new DSTZone(id, ,
1158
                                       startRule.iRecurrence, endRule.iRecurrence);
1159
                }
1160
            }
1161
            return null;
1162
        }
1163
    }
1165
    private static final class DSTZone extends DateTimeZone {
1166
        private static final long serialVersionUID = 6941492635554961361L;
1168
        static DSTZone readFrom(DataInput in, String id) throws IOException {
1169
            return new DSTZone(id, (int)readMillis(in), 
1170
                               Recurrence.readFrom(in), Recurrence.readFrom(in));
1171
        }
1173
        final int iStandardOffset;
1174
        final Recurrence iStartRecurrence;
1175
        final Recurrence iEndRecurrence;
1177
        DSTZone(String id, int standardOffset,
1178
                Recurrence startRecurrence, Recurrence endRecurrence) {
1179
            super(id);
1180
             = standardOffset;
1181
             = startRecurrence;
1182
             = endRecurrence;
1183
        }
1185
        public String getNameKey(long instant) {
1186
            return findMatchingRecurrence(instant).getNameKey();
1187
        }
1189
        public int getOffset(long instant) {
1190
            return  + findMatchingRecurrence(instant).getSaveMillis();
1191
        }
1193
        public int getStandardOffset(long instant) {
1194
            return ;
1195
        }
1197
        public boolean isFixed() {
1198
            return false;
1199
        }
1201
        public long nextTransition(long instant) {
1202
            int standardOffset = ;
1203
            Recurrence startRecurrence = ;
1204
            Recurrence endRecurrence =