/// <summary>
/// Finds the offset info for a local date-time and transition.
/// </summary>
/// <param name="dt"> the date-time, not null </param>
/// <param name="trans"> the transition, not null </param>
/// <returns> the offset info, not null </returns>
private Object FindOffsetInfo(LocalDateTime dt, ZoneOffsetTransition trans)
{
LocalDateTime localTransition = trans.DateTimeBefore;
if (trans.Gap)
{
if (dt.IsBefore(localTransition))
{
return(trans.OffsetBefore);
}
if (dt.IsBefore(trans.DateTimeAfter))
{
return(trans);
}
else
{
return(trans.OffsetAfter);
}
}
else
{
if (dt.IsBefore(localTransition) == false)
{
return(trans.OffsetAfter);
}
if (dt.IsBefore(trans.DateTimeAfter))
{
return(trans.OffsetBefore);
}
else
{
return(trans);
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="standardTransitions"> the standard transitions, not null </param>
/// <param name="standardOffsets"> the standard offsets, not null </param>
/// <param name="savingsInstantTransitions"> the standard transitions, not null </param>
/// <param name="wallOffsets"> the wall offsets, not null </param>
/// <param name="lastRules"> the recurring last rules, size 15 or less, not null </param>
private ZoneRules(long[] standardTransitions, ZoneOffset[] standardOffsets, long[] savingsInstantTransitions, ZoneOffset[] wallOffsets, ZoneOffsetTransitionRule[] lastRules) : base()
{
this.StandardTransitions = standardTransitions;
this.StandardOffsets = standardOffsets;
this.SavingsInstantTransitions = savingsInstantTransitions;
this.WallOffsets = wallOffsets;
this.LastRules = lastRules;
if (savingsInstantTransitions.Length == 0)
{
this.SavingsLocalTransitions = EMPTY_LDT_ARRAY;
}
else
{
// convert savings transitions to locals
IList <LocalDateTime> localTransitionList = new List <LocalDateTime>();
for (int i = 0; i < savingsInstantTransitions.Length; i++)
{
ZoneOffset before = wallOffsets[i];
ZoneOffset after = wallOffsets[i + 1];
ZoneOffsetTransition trans = new ZoneOffsetTransition(savingsInstantTransitions[i], before, after);
if (trans.Gap)
{
localTransitionList.Add(trans.DateTimeBefore);
localTransitionList.Add(trans.DateTimeAfter);
}
else
{
localTransitionList.Add(trans.DateTimeAfter);
localTransitionList.Add(trans.DateTimeBefore);
}
}
this.SavingsLocalTransitions = localTransitionList.ToArray();
}
}
/// <summary>
/// Gets the offset applicable at the specified instant in these rules.
/// <para>
/// The mapping from an instant to an offset is simple, there is only
/// one valid offset for each instant.
/// This method returns that offset.
///
/// </para>
/// </summary>
/// <param name="instant"> the instant to find the offset for, not null, but null
/// may be ignored if the rules have a single offset for all instants </param>
/// <returns> the offset, not null </returns>
public ZoneOffset GetOffset(Instant instant)
{
if (SavingsInstantTransitions.Length == 0)
{
return(StandardOffsets[0]);
}
long epochSec = instant.EpochSecond;
// check if using last rules
if (LastRules.Length > 0 && epochSec > SavingsInstantTransitions[SavingsInstantTransitions.Length - 1])
{
int year = FindYear(epochSec, WallOffsets[WallOffsets.Length - 1]);
ZoneOffsetTransition[] transArray = FindTransitionArray(year);
ZoneOffsetTransition trans = null;
for (int i = 0; i < transArray.Length; i++)
{
trans = transArray[i];
if (epochSec < trans.ToEpochSecond())
{
return(trans.OffsetBefore);
}
}
return(trans.OffsetAfter);
}
// using historic rules
int index = Arrays.BinarySearch(SavingsInstantTransitions, epochSec);
if (index < 0)
{
// switch negative insert position to start of matched range
index = -index - 2;
}
return(WallOffsets[index + 1]);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private static Object readInternal(byte type, java.io.DataInput in) throws java.io.IOException, ClassNotFoundException
private static Object ReadInternal(sbyte type, DataInput @in)
{
switch (type)
{
case ZRULES:
return(ZoneRules.ReadExternal(@in));
case ZOT:
return(ZoneOffsetTransition.ReadExternal(@in));
case ZOTRULE:
return(ZoneOffsetTransitionRule.ReadExternal(@in));
default:
throw new StreamCorruptedException("Unknown serialized type");
}
}
/// <summary>
/// Finds the appropriate transition array for the given year.
/// </summary>
/// <param name="year"> the year, not null </param>
/// <returns> the transition array, not null </returns>
private ZoneOffsetTransition[] FindTransitionArray(int year)
{
Integer yearObj = year; // should use Year class, but this saves a class load
ZoneOffsetTransition[] transArray = LastRulesCache[yearObj];
if (transArray != null)
{
return(transArray);
}
ZoneOffsetTransitionRule[] ruleArray = LastRules;
transArray = new ZoneOffsetTransition[ruleArray.Length];
for (int i = 0; i < ruleArray.Length; i++)
{
transArray[i] = ruleArray[i].CreateTransition(year);
}
if (year < LAST_CACHED_YEAR)
{
LastRulesCache.PutIfAbsent(yearObj, transArray);
}
return(transArray);
}