//-----------------------------------------------------------------------
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Override @SuppressWarnings("unchecked") public D plus(long amountToAdd, java.time.temporal.TemporalUnit unit)
public virtual D Plus(long amountToAdd, TemporalUnit unit)
{
if (unit is ChronoUnit)
{
ChronoUnit f = (ChronoUnit)unit;
switch (f)
{
case DAYS:
return(PlusDays(amountToAdd));
case WEEKS:
return(PlusDays(Math.MultiplyExact(amountToAdd, 7)));
case MONTHS:
return(PlusMonths(amountToAdd));
case YEARS:
return(PlusYears(amountToAdd));
case DECADES:
return(PlusYears(Math.MultiplyExact(amountToAdd, 10)));
case CENTURIES:
return(PlusYears(Math.MultiplyExact(amountToAdd, 100)));
case MILLENNIA:
return(PlusYears(Math.MultiplyExact(amountToAdd, 1000)));
case ERAS:
return(With(ERA, Math.AddExact(GetLong(ERA), amountToAdd)));
}
throw new UnsupportedTemporalTypeException("Unsupported unit: " + unit);
}
return((D)ChronoLocalDate.this.plus(amountToAdd, unit));
}
private void ResolveTime(long hod, long moh, long som, long nos)
{
if (ResolverStyle == ResolverStyle.LENIENT)
{
long totalNanos = Math.MultiplyExact(hod, 3600_000_000_000L);
totalNanos = Math.AddExact(totalNanos, Math.MultiplyExact(moh, 60_000_000_000L));
totalNanos = Math.AddExact(totalNanos, Math.MultiplyExact(som, 1_000_000_000L));
totalNanos = Math.AddExact(totalNanos, nos);
int excessDays = (int)Math.FloorDiv(totalNanos, 86400_000_000_000L); // safe int cast
long nod = Math.FloorMod(totalNanos, 86400_000_000_000L);
UpdateCheckConflict(LocalTime.OfNanoOfDay(nod), Period.OfDays(excessDays));
} // STRICT or SMART
else
{
int mohVal = MINUTE_OF_HOUR.checkValidIntValue(moh);
int nosVal = NANO_OF_SECOND.checkValidIntValue(nos);
// handle 24:00 end of day
if (ResolverStyle == ResolverStyle.SMART && hod == 24 && mohVal == 0 && som == 0 && nosVal == 0)
{
UpdateCheckConflict(LocalTime.MIDNIGHT, Period.OfDays(1));
}
else
{
int hodVal = HOUR_OF_DAY.checkValidIntValue(hod);
int somVal = SECOND_OF_MINUTE.checkValidIntValue(som);
UpdateCheckConflict(LocalTime.Of(hodVal, mohVal, somVal, nosVal), Period.ZERO);
}
}
}
//-----------------------------------------------------------------------
internal override HijrahDate PlusYears(long years)
{
if (years == 0)
{
return(this);
}
int newYear = Math.AddExact(this.ProlepticYear, (int)years);
return(ResolvePreviousValid(newYear, MonthOfYear, DayOfMonth));
}
//-----------------------------------------------------------------------
public long Until(Temporal endExclusive, TemporalUnit unit)
{
Objects.RequireNonNull(endExclusive, "endExclusive");
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") ChronoLocalDateTime<D> end = (ChronoLocalDateTime<D>) getChronology().localDateTime(endExclusive);
ChronoLocalDateTime <D> end = (ChronoLocalDateTime <D>)Chronology.localDateTime(endExclusive);
if (unit is ChronoUnit)
{
if (unit.TimeBased)
{
long amount = end.getLong(EPOCH_DAY) - Date.GetLong(EPOCH_DAY);
switch ((ChronoUnit)unit)
{
case NANOS:
amount = Math.MultiplyExact(amount, NANOS_PER_DAY);
break;
case MICROS:
amount = Math.MultiplyExact(amount, MICROS_PER_DAY);
break;
case MILLIS:
amount = Math.MultiplyExact(amount, MILLIS_PER_DAY);
break;
case SECONDS:
amount = Math.MultiplyExact(amount, SECONDS_PER_DAY);
break;
case MINUTES:
amount = Math.MultiplyExact(amount, MINUTES_PER_DAY);
break;
case HOURS:
amount = Math.MultiplyExact(amount, HOURS_PER_DAY);
break;
case HALF_DAYS:
amount = Math.MultiplyExact(amount, 2);
break;
}
return(Math.AddExact(amount, Time.Until(end.ToLocalTime(), unit)));
}
ChronoLocalDate endDate = end.ToLocalDate();
if (end.ToLocalTime().IsBefore(Time))
{
endDate = endDate.minus(1, ChronoUnit.DAYS);
}
return(Date.Until(endDate, unit));
}
Objects.RequireNonNull(unit, "unit");
return(unit.Between(this, end));
}
//-----------------------------------------------------------------------
private void ResolveTimeFields()
{
// simplify fields
if (FieldValues.ContainsKey(CLOCK_HOUR_OF_DAY))
{
// lenient allows anything, smart allows 0-24, strict allows 1-24
long ch = FieldValues.Remove(CLOCK_HOUR_OF_DAY);
if (ResolverStyle == ResolverStyle.STRICT || (ResolverStyle == ResolverStyle.SMART && ch != 0))
{
CLOCK_HOUR_OF_DAY.checkValidValue(ch);
}
UpdateCheckConflict(CLOCK_HOUR_OF_DAY, HOUR_OF_DAY, ch == 24 ? 0 : ch);
}
if (FieldValues.ContainsKey(CLOCK_HOUR_OF_AMPM))
{
// lenient allows anything, smart allows 0-12, strict allows 1-12
long ch = FieldValues.Remove(CLOCK_HOUR_OF_AMPM);
if (ResolverStyle == ResolverStyle.STRICT || (ResolverStyle == ResolverStyle.SMART && ch != 0))
{
CLOCK_HOUR_OF_AMPM.checkValidValue(ch);
}
UpdateCheckConflict(CLOCK_HOUR_OF_AMPM, HOUR_OF_AMPM, ch == 12 ? 0 : ch);
}
if (FieldValues.ContainsKey(AMPM_OF_DAY) && FieldValues.ContainsKey(HOUR_OF_AMPM))
{
long ap = FieldValues.Remove(AMPM_OF_DAY);
long hap = FieldValues.Remove(HOUR_OF_AMPM);
if (ResolverStyle == ResolverStyle.LENIENT)
{
UpdateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, Math.AddExact(Math.MultiplyExact(ap, 12), hap));
} // STRICT or SMART
else
{
AMPM_OF_DAY.checkValidValue(ap);
HOUR_OF_AMPM.checkValidValue(ap);
UpdateCheckConflict(AMPM_OF_DAY, HOUR_OF_DAY, ap * 12 + hap);
}
}
if (FieldValues.ContainsKey(NANO_OF_DAY))
{
long nod = FieldValues.Remove(NANO_OF_DAY);
if (ResolverStyle != ResolverStyle.LENIENT)
{
NANO_OF_DAY.checkValidValue(nod);
}
UpdateCheckConflict(NANO_OF_DAY, HOUR_OF_DAY, nod / 3600_000_000_000L);
UpdateCheckConflict(NANO_OF_DAY, MINUTE_OF_HOUR, (nod / 60_000_000_000L) % 60);
UpdateCheckConflict(NANO_OF_DAY, SECOND_OF_MINUTE, (nod / 1_000_000_000L) % 60);
UpdateCheckConflict(NANO_OF_DAY, NANO_OF_SECOND, nod % 1_000_000_000L);
}
if (FieldValues.ContainsKey(MICRO_OF_DAY))
{
long cod = FieldValues.Remove(MICRO_OF_DAY);
if (ResolverStyle != ResolverStyle.LENIENT)
{
MICRO_OF_DAY.checkValidValue(cod);
}
UpdateCheckConflict(MICRO_OF_DAY, SECOND_OF_DAY, cod / 1_000_000L);
UpdateCheckConflict(MICRO_OF_DAY, MICRO_OF_SECOND, cod % 1_000_000L);
}
if (FieldValues.ContainsKey(MILLI_OF_DAY))
{
long lod = FieldValues.Remove(MILLI_OF_DAY);
if (ResolverStyle != ResolverStyle.LENIENT)
{
MILLI_OF_DAY.checkValidValue(lod);
}
UpdateCheckConflict(MILLI_OF_DAY, SECOND_OF_DAY, lod / 1000);
UpdateCheckConflict(MILLI_OF_DAY, MILLI_OF_SECOND, lod % 1000);
}
if (FieldValues.ContainsKey(SECOND_OF_DAY))
{
long sod = FieldValues.Remove(SECOND_OF_DAY);
if (ResolverStyle != ResolverStyle.LENIENT)
{
SECOND_OF_DAY.checkValidValue(sod);
}
UpdateCheckConflict(SECOND_OF_DAY, HOUR_OF_DAY, sod / 3600);
UpdateCheckConflict(SECOND_OF_DAY, MINUTE_OF_HOUR, (sod / 60) % 60);
UpdateCheckConflict(SECOND_OF_DAY, SECOND_OF_MINUTE, sod % 60);
}
if (FieldValues.ContainsKey(MINUTE_OF_DAY))
{
long mod = FieldValues.Remove(MINUTE_OF_DAY);
if (ResolverStyle != ResolverStyle.LENIENT)
{
MINUTE_OF_DAY.checkValidValue(mod);
}
UpdateCheckConflict(MINUTE_OF_DAY, HOUR_OF_DAY, mod / 60);
UpdateCheckConflict(MINUTE_OF_DAY, MINUTE_OF_HOUR, mod % 60);
}
// combine partial second fields strictly, leaving lenient expansion to later
if (FieldValues.ContainsKey(NANO_OF_SECOND))
{
long nos = FieldValues[NANO_OF_SECOND];
if (ResolverStyle != ResolverStyle.LENIENT)
{
NANO_OF_SECOND.checkValidValue(nos);
}
if (FieldValues.ContainsKey(MICRO_OF_SECOND))
{
long cos = FieldValues.Remove(MICRO_OF_SECOND);
if (ResolverStyle != ResolverStyle.LENIENT)
{
MICRO_OF_SECOND.checkValidValue(cos);
}
nos = cos * 1000 + (nos % 1000);
UpdateCheckConflict(MICRO_OF_SECOND, NANO_OF_SECOND, nos);
}
if (FieldValues.ContainsKey(MILLI_OF_SECOND))
{
long los = FieldValues.Remove(MILLI_OF_SECOND);
if (ResolverStyle != ResolverStyle.LENIENT)
{
MILLI_OF_SECOND.checkValidValue(los);
}
UpdateCheckConflict(MILLI_OF_SECOND, NANO_OF_SECOND, los * 1_000_000L + (nos % 1_000_000L));
}
}
// convert to time if all four fields available (optimization)
if (FieldValues.ContainsKey(HOUR_OF_DAY) && FieldValues.ContainsKey(MINUTE_OF_HOUR) && FieldValues.ContainsKey(SECOND_OF_MINUTE) && FieldValues.ContainsKey(NANO_OF_SECOND))
{
long hod = FieldValues.Remove(HOUR_OF_DAY);
long moh = FieldValues.Remove(MINUTE_OF_HOUR);
long som = FieldValues.Remove(SECOND_OF_MINUTE);
long nos = FieldValues.Remove(NANO_OF_SECOND);
ResolveTime(hod, moh, som, nos);
}
}
//-----------------------------------------------------------------------
public ChronoPeriod Plus(TemporalAmount amountToAdd)
{
ChronoPeriodImpl amount = ValidateAmount(amountToAdd);
return(new ChronoPeriodImpl(Chrono, Math.AddExact(Years, amount.Years), Math.AddExact(Months, amount.Months), Math.AddExact(Days, amount.Days)));
}
public override long Millis()
{
return(Math.AddExact(BaseClock.Millis(), Offset.ToMillis()));
}
