android-34/com/android/icu/util/ExtendedTimeZone.java - platform/prebuilts/fullsdk/sources - Gitiles

 /*
  * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.icu.util;

 import android.icu.impl.Grego;
 import android.icu.util.AnnualTimeZoneRule;
 import android.icu.util.BasicTimeZone;
 import android.icu.util.DateTimeRule;
 import android.icu.util.InitialTimeZoneRule;
 import android.icu.util.TimeArrayTimeZoneRule;
 import android.icu.util.TimeZone;
 import android.icu.util.TimeZoneRule;
 import android.icu.util.TimeZoneTransition;

 import libcore.api.IntraCoreApi;

 import java.time.DayOfWeek;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.Month;
 import java.time.ZoneOffset;
 import java.time.zone.ZoneOffsetTransition;
 import java.time.zone.ZoneOffsetTransitionRule;
 import java.time.zone.ZoneRules;
 import java.time.zone.ZoneRulesException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.NavigableMap;
 import java.util.TreeMap;


 /**
  * Provide extra functionalities on top of {@link TimeZone} public APIs.
  *
  * @hide
  */
 @IntraCoreApi
 public class ExtendedTimeZone {

     private final TimeZone timezone;

     private ExtendedTimeZone(String id) {
         timezone = TimeZone.getTimeZone(id);
     }

     // The API which calls an implementation in android.icu does not use nullability annotation
     // because the upstream can't guarantee the stability. See http://b/140196694.
     /**
      * Returns an instance from the time zone ID. Note that the returned instance could be shared.
      *
      * @see TimeZone#getTimeZone(String) for the more information.
      * @hide
      */
     @IntraCoreApi
     public static ExtendedTimeZone getInstance(String id) {
         return new ExtendedTimeZone(id);
     }

     /**
      * Clears the default time zone in ICU4J. When next {@link TimeZone#getDefault()} is called,
      * ICU4J will re-initialize the default time zone from the value obtained from the libcore's
      * {@link java.util.TimeZone#getDefault()}.
      *
      * This API is useful for libcore's {@link java.util.TimeZone#setDefault(java.util.TimeZone)} to
      * break the cycle of synchronizing the default time zone between libcore and ICU4J.
      *
      * @hide
      */
     @IntraCoreApi
     public static void clearDefaultTimeZone() {
         TimeZone.setICUDefault(null);
     }

     /**
      * Returns the underlying {@link TimeZone} instance.
      *
      * @hide
      */
     @IntraCoreApi
     public TimeZone getTimeZone() {
         return timezone;
     }

     /**
      * Returns a {@link ZoneRules} instance for this time zone.
      *
      * @throws ZoneRulesException if the internal rules can't be parsed correctly, or it's not
      * implemented for the subtype of {@link TimeZone}.
      *
      * @implNote This implementations relies on {@link BasicTimeZone#getTimeZoneRules()} in the
      * following way:
      * Returned array starts with {@code InitialTimeZoneRule}, followed by {@code
      * TimeArrayTimeZoneRule}, and, if available, ends with {@code AnnualTimeZoneRule}.
      * @hide
      */
     @IntraCoreApi
     public ZoneRules createZoneRules() {
         if (!(timezone instanceof BasicTimeZone)) {
             throw zoneRulesException("timezone is "
                     + timezone.getClass().getCanonicalName()
                     + " which is not instance of BasicTimeZone");
         }

         BasicTimeZone basicTimeZone = (BasicTimeZone) timezone;

         TimeZoneRule[] timeZoneRules = basicTimeZone.getTimeZoneRules();

         if (timeZoneRules.length == 0) {
             throw zoneRulesException("Got 0 time zone rules");
         }

         ZoneOffset baseStandardOffset = null;
         ZoneOffset baseWallOffset = null;

         NavigableMap<Long, TimeArrayTimeZoneRule> rulesByStartTime = new TreeMap<>();
         boolean hasRecurringRules = false;

         for (TimeZoneRule timeZoneRule : timeZoneRules) {
             if (timeZoneRule instanceof InitialTimeZoneRule) {
                 InitialTimeZoneRule initialTimeZoneRule = (InitialTimeZoneRule) timeZoneRule;
                 baseStandardOffset = standardOffset(initialTimeZoneRule);
                 baseWallOffset = fullOffset(initialTimeZoneRule);
             } else if (timeZoneRule instanceof TimeArrayTimeZoneRule) {
                 TimeArrayTimeZoneRule timeArrayTimeZoneRule = (TimeArrayTimeZoneRule) timeZoneRule;

                 for (long startTime : timeArrayTimeZoneRule.getStartTimes()) {
                     rulesByStartTime.put(
                             utcStartTime(startTime, timeArrayTimeZoneRule), timeArrayTimeZoneRule);
                 }
             } else if (timeZoneRule instanceof AnnualTimeZoneRule) {
                 // Order of AnnualTimeZoneRule-s in BasicTimeZone#getTimeZoneRules is not
                 // specified, they will be fetched using different API.
                 hasRecurringRules = true;
             } else {
                 throw zoneRulesException(
                         "Unrecognized time zone rule " + timeZoneRule.getClass() + ".");
             }
         }

         // Keep in mind that transitionList is not superset of standardOffsetTransitionList.
         // transitionList keeps track of wall clock changes, but it might remain the same after
         // standard offset change if DST was changed too.
         List<ZoneOffsetTransition> standardOffsetTransitionList = new ArrayList<>();
         List<ZoneOffsetTransition> transitionList = new ArrayList<>();

         ZoneOffset lastStandardOffset = baseStandardOffset;
         ZoneOffset lastWallOffset = baseWallOffset;

         for (Map.Entry<Long, TimeArrayTimeZoneRule> entry : rulesByStartTime.entrySet()) {
             long startTime = entry.getKey();
             TimeArrayTimeZoneRule timeZoneRule = entry.getValue();

             ZoneOffset ruleStandardOffset = standardOffset(timeZoneRule);

             if (!ruleStandardOffset.equals(lastStandardOffset)) {
                 // ZoneRules needs changes in standard offsets only as an argument.
                 // ZoneOffsetTransition requires before and after offsets to be different, so wall
                 // clock offset can't be used as beforeOffset(it can be equal to afterOffset). Using
                 // previous standard offset seems to be the only reasonable choice left.
                 // As of 2021 transition and beforeOffset arguments are used to calculate UTC offset
                 // of the switch date and previous standard offset will do the trick.
                 ZoneOffsetTransition zoneOffsetTransition =
                         ZoneOffsetTransition.of(
                                 localDateTime(startTime, lastStandardOffset),
                                 lastStandardOffset,
                                 ruleStandardOffset);

                 standardOffsetTransitionList.add(zoneOffsetTransition);
                 lastStandardOffset = ruleStandardOffset;
             }

             ZoneOffset ruleWallOffset = fullOffset(timeZoneRule);

             // ZoneOffsetTransition tracks only changes in full offset - if raw and DST offsets
             // sum is not changed after a transition, such transition is not tracked by ZoneRules.
             // ICU does not squash such transitions.
             if (!lastWallOffset.equals(ruleWallOffset)) {
                 ZoneOffsetTransition zoneOffsetTransition =
                         ZoneOffsetTransition.of(
                                 localDateTime(startTime, lastWallOffset),
                                 lastWallOffset,
                                 ruleWallOffset);

                 transitionList.add(zoneOffsetTransition);
                 lastWallOffset = ruleWallOffset;
             }
         }

         List<ZoneOffsetTransitionRule> lastRules = new ArrayList<>();

         if (hasRecurringRules) {
             List<AnnualTimeZoneRule> annualTimeZoneRules = new ArrayList<>();

             // ZoneOffsetTransitionRule requires beforeOffset. As total offset in
             // TimeArrayTimeZoneRule may differ from offset of the last recurring rule
             // we apply all available recurring rule once. It is possible to build lastRules
             // in loop below, but doing it in separate loop simplifies code significantly.
             TimeZoneTransition firstTransitionToAnnualRule = basicTimeZone
                     .getNextTransition(rulesByStartTime.lastKey(), false /* inclusive */);
             AnnualTimeZoneRule firstAnnualRule =
                     (AnnualTimeZoneRule) firstTransitionToAnnualRule.getTo();
             AnnualTimeZoneRule currentTimeZoneRule = firstAnnualRule;
             long currentUnixEpochTime = firstTransitionToAnnualRule.getTime();

             do {
                 annualTimeZoneRules.add(currentTimeZoneRule);

                 if (annualTimeZoneRules.size() > 16) {
                     throw zoneRulesException("More than 16 annual transitions found.");
                 }

                 ZoneOffset ruleStandardOffset = standardOffset(currentTimeZoneRule);

                 if (!lastStandardOffset.equals(ruleStandardOffset)) {
                     standardOffsetTransitionList.add(
                             ZoneOffsetTransition.of(
                                     localDateTime(currentUnixEpochTime, lastStandardOffset),
                                     lastStandardOffset,
                                     ruleStandardOffset
                             ));
                     lastStandardOffset = ruleStandardOffset;
                 }

                 int currentYear =
                         Instant.ofEpochMilli(currentUnixEpochTime).atOffset(lastWallOffset).getYear();
                 ZoneOffsetTransition recurringRuleTransition =
                         createZoneOffsetTransitionRule(
                                 currentTimeZoneRule,
                                 lastStandardOffset,
                                 lastWallOffset)
                                 .createTransition(currentYear);

                 // After introduction of first annual rule wall offset may not change.
                 if (!lastWallOffset.equals(recurringRuleTransition.getOffsetAfter())) {
                     transitionList.add(ZoneOffsetTransition.of(
                             localDateTime(currentUnixEpochTime, lastWallOffset),
                             lastWallOffset,
                             recurringRuleTransition.getOffsetAfter()));
                     lastWallOffset = recurringRuleTransition.getOffsetAfter();
                 }

                 TimeZoneTransition nextTransition =
                         basicTimeZone.getNextTransition(currentUnixEpochTime, false /* inclusive */);
                 currentUnixEpochTime = nextTransition.getTime();
                 currentTimeZoneRule = (AnnualTimeZoneRule) nextTransition.getTo();

                 if (currentTimeZoneRule == null) {
                     throw zoneRulesException("No transitions after "
                             + currentUnixEpochTime + " for a timezone with recurring rules");
                 }
             } while (!currentTimeZoneRule.isEquivalentTo(firstAnnualRule));

             // All annual rules use the same standard offset and wall offset is always updated on
             // transition.
             // The initial value of lastWallOffset is the wall offset of the last recurring
             // AnnualTimeZoneRule.
             for (AnnualTimeZoneRule annualTimeZoneRule : annualTimeZoneRules) {
                 ZoneOffsetTransitionRule zoneOffsetTransitionRule =
                         createZoneOffsetTransitionRule(
                                 annualTimeZoneRule, lastStandardOffset, lastWallOffset);

                 lastWallOffset = zoneOffsetTransitionRule.getOffsetAfter();

                 lastRules.add(zoneOffsetTransitionRule);
             }

             // ZoneRules does not specify it, but internally it expects lastRules to be sorted
             // (see ZoneRules#getOffset) in the order they will happen within a year. For example,
             // if rule A starts in October 2021, and rule B starts in March 2022, expected order
             // is [B, A].
             // We assume that for any year that order is fixed, even though it is possible
             // to build set of rules where order depends on a given year.
             // annualTimeZoneRules stores rules in the order they happened, so we just need to find
             // a break in startYear.
             int firstRuleIndex = 0;
             while (firstRuleIndex < annualTimeZoneRules.size()
                     && firstAnnualRule.getStartYear()
                             == annualTimeZoneRules.get(firstRuleIndex).getStartYear()) {
                 ++firstRuleIndex;
             }

             Collections.rotate(lastRules, -firstRuleIndex);
         }

         return ZoneRules.of(
                 baseStandardOffset,
                 baseWallOffset,
                 standardOffsetTransitionList,
                 transitionList,
                 lastRules);
     }


     /**
      * Converts {@link AnnualTimeZoneRule} to {@link ZoneOffsetTransitionRule}. Switch date may be
      * represented relative to UTC, wall clock, or standard offset. For the latter 2 cases
      * {@code lastWallOffset} and {@code lastStandardOffset} are used.
      *
      * @param annualTimeZoneRule  rule to be converted
      * @param lastStandardOffset  standard offset of a rule which preceded {@code
      *     annualTimeZoneRule}
      * @param lastWallOffset  wall offset of a rule which preceded {@code annualTimeZoneRule}
      */
     private ZoneOffsetTransitionRule createZoneOffsetTransitionRule(
             AnnualTimeZoneRule annualTimeZoneRule,
             ZoneOffset lastStandardOffset,
             ZoneOffset lastWallOffset) {
         DateTimeRule dateTimeRule = annualTimeZoneRule.getRule();
         Month month = Month.of(dateTimeRule.getRuleMonth() + 1);
         final DayOfWeek dayOfWeek;
         final int dayOfMonthIndicator;
         switch (dateTimeRule.getDateRuleType()) {
             case DateTimeRule.DOM:
                 dayOfMonthIndicator = dateTimeRule.getRuleDayOfMonth();
                 dayOfWeek = null;
                 break;
             case DateTimeRule.DOW:
                 int weekInMonth = dateTimeRule.getRuleWeekInMonth();
                 if (weekInMonth > 0) {
                     dayOfMonthIndicator = (weekInMonth - 1) * 7  + 1;
                 } else if (weekInMonth < 0) {
                     dayOfMonthIndicator = (weekInMonth + 1) * 7 - 1;
                 } else {
                     throw zoneRulesException("Invalid DateTimeRule in "
                             + annualTimeZoneRule +
                             ". Non-zero weekInMonth expected in " + dateTimeRule);
                 }
                 dayOfWeek = dayOfWeek(dateTimeRule);
                 break;
             case DateTimeRule.DOW_GEQ_DOM:
                 dayOfMonthIndicator = dateTimeRule.getRuleDayOfMonth();
                 dayOfWeek = dayOfWeek(dateTimeRule);
                 break;
             case DateTimeRule.DOW_LEQ_DOM:
                 // java.time.ZoneRules uses negative numbers to indicate that switch date should
                 // come before certain date. Using leap year so that lastSun like rule will
                 // always work correctly.
                 dayOfMonthIndicator =
                         dateTimeRule.getRuleDayOfMonth() - month.maxLength() - 1;
                 dayOfWeek = dayOfWeek(dateTimeRule);
                 break;
             default:
                 throw zoneRulesException("Unexpected dateTimeRule.dateRuleType="
                         + dateTimeRule.getTimeRuleType() + " in " + annualTimeZoneRule);
         }

         final boolean timeEndOfDay;
         final LocalTime switchDateTime;
         if (dateTimeRule.getRuleMillisInDay() == Grego.MILLIS_PER_DAY) {
             timeEndOfDay = true;
             switchDateTime = LocalTime.MIDNIGHT;
         } else {
             timeEndOfDay = false;
             switchDateTime = LocalTime.ofNanoOfDay(dateTimeRule.getRuleMillisInDay() * 1_000_000L);
         }

         ZoneOffsetTransitionRule.TimeDefinition timeDefinition = timeDefinition(annualTimeZoneRule);

         // JavaDoc for standardOffset tells that it should be "offset in force at the cutover".
         // It's not clear what offset is in effect at the cutover moment, but zic format assumes
         // that only DST is changed in annual rules and standard offset is handled differently.
         return ZoneOffsetTransitionRule.of(month,
                 dayOfMonthIndicator,
                 dayOfWeek,
                 switchDateTime,
                 timeEndOfDay,
                 timeDefinition,
                 lastStandardOffset,
                 lastWallOffset,
                 fullOffset(annualTimeZoneRule));
     }

     private ZoneOffsetTransitionRule.TimeDefinition timeDefinition(
             AnnualTimeZoneRule annualTimeZoneRule) {
         DateTimeRule dateTimeRule = annualTimeZoneRule.getRule();
         switch (dateTimeRule.getTimeRuleType()) {
             case DateTimeRule.STANDARD_TIME:
                 return ZoneOffsetTransitionRule.TimeDefinition.STANDARD;
             case DateTimeRule.UTC_TIME:
                 return ZoneOffsetTransitionRule.TimeDefinition.UTC;
             case DateTimeRule.WALL_TIME:
                 return ZoneOffsetTransitionRule.TimeDefinition.WALL;
             default:
                 throw zoneRulesException(
                         "Unexpected dateTimeRule.timeRuleType=" + dateTimeRule.getTimeRuleType()
                                 + " in AnnualTimeZoneRule: " + annualTimeZoneRule);
         }
     }

     private long utcStartTime(long startTime, TimeArrayTimeZoneRule timeZoneRule) {
         switch (timeZoneRule.getTimeType()) {
             case DateTimeRule.UTC_TIME:
                 return startTime;
             case DateTimeRule.STANDARD_TIME:
                 return startTime - timeZoneRule.getRawOffset();
             case DateTimeRule.WALL_TIME:
                 return startTime - timeZoneRule.getRawOffset() - timeZoneRule.getDSTSavings();
             default:
                 throw zoneRulesException("Unexpected timeType in " + timeZoneRule);
         }
     }

     private ZoneRulesException zoneRulesException(String message) {
         return new ZoneRulesException("Failed to build ZoneRules for " + timezone.getID() +
                 ". " + message);
     }

     private static LocalDateTime localDateTime(long epochMillis, ZoneOffset zoneOffset) {
         return Instant.ofEpochMilli(epochMillis)
                 .atOffset(zoneOffset)
                 .toLocalDateTime();
     }

     private static DayOfWeek dayOfWeek(DateTimeRule dateTimeRule) {
         return DayOfWeek.SUNDAY.plus(dateTimeRule.getRuleDayOfWeek() - 1);
     }

     private static ZoneOffset standardOffset(TimeZoneRule timeZoneRule) {
         return toOffset(timeZoneRule.getRawOffset());
     }

     private static ZoneOffset fullOffset(TimeZoneRule timeZoneRule) {
         return toOffset(timeZoneRule.getRawOffset() + timeZoneRule.getDSTSavings());
     }

     private static ZoneOffset toOffset(int rawOffset) {
         return ZoneOffset.ofTotalSeconds(rawOffset / 1_000);
     }
 }
	/*
	* Copyright (C) 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.icu.util;

	import android.icu.impl.Grego;
	import android.icu.util.AnnualTimeZoneRule;
	import android.icu.util.BasicTimeZone;
	import android.icu.util.DateTimeRule;
	import android.icu.util.InitialTimeZoneRule;
	import android.icu.util.TimeArrayTimeZoneRule;
	import android.icu.util.TimeZone;
	import android.icu.util.TimeZoneRule;
	import android.icu.util.TimeZoneTransition;

	import libcore.api.IntraCoreApi;

	import java.time.DayOfWeek;
	import java.time.Instant;
	import java.time.LocalDateTime;
	import java.time.LocalTime;
	import java.time.Month;
	import java.time.ZoneOffset;
	import java.time.zone.ZoneOffsetTransition;
	import java.time.zone.ZoneOffsetTransitionRule;
	import java.time.zone.ZoneRules;
	import java.time.zone.ZoneRulesException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.Map;
	import java.util.NavigableMap;
	import java.util.TreeMap;


	/**
	* Provide extra functionalities on top of {@link TimeZone} public APIs.
	*
	* @hide
	*/
	@IntraCoreApi
	public class ExtendedTimeZone {

	private final TimeZone timezone;

	private ExtendedTimeZone(String id) {
	timezone = TimeZone.getTimeZone(id);
	}

	// The API which calls an implementation in android.icu does not use nullability annotation
	// because the upstream can't guarantee the stability. See http://b/140196694.
	/**
	* Returns an instance from the time zone ID. Note that the returned instance could be shared.
	*
	* @see TimeZone#getTimeZone(String) for the more information.
	* @hide
	*/
	@IntraCoreApi
	public static ExtendedTimeZone getInstance(String id) {
	return new ExtendedTimeZone(id);
	}

	/**
	* Clears the default time zone in ICU4J. When next {@link TimeZone#getDefault()} is called,
	* ICU4J will re-initialize the default time zone from the value obtained from the libcore's
	* {@link java.util.TimeZone#getDefault()}.
	*
	* This API is useful for libcore's {@link java.util.TimeZone#setDefault(java.util.TimeZone)} to
	* break the cycle of synchronizing the default time zone between libcore and ICU4J.
	*
	* @hide
	*/
	@IntraCoreApi
	public static void clearDefaultTimeZone() {
	TimeZone.setICUDefault(null);
	}

	/**
	* Returns the underlying {@link TimeZone} instance.
	*
	* @hide
	*/
	@IntraCoreApi
	public TimeZone getTimeZone() {
	return timezone;
	}

	/**
	* Returns a {@link ZoneRules} instance for this time zone.
	*
	* @throws ZoneRulesException if the internal rules can't be parsed correctly, or it's not
	* implemented for the subtype of {@link TimeZone}.
	*
	* @implNote This implementations relies on {@link BasicTimeZone#getTimeZoneRules()} in the
	* following way:
	* Returned array starts with {@code InitialTimeZoneRule}, followed by {@code
	* TimeArrayTimeZoneRule}, and, if available, ends with {@code AnnualTimeZoneRule}.
	* @hide
	*/
	@IntraCoreApi
	public ZoneRules createZoneRules() {
	if (!(timezone instanceof BasicTimeZone)) {
	throw zoneRulesException("timezone is "
	+ timezone.getClass().getCanonicalName()
	+ " which is not instance of BasicTimeZone");
	}

	BasicTimeZone basicTimeZone = (BasicTimeZone) timezone;

	TimeZoneRule[] timeZoneRules = basicTimeZone.getTimeZoneRules();

	if (timeZoneRules.length == 0) {
	throw zoneRulesException("Got 0 time zone rules");
	}

	ZoneOffset baseStandardOffset = null;
	ZoneOffset baseWallOffset = null;

	NavigableMap<Long, TimeArrayTimeZoneRule> rulesByStartTime = new TreeMap<>();
	boolean hasRecurringRules = false;

	for (TimeZoneRule timeZoneRule : timeZoneRules) {
	if (timeZoneRule instanceof InitialTimeZoneRule) {
	InitialTimeZoneRule initialTimeZoneRule = (InitialTimeZoneRule) timeZoneRule;
	baseStandardOffset = standardOffset(initialTimeZoneRule);
	baseWallOffset = fullOffset(initialTimeZoneRule);
	} else if (timeZoneRule instanceof TimeArrayTimeZoneRule) {
	TimeArrayTimeZoneRule timeArrayTimeZoneRule = (TimeArrayTimeZoneRule) timeZoneRule;

	for (long startTime : timeArrayTimeZoneRule.getStartTimes()) {
	rulesByStartTime.put(
	utcStartTime(startTime, timeArrayTimeZoneRule), timeArrayTimeZoneRule);
	}
	} else if (timeZoneRule instanceof AnnualTimeZoneRule) {
	// Order of AnnualTimeZoneRule-s in BasicTimeZone#getTimeZoneRules is not
	// specified, they will be fetched using different API.
	hasRecurringRules = true;
	} else {
	throw zoneRulesException(
	"Unrecognized time zone rule " + timeZoneRule.getClass() + ".");
	}
	}

	// Keep in mind that transitionList is not superset of standardOffsetTransitionList.
	// transitionList keeps track of wall clock changes, but it might remain the same after
	// standard offset change if DST was changed too.
	List<ZoneOffsetTransition> standardOffsetTransitionList = new ArrayList<>();
	List<ZoneOffsetTransition> transitionList = new ArrayList<>();

	ZoneOffset lastStandardOffset = baseStandardOffset;
	ZoneOffset lastWallOffset = baseWallOffset;

	for (Map.Entry<Long, TimeArrayTimeZoneRule> entry : rulesByStartTime.entrySet()) {
	long startTime = entry.getKey();
	TimeArrayTimeZoneRule timeZoneRule = entry.getValue();

	ZoneOffset ruleStandardOffset = standardOffset(timeZoneRule);

	if (!ruleStandardOffset.equals(lastStandardOffset)) {
	// ZoneRules needs changes in standard offsets only as an argument.
	// ZoneOffsetTransition requires before and after offsets to be different, so wall
	// clock offset can't be used as beforeOffset(it can be equal to afterOffset). Using
	// previous standard offset seems to be the only reasonable choice left.
	// As of 2021 transition and beforeOffset arguments are used to calculate UTC offset
	// of the switch date and previous standard offset will do the trick.
	ZoneOffsetTransition zoneOffsetTransition =
	ZoneOffsetTransition.of(
	localDateTime(startTime, lastStandardOffset),
	lastStandardOffset,
	ruleStandardOffset);

	standardOffsetTransitionList.add(zoneOffsetTransition);
	lastStandardOffset = ruleStandardOffset;
	}

	ZoneOffset ruleWallOffset = fullOffset(timeZoneRule);

	// ZoneOffsetTransition tracks only changes in full offset - if raw and DST offsets
	// sum is not changed after a transition, such transition is not tracked by ZoneRules.
	// ICU does not squash such transitions.
	if (!lastWallOffset.equals(ruleWallOffset)) {
	ZoneOffsetTransition zoneOffsetTransition =
	ZoneOffsetTransition.of(
	localDateTime(startTime, lastWallOffset),
	lastWallOffset,
	ruleWallOffset);

	transitionList.add(zoneOffsetTransition);
	lastWallOffset = ruleWallOffset;
	}
	}

	List<ZoneOffsetTransitionRule> lastRules = new ArrayList<>();

	if (hasRecurringRules) {
	List<AnnualTimeZoneRule> annualTimeZoneRules = new ArrayList<>();

	// ZoneOffsetTransitionRule requires beforeOffset. As total offset in
	// TimeArrayTimeZoneRule may differ from offset of the last recurring rule
	// we apply all available recurring rule once. It is possible to build lastRules
	// in loop below, but doing it in separate loop simplifies code significantly.
	TimeZoneTransition firstTransitionToAnnualRule = basicTimeZone
	.getNextTransition(rulesByStartTime.lastKey(), false /* inclusive */);
	AnnualTimeZoneRule firstAnnualRule =
	(AnnualTimeZoneRule) firstTransitionToAnnualRule.getTo();
	AnnualTimeZoneRule currentTimeZoneRule = firstAnnualRule;
	long currentUnixEpochTime = firstTransitionToAnnualRule.getTime();

	do {
	annualTimeZoneRules.add(currentTimeZoneRule);

	if (annualTimeZoneRules.size() > 16) {
	throw zoneRulesException("More than 16 annual transitions found.");
	}

	ZoneOffset ruleStandardOffset = standardOffset(currentTimeZoneRule);

	if (!lastStandardOffset.equals(ruleStandardOffset)) {
	standardOffsetTransitionList.add(
	ZoneOffsetTransition.of(
	localDateTime(currentUnixEpochTime, lastStandardOffset),
	lastStandardOffset,
	ruleStandardOffset
	));
	lastStandardOffset = ruleStandardOffset;
	}

	int currentYear =
	Instant.ofEpochMilli(currentUnixEpochTime).atOffset(lastWallOffset).getYear();
	ZoneOffsetTransition recurringRuleTransition =
	createZoneOffsetTransitionRule(
	currentTimeZoneRule,
	lastStandardOffset,
	lastWallOffset)
	.createTransition(currentYear);

	// After introduction of first annual rule wall offset may not change.
	if (!lastWallOffset.equals(recurringRuleTransition.getOffsetAfter())) {
	transitionList.add(ZoneOffsetTransition.of(
	localDateTime(currentUnixEpochTime, lastWallOffset),
	lastWallOffset,
	recurringRuleTransition.getOffsetAfter()));
	lastWallOffset = recurringRuleTransition.getOffsetAfter();
	}

	TimeZoneTransition nextTransition =
	basicTimeZone.getNextTransition(currentUnixEpochTime, false /* inclusive */);
	currentUnixEpochTime = nextTransition.getTime();
	currentTimeZoneRule = (AnnualTimeZoneRule) nextTransition.getTo();

	if (currentTimeZoneRule == null) {
	throw zoneRulesException("No transitions after "
	+ currentUnixEpochTime + " for a timezone with recurring rules");
	}
	} while (!currentTimeZoneRule.isEquivalentTo(firstAnnualRule));

	// All annual rules use the same standard offset and wall offset is always updated on
	// transition.
	// The initial value of lastWallOffset is the wall offset of the last recurring
	// AnnualTimeZoneRule.
	for (AnnualTimeZoneRule annualTimeZoneRule : annualTimeZoneRules) {
	ZoneOffsetTransitionRule zoneOffsetTransitionRule =
	createZoneOffsetTransitionRule(
	annualTimeZoneRule, lastStandardOffset, lastWallOffset);

	lastWallOffset = zoneOffsetTransitionRule.getOffsetAfter();

	lastRules.add(zoneOffsetTransitionRule);
	}

	// ZoneRules does not specify it, but internally it expects lastRules to be sorted
	// (see ZoneRules#getOffset) in the order they will happen within a year. For example,
	// if rule A starts in October 2021, and rule B starts in March 2022, expected order
	// is [B, A].
	// We assume that for any year that order is fixed, even though it is possible
	// to build set of rules where order depends on a given year.
	// annualTimeZoneRules stores rules in the order they happened, so we just need to find
	// a break in startYear.
	int firstRuleIndex = 0;
	while (firstRuleIndex < annualTimeZoneRules.size()
	&& firstAnnualRule.getStartYear()
	== annualTimeZoneRules.get(firstRuleIndex).getStartYear()) {
	++firstRuleIndex;
	}

	Collections.rotate(lastRules, -firstRuleIndex);
	}

	return ZoneRules.of(
	baseStandardOffset,
	baseWallOffset,
	standardOffsetTransitionList,
	transitionList,
	lastRules);
	}


	/**
	* Converts {@link AnnualTimeZoneRule} to {@link ZoneOffsetTransitionRule}. Switch date may be
	* represented relative to UTC, wall clock, or standard offset. For the latter 2 cases
	* {@code lastWallOffset} and {@code lastStandardOffset} are used.
	*
	* @param annualTimeZoneRule rule to be converted
	* @param lastStandardOffset standard offset of a rule which preceded {@code
	* annualTimeZoneRule}
	* @param lastWallOffset wall offset of a rule which preceded {@code annualTimeZoneRule}
	*/
	private ZoneOffsetTransitionRule createZoneOffsetTransitionRule(
	AnnualTimeZoneRule annualTimeZoneRule,
	ZoneOffset lastStandardOffset,
	ZoneOffset lastWallOffset) {
	DateTimeRule dateTimeRule = annualTimeZoneRule.getRule();
	Month month = Month.of(dateTimeRule.getRuleMonth() + 1);
	final DayOfWeek dayOfWeek;
	final int dayOfMonthIndicator;
	switch (dateTimeRule.getDateRuleType()) {
	case DateTimeRule.DOM:
	dayOfMonthIndicator = dateTimeRule.getRuleDayOfMonth();
	dayOfWeek = null;
	break;
	case DateTimeRule.DOW:
	int weekInMonth = dateTimeRule.getRuleWeekInMonth();
	if (weekInMonth > 0) {
	dayOfMonthIndicator = (weekInMonth - 1) * 7 + 1;
	} else if (weekInMonth < 0) {
	dayOfMonthIndicator = (weekInMonth + 1) * 7 - 1;
	} else {
	throw zoneRulesException("Invalid DateTimeRule in "
	+ annualTimeZoneRule +
	". Non-zero weekInMonth expected in " + dateTimeRule);
	}
	dayOfWeek = dayOfWeek(dateTimeRule);
	break;
	case DateTimeRule.DOW_GEQ_DOM:
	dayOfMonthIndicator = dateTimeRule.getRuleDayOfMonth();
	dayOfWeek = dayOfWeek(dateTimeRule);
	break;
	case DateTimeRule.DOW_LEQ_DOM:
	// java.time.ZoneRules uses negative numbers to indicate that switch date should
	// come before certain date. Using leap year so that lastSun like rule will
	// always work correctly.
	dayOfMonthIndicator =
	dateTimeRule.getRuleDayOfMonth() - month.maxLength() - 1;
	dayOfWeek = dayOfWeek(dateTimeRule);
	break;
	default:
	throw zoneRulesException("Unexpected dateTimeRule.dateRuleType="
	+ dateTimeRule.getTimeRuleType() + " in " + annualTimeZoneRule);
	}

	final boolean timeEndOfDay;
	final LocalTime switchDateTime;
	if (dateTimeRule.getRuleMillisInDay() == Grego.MILLIS_PER_DAY) {
	timeEndOfDay = true;
	switchDateTime = LocalTime.MIDNIGHT;
	} else {
	timeEndOfDay = false;
	switchDateTime = LocalTime.ofNanoOfDay(dateTimeRule.getRuleMillisInDay() * 1_000_000L);
	}

	ZoneOffsetTransitionRule.TimeDefinition timeDefinition = timeDefinition(annualTimeZoneRule);

	// JavaDoc for standardOffset tells that it should be "offset in force at the cutover".
	// It's not clear what offset is in effect at the cutover moment, but zic format assumes
	// that only DST is changed in annual rules and standard offset is handled differently.
	return ZoneOffsetTransitionRule.of(month,
	dayOfMonthIndicator,
	dayOfWeek,
	switchDateTime,
	timeEndOfDay,
	timeDefinition,
	lastStandardOffset,
	lastWallOffset,
	fullOffset(annualTimeZoneRule));
	}

	private ZoneOffsetTransitionRule.TimeDefinition timeDefinition(
	AnnualTimeZoneRule annualTimeZoneRule) {
	DateTimeRule dateTimeRule = annualTimeZoneRule.getRule();
	switch (dateTimeRule.getTimeRuleType()) {
	case DateTimeRule.STANDARD_TIME:
	return ZoneOffsetTransitionRule.TimeDefinition.STANDARD;
	case DateTimeRule.UTC_TIME:
	return ZoneOffsetTransitionRule.TimeDefinition.UTC;
	case DateTimeRule.WALL_TIME:
	return ZoneOffsetTransitionRule.TimeDefinition.WALL;
	default:
	throw zoneRulesException(
	"Unexpected dateTimeRule.timeRuleType=" + dateTimeRule.getTimeRuleType()
	+ " in AnnualTimeZoneRule: " + annualTimeZoneRule);
	}
	}

	private long utcStartTime(long startTime, TimeArrayTimeZoneRule timeZoneRule) {
	switch (timeZoneRule.getTimeType()) {
	case DateTimeRule.UTC_TIME:
	return startTime;
	case DateTimeRule.STANDARD_TIME:
	return startTime - timeZoneRule.getRawOffset();
	case DateTimeRule.WALL_TIME:
	return startTime - timeZoneRule.getRawOffset() - timeZoneRule.getDSTSavings();
	default:
	throw zoneRulesException("Unexpected timeType in " + timeZoneRule);
	}
	}

	private ZoneRulesException zoneRulesException(String message) {
	return new ZoneRulesException("Failed to build ZoneRules for " + timezone.getID() +
	". " + message);
	}

	private static LocalDateTime localDateTime(long epochMillis, ZoneOffset zoneOffset) {
	return Instant.ofEpochMilli(epochMillis)
	.atOffset(zoneOffset)
	.toLocalDateTime();
	}

	private static DayOfWeek dayOfWeek(DateTimeRule dateTimeRule) {
	return DayOfWeek.SUNDAY.plus(dateTimeRule.getRuleDayOfWeek() - 1);
	}

	private static ZoneOffset standardOffset(TimeZoneRule timeZoneRule) {
	return toOffset(timeZoneRule.getRawOffset());
	}

	private static ZoneOffset fullOffset(TimeZoneRule timeZoneRule) {
	return toOffset(timeZoneRule.getRawOffset() + timeZoneRule.getDSTSavings());
	}

	private static ZoneOffset toOffset(int rawOffset) {
	return ZoneOffset.ofTotalSeconds(rawOffset / 1_000);
	}
	}