public void AddMonthlyDayOfWeekForwardEventThrowsStartEndInbound()
{
const string eventName = "alpha";
var start = new DateTime(DateTime.Now.AddYears(-2).Year, DateTime.Now.AddYears(-2).Month, 1);
var end = DateTime.Now.AddYears(2);
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyDayOfWeekForwardEvent(eventName, true, DayOfWeek.Friday, 1, start, end);
bool foundFirstFriday = false;
for (var currentDate = start; currentDate <= end; currentDate = currentDate.AddDays(1))
{
if (currentDate.IsFirstDayOfMonth())
{
foundFirstFriday = false;
}
if (!foundFirstFriday && currentDate.DayOfWeek == DayOfWeek.Friday)
{
foundFirstFriday = true;
Assert.Contains(eventName, currentDate.EventsOnDate(true, true));
}
else
{
Assert.Empty(currentDate.EventsOnDate(true, true));
}
}
}
public void AddDateEventThrowEventDuplicate1()
{
const string duplicate = "dup";
CalendarDateTime.AddDateEvent(duplicate, false, DateTime.Now);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddDateEvent(duplicate, false, DateTime.Now));
}
public void AddWeeklyInMonthEventEventNameNullEmptyThrows()
{
var dayOfWeeks = DayOfWeek.Monday;
Assert.Throws <ArgumentNullException>(() => CalendarDateTime.AddWeeklyInMonthEvent(null, true, dayOfWeeks));
Assert.Throws <ArgumentNullException>(() => CalendarDateTime.AddWeeklyInMonthEvent(string.Empty, true, dayOfWeeks));
}
public static CalendarDateTime Add(CalendarDateTime x, Duration y)
{
if (y is CalendarDateTimeDuration)
{
return Add(x, (CalendarDateTimeDuration)y);
}
if (y is OrdinalDateTimeDuration)
{
return Add(x, ((OrdinalDateTimeDuration)y).ToCalendarDateTimeDuration());
}
if (y is CalendarDateDuration)
{
return Add(x, (CalendarDateDuration)y);
}
if (y is OrdinalDateDuration)
{
return Add(x, ((OrdinalDateDuration)y).ToCalendarDateDuration());
}
if (y is TimeDuration)
{
return Add(x, (TimeDuration)y);
}
if (y is DesignatedDuration)
{
return Add(x, (DesignatedDuration)y);
}
throw new InvalidOperationException($"A {y.GetType()} cannot be added to a {x.GetType()}.");
}
public static void AddMonthlyDayOfWeekReverseEventsInRange()
{
var eventName = "someName";
var start = _startTestDate;
var end = _endTestDate.LastDateOfMonth();
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyDayOfWeekReverseEvent(eventName, true, DayOfWeek.Monday, 1, start, end); // Last Monday of every month
var foundLastMonday = false;
// dateEnd need to seed in as equal or after the last Monday of the month to work (last day of the month works).
for (var currentDate = end; currentDate >= start; currentDate = currentDate.AddDays(-1))
{
if (currentDate.IsLastDayOfMonth())
{
foundLastMonday = false;
}
if (!foundLastMonday && currentDate.DayOfWeek == DayOfWeek.Monday)
{
foundLastMonday = true;
var actual = currentDate.EventsOnDate(true, true);
Assert.Contains(eventName, actual);
}
else
{
Assert.Empty(currentDate.EventsOnDate(true, true));
}
}
}
public void AddWeeklyEventEmptyEventDupThrows()
{
const string dupEvent = "duplicate";
CalendarDateTime.AddMonthlyDateEvent(dupEvent, true, 1);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddMonthlyDateEvent(dupEvent, true, 1));
}
public void EventsOnDateYearlyReverse()
{
var offKey = new List <string> {
"rev1"
};
var workKey = new List <string> {
"rev2"
};
var bothOffWork = new List <string>();
bothOffWork.AddRange(offKey);
bothOffWork.AddRange(workKey);
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyDayOfWeekReverseEvent(offKey[0], true, 5, 2, DayOfWeek.Monday);
CalendarDateTime.AddYearlyDayOfWeekReverseEvent(workKey[0], false, 5, 2, DayOfWeek.Monday);
var testDate = new DateTime(2018, 5, 21);
var dayOff = testDate.EventsOnDate(false, true).ToList();
var workday = testDate.EventsOnDate(true, false).ToList();
var both = testDate.EventsOnDate(true, true).ToList();
var neither = testDate.EventsOnDate(false, false).ToList();
Assert.NotStrictEqual(dayOff, offKey);
Assert.NotStrictEqual(workday, workKey);
Assert.Empty(neither);
Assert.NotStrictEqual(bothOffWork, both);
Assert.Empty(testDate.AddDays(1).EventsOnDate(true, true));
}
public void EventsOnDateAnnual()
{
var offKey = new List <string> {
"key1"
};
var workKey = new List <string> {
"key2"
};
var bothOffWork = new List <string>();
bothOffWork.AddRange(offKey);
bothOffWork.AddRange(workKey);
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddDateEvent(offKey[0], true, DateTime.Now);
CalendarDateTime.AddDateEvent(workKey[0], false, DateTime.Now);
var dayOff = DateTime.Now.EventsOnDate(false, true).ToList();
var workday = DateTime.Now.EventsOnDate(true, false).ToList();
var both = DateTime.Now.EventsOnDate(true, true).ToList();
var neither = DateTime.Now.EventsOnDate(false, false).ToList();
Assert.NotStrictEqual(dayOff, offKey);
Assert.NotStrictEqual(workday, workKey);
Assert.Empty(neither);
Assert.NotStrictEqual(bothOffWork, both);
Assert.Empty(DateTime.Now.AddDays(1).EventsOnDate(true, true));
}
public void EventsOnDateDate()
{
var offKey = new List <string> {
"dayOf"
};
var workKey = new List <string> {
"dayOn"
};
var bothOffWork = new List <string>();
bothOffWork.AddRange(offKey);
bothOffWork.AddRange(workKey);
var date = DateTime.Now;
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyDateEvent(offKey[0], true, date.Month, date.Day, false, false);
CalendarDateTime.AddYearlyDateEvent(workKey[0], false, date.Month, date.Day, false, false);
var dayOff = date.EventsOnDate(false, true).ToList();
var workday = date.EventsOnDate(true, false).ToList();
var both = date.EventsOnDate(true, true).ToList();
var neither = date.EventsOnDate(false, false).ToList();
Assert.NotStrictEqual(dayOff, offKey);
Assert.NotStrictEqual(workday, workKey);
Assert.Empty(neither);
Assert.NotStrictEqual(bothOffWork, both);
Assert.Empty(date.AddDays(1).EventsOnDate(true, true));
}
public void EventsOnDateYearlyCalculated()
{
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyCalculatedEvent(HolidayNames.EasterSundayText, true);
CalendarDateTime.AddYearlyCalculatedEvent(HolidayNames.GoodFridayText, false);
var goodFridayDate = new DateTime(2018, 3, 30);
var goodFridayDayOff = goodFridayDate.EventsOnDate(false, true);
var goodFridayWorkday = goodFridayDate.EventsOnDate(true, false);
var goodFridayBoth = goodFridayDate.EventsOnDate(true, true);
var goodFridayNeither = goodFridayDate.EventsOnDate(false, false);
Assert.Empty(goodFridayDayOff);
Assert.Contains(CalculatedEventsText.GoodFriday, goodFridayWorkday);
Assert.Empty(goodFridayNeither);
Assert.Contains(CalculatedEventsText.GoodFriday, goodFridayBoth);
var easterDate = new DateTime(2018, 4, 1);
var easterDayOff = easterDate.EventsOnDate(false, true);
var easterWorkday = easterDate.EventsOnDate(true, false);
var easterBoth = easterDate.EventsOnDate(true, true);
var easterNeither = easterDate.EventsOnDate(false, false);
Assert.Contains(CalculatedEventsText.EasterSunday, easterDayOff);
Assert.Empty(easterWorkday);
Assert.Empty(easterNeither);
Assert.Contains(CalculatedEventsText.EasterSunday, easterBoth);
}
public void AddMonthlyDayOfWeekForwardEventThrowsWeeksForwardInvalid()
{
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyDayOfWeekForwardEvent("alpha", true, DayOfWeek.Friday, 1);
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.AddMonthlyDayOfWeekForwardEvent("beta", true, DayOfWeek.Friday, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.AddMonthlyDayOfWeekForwardEvent("delta", true, DayOfWeek.Friday, -1));
}
public void Remove()
{
const string monthlyKey = "monthlyKey";
const string weekKey = "WeekKey";
const string yearlyKey = "YearlyKey";
const string dateKey = "dateKey";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyDateEvent(yearlyKey, false, 1, 2, false, false);
CalendarDateTime.AddMonthlyDateEvent(monthlyKey, true, 12);
CalendarDateTime.AddWeeklyInMonthEvent(weekKey, false, DayOfWeek.Friday);
CalendarDateTime.AddDateEvent(dateKey, false, DateTime.Now);
Assert.False(CalendarDateTime.RemoveEvent("nothingRemoved"));
Assert.True(CalendarDateTime.CountEvents == 4);
Assert.True(CalendarDateTime.RemoveEvent(weekKey));
Assert.True(CalendarDateTime.CountEvents == 3);
Assert.True(CalendarDateTime.RemoveEvent(dateKey));
Assert.True(CalendarDateTime.CountEvents == 2);
Assert.True(CalendarDateTime.RemoveEvent(yearlyKey));
Assert.True(CalendarDateTime.CountEvents == 1);
Assert.False(CalendarDateTime.RemoveEvent("notHere"));
Assert.True(CalendarDateTime.CountEvents == 1);
Assert.True(CalendarDateTime.RemoveEvent(monthlyKey));
Assert.True(CalendarDateTime.CountEvents == 0);
}
public void IsOffDay1And3Wednesday()
{
var testDayOfWeek = DayOfWeek.Wednesday;
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddWeeklyInMonthEvent("FirstThird", true, testDayOfWeek, new List <int> {
1, 3
});
var occurrence = -99;
var currentDate = _startTestDate;
var dayOfWeekInc = currentDate.DayOfWeek;
var dateEnd = _endTestDate;
while (currentDate <= dateEnd)
{
if (currentDate.Day == 1)
{
occurrence = 1;
dayOfWeekInc = currentDate.DayOfWeek;
}
else if (currentDate.DayOfWeek == dayOfWeekInc)
{
occurrence++;
}
var expected = currentDate.DayOfWeek == testDayOfWeek && (occurrence == 1 || occurrence == 3);
var actual = currentDate.IsDayOff();
Assert.True(expected == actual, "Failed on, " + currentDate);
currentDate = currentDate.AddDays(1);
}
}
public void EventDatesMonthlyOfWeekReverseEvent()
{
const string eventName = "Tango";
const int targetWeek = 2;
const DayOfWeek targetDayOfWeek = DayOfWeek.Wednesday;
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyDayOfWeekReverseEvent(eventName, true, targetDayOfWeek, targetWeek, _startTestDate, _endTestDate);
var actual = eventName.EventDatesBetween(_startTestDate, _endTestDate);
var expected = new List <DateTime>();
int week = 0;
for (var date = _endTestDate; date >= _startTestDate; date = date.AddDays(-1))
{
if (date.IsLastDayOfMonth())
{
week = 0;
}
if (date.DayOfWeek == targetDayOfWeek)
{
week++;
}
if (week == targetWeek && date.DayOfWeek == targetDayOfWeek)
{
expected.Add(date);
}
}
expected = expected.OrderBy(s => s).ToList();
Assert.Equal(expected, actual);
}
public static void AddMonthlyDayOfWeekReverseEventDuplicateThrows()
{
const string dupName = "dup";
CalendarDateTime.AddMonthlyDayOfWeekReverseEvent(dupName, true, DayOfWeek.Monday, 2);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddMonthlyDayOfWeekReverseEvent(dupName, true, DayOfWeek.Monday, 2));
}
public void AddMonthlyDayEventYearRange()
{
CalendarDateTime.ClearCalendar();
var event1Name = "Workday1";
const bool event1OffDay = false;
var event1Day = 12;
var firstValidDate = _startTestDate.AddYears(5);
var lastValidDate = _endTestDate.AddYears(-5);
Assert.Equal(0, CalendarDateTime.CountEvents);
CalendarDateTime.AddMonthlyDateEvent(event1Name, event1OffDay, event1Day, firstValidDate, lastValidDate);
Assert.Equal(1, CalendarDateTime.CountMonthlyEvents);
Assert.Equal(1, CalendarDateTime.CountEvents);
for (var currentDate = _startTestDate; currentDate <= _endTestDate; currentDate = currentDate.AddDays(1))
{
Assert.Equal(currentDate.IsDayOff(), event1OffDay);
Assert.Equal(currentDate.IsWorkDay(), !event1OffDay);
var expected = new List <string>();
if (currentDate.IsBetweenEqual(firstValidDate, lastValidDate) && currentDate.Day == event1Day)
{
expected.Add(event1Name);
}
var actual = currentDate.EventsOnDate(true, true);
Assert.Equal(expected, actual);
}
}
public void AddYearlyDayOfWeekReverseEventDuplicate()
{
const string dup = "dup";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyDayOfWeekForwardEvent(dup, true, 10, 1, DayOfWeek.Friday);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddYearlyDayOfWeekForwardEvent(dup, true, 11, 1, DayOfWeek.Friday));
}
public void DayOfWeekMonthForwardThrowsYearMax()
{
var date = DateTime.MaxValue;
CalendarDateTime.ClearCalendar();
CalendarDateTime.DayOfWeekMonthForward(date.Year, 1, DayOfWeek.Friday, 1);
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.DayOfWeekMonthForward(date.Year + 1, date.Month, date.DayOfWeek, 1));
}
public void DuplicateKeysThrows()
{
const string weekKey = "WeekKey";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddWeeklyInMonthEvent(weekKey, false, DayOfWeek.Friday);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddYearlyDateEvent(weekKey, false, 1, 2, false, false));
}
public void AddWeeklyEventIntervalInvalidThrows()
{
var dates = new List <DayOfWeek> {
DayOfWeek.Tuesday, DayOfWeek.Thursday
};
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.AddWeeklyEvent("beta", true, dates, null, 0));
}
public void AddWeeklyEventNullEventNameThrows()
{
var dates = new List <DayOfWeek> {
DayOfWeek.Tuesday, DayOfWeek.Thursday
};
Assert.Throws <ArgumentNullException>(() => CalendarDateTime.AddWeeklyEvent(null, true, dates));
}
public void DayOfWeekMonthReverseThrowsYearMin()
{
var date = DateTime.MinValue;
CalendarDateTime.ClearCalendar();
CalendarDateTime.DayOfWeekMonthReverse(date.Year, date.Month, DayOfWeek.Friday, 1);
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.DayOfWeekMonthReverse(date.Year - 1, date.Month, date.DayOfWeek, 1));
}
public void AddMonthlyDayOfWeekForwardEventThrowsDuplicate()
{
const string dup = "duplicate";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyDayOfWeekForwardEvent(dup, false, DayOfWeek.Monday, 2);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddMonthlyDayOfWeekForwardEvent(dup, true, DayOfWeek.Friday, 1));
}
public void AddYearlyDayOfWeekReverseEventWeekDuplicate()
{
const string duplicate = "duplicate";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddYearlyDayOfWeekReverseEvent(duplicate, true, 1, 1, DayOfWeek.Monday);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddYearlyDayOfWeekReverseEvent(duplicate, false, 1, 1, DayOfWeek.Monday));
}
public void AddMonthlyDayEventThrowsInvalidDay()
{
CalendarDateTime.ClearCalendar();
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.AddMonthlyDateEvent("alpha", false, 0));
CalendarDateTime.AddMonthlyDateEvent("beta", true, 1);
CalendarDateTime.AddMonthlyDateEvent("delta", true, 31);
Assert.Throws <ArgumentOutOfRangeException>(() => CalendarDateTime.AddMonthlyDateEvent("gamma", false, 32));
}
public void AddMonthlyLastDayEventDuplicate()
{
const string eventName = "zink";
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddMonthlyLastDayEvent(eventName, true);
Assert.Throws <ArgumentException>(() => CalendarDateTime.AddMonthlyLastDayEvent(eventName, true));
}
public void EventDatesBetweenEmptyEvent()
{
CalendarDateTime.ClearCalendar();
Calendars.NewYorkStockExchange();
var expected = new ImmutableArray <DateTime>();
var actual = string.Empty.EventDatesBetween(DateTime.MaxValue.Year, DateTime.MinValue.Year);
Assert.Equal(expected, actual);
}
public void EventDatesBetweenSwap()
{
CalendarDateTime.ClearCalendar();
Holidays.NewYearsDay(true, false, false);
var expected = Enumerable.Range(_startTestDate.Year, _endTestDate.Year - _startTestDate.Year + 1).Select(s => new DateTime(s, 1, 1));
var actual = HolidayNames.NewYearsDayText.EventDatesBetween(_endTestDate.Year, _startTestDate.Year);
Assert.Equal(expected, actual);
}
private void TestSetForwardWeekDayHolidays([NotNull] List <Holiday> assertHolidays, int expectedWeek, DayOfWeek expectedDayOfWeek, [NotNull] string expectedHoliday)
{
TestSetYearRange(assertHolidays);
foreach (var assertHoliday in assertHolidays)
{
var expectedDate = CalendarDateTime.DayOfWeekMonthForward(assertHoliday.Date.Year, assertHoliday.Date.Month, expectedDayOfWeek, expectedWeek);
Assert.True(assertHoliday.Date == expectedDate, "Date miss match in the " + expectedHoliday + " set");
}
}
public void EventDatesBetweenEmpty()
{
CalendarDateTime.ClearCalendar();
DefinedCalendars.USA.Holidays.ThanksgivingDay(true);
var expected = new List <DateTime>();
var actual = CalendarDateTime.EventDatesBetween(null);
Assert.Equal(expected, actual);
}
internal static string Serialize(CalendarDateTime dateTime, ISO8601Options options)
{
if (options == null)
{
options = ISO8601Options.Default;
}
return dateTime.Date.ToString(options) + dateTime.Time.ToString(options);
}
public void IsDayOffAnnualTrue()
{
const string may1Name = "A Test";
var may1Date = DateTime.Now;
CalendarDateTime.ClearCalendar();
CalendarDateTime.AddDateEvent(may1Name, true, may1Date);
Assert.True(may1Date.IsDayOff());
}
internal static TimeSpan Subtract(CalendarDateTime later, TimePoint earlier)
{
if (earlier is CalendarDateTime)
{
return later - (CalendarDateTime)earlier;
}
if (earlier is OrdinalDateTime)
{
return later - ((OrdinalDateTime)earlier).ToCalendarDateTime();
}
if (earlier is WeekDateTime)
{
return later - ((WeekDateTime)earlier).ToCalendarDateTime();
}
if (earlier is CalendarDate)
{
return later - (CalendarDate)earlier;
}
if (earlier is OrdinalDate)
{
return later - ((OrdinalDate)earlier).ToCalendarDate();
}
if (earlier is WeekDate)
{
return later - ((WeekDate)earlier).ToCalendarDate();
}
if (earlier is Time)
{
return later - (Time)earlier;
}
throw new InvalidOperationException($"A {earlier.GetType()} cannot be subtracted from a {later.GetType()}");
}
public static TimeSpan Subtract(CalendarDateTime later, CalendarDate earlier)
{
return TimeSpan.FromDays(
(later.Year - earlier.Year) * 365
+ (later.Year - 1) / 4 - (earlier.Year - 1) / 4
- (later.Year - 1) / 100 + (earlier.Year - 1) / 100
+ (later.Year - 1) / 400 - (earlier.Year - 1) / 400
+ DaysToMonth(later.Year, later.Month)
- DaysToMonth(earlier.Year, earlier.Month)
+ later.Day
- earlier.Day)
+ TimeSpan.FromHours(later.Hour)
+ TimeSpan.FromMinutes(later.Minute)
+ TimeSpan.FromSeconds(later.Second);
}
public static CalendarDateTime Add(CalendarDateTime x, TimeDuration y)
{
double day = x.Day;
double month = x.Month;
long year = x.Year;
double second = x.Second;
double minute = x.Minute;
double hour = x.Hour + y.Hours;
TimePrecision precision = x.Precision;
if (y.Minutes != null)
{
minute += y.Minutes.Value;
if (precision < TimePrecision.Minute)
{
precision = TimePrecision.Minute;
}
}
if (y.Seconds != null)
{
second += y.Seconds.Value;
if (precision < TimePrecision.Second)
{
precision = TimePrecision.Second;
}
}
if (hour != (int)hour && precision < TimePrecision.Minute)
{
minute += (hour - (int)hour) * MinutesPerHour;
hour = (int)hour;
}
if (minute != (int)minute && precision < TimePrecision.Second)
{
second += (minute - (int)minute) * SecondsPerMinute;
second = (int)second;
}
while (second >= SecondsPerMinute)
{
second -= SecondsPerMinute;
minute++;
}
while (minute >= MinutesPerHour)
{
minute -= MinutesPerHour;
hour++;
}
while (hour >= HoursPerDay)
{
hour -= HoursPerDay;
day++;
}
while (month > MonthsPerYear)
{
month -= MonthsPerYear;
year++;
}
int daysInMonth = DaysInMonth(year, (int)month);
while (day > daysInMonth)
{
day -= daysInMonth;
month++;
daysInMonth = DaysInMonth(year, (int)month);
}
switch (precision)
{
case TimePrecision.Hour:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time(hour));
case TimePrecision.Minute:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time((int)hour, minute));
case TimePrecision.Second:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time((int)hour, (int)minute, second));
default:
return null;
}
}
public static CalendarDateTime Add(CalendarDateTime x, CalendarDateDuration y)
{
double day = x.Day;
double month = x.Month;
double year = x.Year;
var second = x.Second;
var minute = x.Minute;
var hour = x.Hour;
var precision = x.Precision;
year += y.Years;
if (y.Months != null)
{
month += y.Months.Value;
}
if (y.Days != null)
{
day += y.Days.Value;
}
while ((int)month > MonthsPerYear)
{
month -= MonthsPerYear;
year++;
}
int daysInMonth = DaysInMonth((long)year, (int)month);
while (day > daysInMonth)
{
day -= daysInMonth;
month++;
daysInMonth = DaysInMonth((long)year, (int)month);
}
switch (precision)
{
case TimePrecision.Hour:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time(hour));
case TimePrecision.Minute:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time((int)hour, minute));
case TimePrecision.Second:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time((int)hour, (int)minute, second));
default:
return null;
}
}
public static CalendarDateTime Add(CalendarDateTime x, DesignatedDuration y)
{
double day = x.Day;
double month = x.Month;
double year = x.Year;
var second = x.Second;
var minute = x.Minute;
var hour = x.Hour;
var precision = x.Precision;
if (y.Years != null)
{
year += y.Years.Value;
}
if (y.Months != null)
{
month += y.Months.Value;
if (year != (int)year)
{
month += (year - (int)year) * 60;
}
}
if (y.Days != null)
{
day += y.Days.Value;
if (month != (int)month)
{
day += (month - (int)month) * 60;
}
}
if (y.Hours != null)
{
hour += y.Hours.Value;
if (day != (int)day)
{
hour += (day - (int)day) * 24;
}
}
if (y.Minutes != null)
{
minute += y.Minutes.Value;
if (hour != (int)hour)
{
minute += (hour - (int)hour) * 60;
}
if (precision < TimePrecision.Minute)
{
precision = TimePrecision.Minute;
}
}
if (y.Seconds != null)
{
second += y.Seconds.Value;
if (minute != (int)minute)
{
second += (minute - (int)minute) * 60;
}
if (precision < TimePrecision.Second)
{
precision = TimePrecision.Second;
}
}
while (!(second < 60))
{
second -= 60;
minute++;
}
while ((int)minute > 59 || (precision == TimePrecision.Minute && !(minute < 60d)))
{
minute -= 60;
hour++;
}
while ((int)hour > 23 || (precision == TimePrecision.Hour && hour >= 24d))
{
hour -= 24;
day++;
}
while ((int)month > 12)
{
month -= 12;
year++;
}
int daysInMonth = DaysInMonth((long)year, (int)month);
while (day > daysInMonth)
{
day -= daysInMonth;
month++;
daysInMonth = DaysInMonth((long)year, (int)month);
}
switch (precision)
{
case TimePrecision.Hour:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time(hour));
case TimePrecision.Minute:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time((int)hour, minute));
case TimePrecision.Second:
return new CalendarDateTime(new CalendarDate((long)year, (int)month, (int)day), new Time((int)hour, (int)minute, second));
default:
return null;
}
}
public static CalendarDateTime Subtract(CalendarDateTime x, CalendarDateTimeDuration y)
{
long year = x.Year - y.Years;
double month = x.Month - y.Months;
double day = x.Day - y.Days;
double hour = x.Hour - y.Hours;
double minute = x.Minute;
double second = x.Second;
TimePrecision precision = x.Precision;
if (y.Minutes != null)
{
minute -= y.Minutes.Value;
if (minute != (int)minute && precision > TimePrecision.Minute)
{
second += (minute - (int)minute) * SecondsPerMinute;
minute = (int)minute;
}
if (precision < TimePrecision.Minute)
{
precision = TimePrecision.Minute;
}
}
if (y.Seconds != null)
{
second -= y.Seconds.Value;
if (precision < TimePrecision.Second)
{
precision = TimePrecision.Second;
}
}
while (second <= -SecondsPerMinute)
{
second += SecondsPerMinute;
minute--;
}
while (minute <= -MinutesPerHour)
{
minute += MinutesPerHour;
hour--;
}
while (hour <= -HoursPerDay)
{
hour += HoursPerDay;
day--;
}
while (month < 1)
{
month += MonthsPerYear;
year--;
}
while (day < 1)
{
day += DaysInMonth(year, (int)month);
month--;
}
switch (precision)
{
case TimePrecision.Hour:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time(hour));
case TimePrecision.Minute:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time((int)hour, minute));
case TimePrecision.Second:
return new CalendarDateTime(new CalendarDate(year, (int)month, (int)day), new Time((int)hour, (int)minute, second));
default:
return null;
}
}
public static TimeSpan Subtract(CalendarDateTime later, Time earlier)
{
return TimeSpan.FromHours(
later.Hour - earlier.Hour
+ later.Time.UtcOffset.Hours - earlier.UtcOffset.Hours)
+ TimeSpan.FromMinutes(
later.Minute - earlier.Minute
+ later.Time.UtcOffset.Minutes - earlier.UtcOffset.Minutes)
+ TimeSpan.FromSeconds(later.Second - earlier.Second);
}
internal static WeekDateTime ToWeekDateTime(CalendarDateTime datetime)
{
return new WeekDateTime(datetime.Date.ToWeekDate(), datetime.Time);
}
internal static OrdinalDateTime ToOrdinalDateTime(CalendarDateTime datetime)
{
return new OrdinalDateTime(datetime.Date.ToOrdinalDate(), datetime.Time);
}
