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); }