netcore/System.Private.CoreLib/shared/System/Globalization/GregorianCalendarHelper.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 namespace System.Globalization
   6 {
   7     // Gregorian Calendars use Era Info
   8     internal class EraInfo
   9     {
  10         internal int era;          // The value of the era.
  11         internal long ticks;    // The time in ticks when the era starts
  12         internal int yearOffset;   // The offset to Gregorian year when the era starts.
  13                                    // Gregorian Year = Era Year + yearOffset
  14                                    // Era Year = Gregorian Year - yearOffset
  15         internal int minEraYear;   // Min year value in this era. Generally, this value is 1, but this may
  16                                    // be affected by the DateTime.MinValue;
  17         internal int maxEraYear;   // Max year value in this era. (== the year length of the era + 1)
  18
  19         internal string? eraName;    // The era name
  20         internal string? abbrevEraName;  // Abbreviated Era Name
  21         internal string? englishEraName; // English era name
  22
  23         internal EraInfo(int era, int startYear, int startMonth, int startDay, int yearOffset, int minEraYear, int maxEraYear)
  24         {
  25             this.era = era;
  26             this.yearOffset = yearOffset;
  27             this.minEraYear = minEraYear;
  28             this.maxEraYear = maxEraYear;
  29             this.ticks = new DateTime(startYear, startMonth, startDay).Ticks;
  30         }
  31
  32         internal EraInfo(int era, int startYear, int startMonth, int startDay, int yearOffset, int minEraYear, int maxEraYear,
  33                           string eraName, string abbrevEraName, string englishEraName)
  34         {
  35             this.era = era;
  36             this.yearOffset = yearOffset;
  37             this.minEraYear = minEraYear;
  38             this.maxEraYear = maxEraYear;
  39             this.ticks = new DateTime(startYear, startMonth, startDay).Ticks;
  40             this.eraName = eraName;
  41             this.abbrevEraName = abbrevEraName;
  42             this.englishEraName = englishEraName;
  43         }
  44     }
  45
  46     // This calendar recognizes two era values:
  47     // 0 CurrentEra (AD)
  48     // 1 BeforeCurrentEra (BC)
  49     internal class GregorianCalendarHelper
  50     {
  51         // 1 tick = 100ns = 10E-7 second
  52         // Number of ticks per time unit
  53         internal const long TicksPerMillisecond = 10000;
  54         internal const long TicksPerSecond = TicksPerMillisecond * 1000;
  55         internal const long TicksPerMinute = TicksPerSecond * 60;
  56         internal const long TicksPerHour = TicksPerMinute * 60;
  57         internal const long TicksPerDay = TicksPerHour * 24;
  58
  59         // Number of milliseconds per time unit
  60         internal const int MillisPerSecond = 1000;
  61         internal const int MillisPerMinute = MillisPerSecond * 60;
  62         internal const int MillisPerHour = MillisPerMinute * 60;
  63         internal const int MillisPerDay = MillisPerHour * 24;
  64
  65         // Number of days in a non-leap year
  66         internal const int DaysPerYear = 365;
  67         // Number of days in 4 years
  68         internal const int DaysPer4Years = DaysPerYear * 4 + 1;
  69         // Number of days in 100 years
  70         internal const int DaysPer100Years = DaysPer4Years * 25 - 1;
  71         // Number of days in 400 years
  72         internal const int DaysPer400Years = DaysPer100Years * 4 + 1;
  73
  74         // Number of days from 1/1/0001 to 1/1/10000
  75         internal const int DaysTo10000 = DaysPer400Years * 25 - 366;
  76
  77         internal const long MaxMillis = (long)DaysTo10000 * MillisPerDay;
  78
  79         internal const int DatePartYear = 0;
  80         internal const int DatePartDayOfYear = 1;
  81         internal const int DatePartMonth = 2;
  82         internal const int DatePartDay = 3;
  83
  84         //
  85         // This is the max Gregorian year can be represented by DateTime class.  The limitation
  86         // is derived from DateTime class.
  87         //
  88         internal int MaxYear => m_maxYear;
  89
  90         internal static readonly int[] DaysToMonth365 =
  91         {
  92             0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
  93         };
  94
  95         internal static readonly int[] DaysToMonth366 =
  96         {
  97             0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366
  98         };
  99
 100         internal int m_maxYear = 9999;
 101         internal int m_minYear;
 102         internal Calendar m_Cal;
 103
 104         internal EraInfo[] m_EraInfo;
 105         internal int[]? m_eras = null;
 106
 107
 108         // Construct an instance of gregorian calendar.
 109         internal GregorianCalendarHelper(Calendar cal, EraInfo[] eraInfo)
 110         {
 111             m_Cal = cal;
 112             m_EraInfo = eraInfo;
 113             m_maxYear = m_EraInfo[0].maxEraYear;
 114             m_minYear = m_EraInfo[0].minEraYear;
 115         }
 116
 117         // EraInfo.yearOffset:  The offset to Gregorian year when the era starts. Gregorian Year = Era Year + yearOffset
 118         //                      Era Year = Gregorian Year - yearOffset
 119         // EraInfo.minEraYear:  Min year value in this era. Generally, this value is 1, but this may be affected by the DateTime.MinValue;
 120         // EraInfo.maxEraYear:  Max year value in this era. (== the year length of the era + 1)
 121         private int GetYearOffset(int year, int era, bool throwOnError)
 122         {
 123             if (year < 0)
 124             {
 125                 if (throwOnError)
 126                 {
 127                     throw new ArgumentOutOfRangeException(nameof(year), SR.ArgumentOutOfRange_NeedNonNegNum);
 128                 }
 129                 return -1;
 130             }
 131
 132             if (era == Calendar.CurrentEra)
 133             {
 134                 era = m_Cal.CurrentEraValue;
 135             }
 136
 137             for (int i = 0; i < m_EraInfo.Length; i++)
 138             {
 139                 if (era == m_EraInfo[i].era)
 140                 {
 141                     if (year >= m_EraInfo[i].minEraYear)
 142                     {
 143                         if (year <= m_EraInfo[i].maxEraYear)
 144                         {
 145                             return m_EraInfo[i].yearOffset;
 146                         }
 147                         else if (!LocalAppContextSwitches.EnforceJapaneseEraYearRanges)
 148                         {
 149                             // If we got the year number exceeding the era max year number, this still possible be valid as the date can be created before
 150                             // introducing new eras after the era we are checking. we'll loop on the eras after the era we have and ensure the year
 151                             // can exist in one of these eras. otherwise, we'll throw.
 152                             // Note, we always return the offset associated with the requested era.
 153                             //
 154                             // Here is some example:
 155                             // if we are getting the era number 4 (Heisei) and getting the year number 32. if the era 4 has year range from 1 to 31
 156                             // then year 32 exceeded the range of era 4 and we'll try to find out if the years difference (32 - 31 = 1) would lay in
 157                             // the subsequent eras (e.g era 5 and up)
 158
 159                             int remainingYears = year - m_EraInfo[i].maxEraYear;
 160
 161                             for (int j = i - 1; j >= 0; j--)
 162                             {
 163                                 if (remainingYears <= m_EraInfo[j].maxEraYear)
 164                                 {
 165                                     return m_EraInfo[i].yearOffset;
 166                                 }
 167                                 remainingYears -= m_EraInfo[j].maxEraYear;
 168                             }
 169                         }
 170                     }
 171
 172                     if (throwOnError)
 173                     {
 174                         throw new ArgumentOutOfRangeException(
 175                                     nameof(year),
 176                                     SR.Format(
 177                                         SR.ArgumentOutOfRange_Range,
 178                                         m_EraInfo[i].minEraYear,
 179                                         m_EraInfo[i].maxEraYear));
 180                     }
 181
 182                     break; // no need to iterate more on eras.
 183                 }
 184             }
 185
 186             if (throwOnError)
 187             {
 188                 throw new ArgumentOutOfRangeException(nameof(era), SR.ArgumentOutOfRange_InvalidEraValue);
 189             }
 190             return -1;
 191         }
 192
 193         /*=================================GetGregorianYear==========================
 194         **Action: Get the Gregorian year value for the specified year in an era.
 195         **Returns: The Gregorian year value.
 196         **Arguments:
 197         **      year    the year value in Japanese calendar
 198         **      era     the Japanese emperor era value.
 199         **Exceptions:
 200         **      ArgumentOutOfRangeException if year value is invalid or era value is invalid.
 201         ============================================================================*/
 202
 203         internal int GetGregorianYear(int year, int era)
 204         {
 205             return GetYearOffset(year, era, throwOnError: true) + year;
 206         }
 207
 208         internal bool IsValidYear(int year, int era)
 209         {
 210             return GetYearOffset(year, era, throwOnError: false) >= 0;
 211         }
 212
 213         // Returns a given date part of this DateTime. This method is used
 214         // to compute the year, day-of-year, month, or day part.
 215         internal virtual int GetDatePart(long ticks, int part)
 216         {
 217             CheckTicksRange(ticks);
 218             // n = number of days since 1/1/0001
 219             int n = (int)(ticks / TicksPerDay);
 220             // y400 = number of whole 400-year periods since 1/1/0001
 221             int y400 = n / DaysPer400Years;
 222             // n = day number within 400-year period
 223             n -= y400 * DaysPer400Years;
 224             // y100 = number of whole 100-year periods within 400-year period
 225             int y100 = n / DaysPer100Years;
 226             // Last 100-year period has an extra day, so decrement result if 4
 227             if (y100 == 4) y100 = 3;
 228             // n = day number within 100-year period
 229             n -= y100 * DaysPer100Years;
 230             // y4 = number of whole 4-year periods within 100-year period
 231             int y4 = n / DaysPer4Years;
 232             // n = day number within 4-year period
 233             n -= y4 * DaysPer4Years;
 234             // y1 = number of whole years within 4-year period
 235             int y1 = n / DaysPerYear;
 236             // Last year has an extra day, so decrement result if 4
 237             if (y1 == 4) y1 = 3;
 238             // If year was requested, compute and return it
 239             if (part == DatePartYear)
 240             {
 241                 return (y400 * 400 + y100 * 100 + y4 * 4 + y1 + 1);
 242             }
 243             // n = day number within year
 244             n -= y1 * DaysPerYear;
 245             // If day-of-year was requested, return it
 246             if (part == DatePartDayOfYear)
 247             {
 248                 return (n + 1);
 249             }
 250             // Leap year calculation looks different from IsLeapYear since y1, y4,
 251             // and y100 are relative to year 1, not year 0
 252             bool leapYear = (y1 == 3 && (y4 != 24 || y100 == 3));
 253             int[] days = leapYear ? DaysToMonth366 : DaysToMonth365;
 254             // All months have less than 32 days, so n >> 5 is a good conservative
 255             // estimate for the month
 256             int m = (n >> 5) + 1;
 257             // m = 1-based month number
 258             while (n >= days[m]) m++;
 259             // If month was requested, return it
 260             if (part == DatePartMonth) return (m);
 261             // Return 1-based day-of-month
 262             return (n - days[m - 1] + 1);
 263         }
 264
 265         /*=================================GetAbsoluteDate==========================
 266         **Action: Gets the absolute date for the given Gregorian date.  The absolute date means
 267         **       the number of days from January 1st, 1 A.D.
 268         **Returns:  the absolute date
 269         **Arguments:
 270         **      year    the Gregorian year
 271         **      month   the Gregorian month
 272         **      day     the day
 273         **Exceptions:
 274         **      ArgumentOutOfRangException  if year, month, day value is valid.
 275         **Note:
 276         **      This is an internal method used by DateToTicks() and the calculations of Hijri and Hebrew calendars.
 277         **      Number of Days in Prior Years (both common and leap years) +
 278         **      Number of Days in Prior Months of Current Year +
 279         **      Number of Days in Current Month
 280         **
 281         ============================================================================*/
 282
 283         internal static long GetAbsoluteDate(int year, int month, int day)
 284         {
 285             if (year >= 1 && year <= 9999 && month >= 1 && month <= 12)
 286             {
 287                 int[] days = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))) ? DaysToMonth366 : DaysToMonth365;
 288                 if (day >= 1 && (day <= days[month] - days[month - 1]))
 289                 {
 290                     int y = year - 1;
 291                     int absoluteDate = y * 365 + y / 4 - y / 100 + y / 400 + days[month - 1] + day - 1;
 292                     return (absoluteDate);
 293                 }
 294             }
 295             throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadYearMonthDay);
 296         }
 297
 298         // Returns the tick count corresponding to the given year, month, and day.
 299         // Will check the if the parameters are valid.
 300         internal static long DateToTicks(int year, int month, int day)
 301         {
 302             return (GetAbsoluteDate(year, month, day) * TicksPerDay);
 303         }
 304
 305         // Return the tick count corresponding to the given hour, minute, second.
 306         // Will check the if the parameters are valid.
 307         internal static long TimeToTicks(int hour, int minute, int second, int millisecond)
 308         {
 309             // TimeSpan.TimeToTicks is a family access function which does no error checking, so
 310             // we need to put some error checking out here.
 311             if (hour >= 0 && hour < 24 && minute >= 0 && minute < 60 && second >= 0 && second < 60)
 312             {
 313                 if (millisecond < 0 || millisecond >= MillisPerSecond)
 314                 {
 315                     throw new ArgumentOutOfRangeException(
 316                                 nameof(millisecond),
 317                                 SR.Format(
 318                                     SR.ArgumentOutOfRange_Range,
 319                                     0,
 320                                     MillisPerSecond - 1));
 321                 }
 322                 return (InternalGlobalizationHelper.TimeToTicks(hour, minute, second) + millisecond * TicksPerMillisecond);
 323             }
 324             throw new ArgumentOutOfRangeException(null, SR.ArgumentOutOfRange_BadHourMinuteSecond);
 325         }
 326
 327
 328         internal void CheckTicksRange(long ticks)
 329         {
 330             if (ticks < m_Cal.MinSupportedDateTime.Ticks || ticks > m_Cal.MaxSupportedDateTime.Ticks)
 331             {
 332                 throw new ArgumentOutOfRangeException(
 333                             "time",
 334                             SR.Format(
 335                                 CultureInfo.InvariantCulture,
 336                                 SR.ArgumentOutOfRange_CalendarRange,
 337                                 m_Cal.MinSupportedDateTime,
 338                                 m_Cal.MaxSupportedDateTime));
 339             }
 340         }
 341
 342         // Returns the DateTime resulting from adding the given number of
 343         // months to the specified DateTime. The result is computed by incrementing
 344         // (or decrementing) the year and month parts of the specified DateTime by
 345         // value months, and, if required, adjusting the day part of the
 346         // resulting date downwards to the last day of the resulting month in the
 347         // resulting year. The time-of-day part of the result is the same as the
 348         // time-of-day part of the specified DateTime.
 349         //
 350         // In more precise terms, considering the specified DateTime to be of the
 351         // form y / m / d + t, where y is the
 352         // year, m is the month, d is the day, and t is the
 353         // time-of-day, the result is y1 / m1 / d1 + t,
 354         // where y1 and m1 are computed by adding value months
 355         // to y and m, and d1 is the largest value less than
 356         // or equal to d that denotes a valid day in month m1 of year
 357         // y1.
 358         //
 359         public DateTime AddMonths(DateTime time, int months)
 360         {
 361             if (months < -120000 || months > 120000)
 362             {
 363                 throw new ArgumentOutOfRangeException(
 364                             nameof(months),
 365                             SR.Format(
 366                                 SR.ArgumentOutOfRange_Range,
 367                                 -120000,
 368                                 120000));
 369             }
 370             CheckTicksRange(time.Ticks);
 371
 372             int y = GetDatePart(time.Ticks, DatePartYear);
 373             int m = GetDatePart(time.Ticks, DatePartMonth);
 374             int d = GetDatePart(time.Ticks, DatePartDay);
 375             int i = m - 1 + months;
 376             if (i >= 0)
 377             {
 378                 m = i % 12 + 1;
 379                 y += i / 12;
 380             }
 381             else
 382             {
 383                 m = 12 + (i + 1) % 12;
 384                 y += (i - 11) / 12;
 385             }
 386             int[] daysArray = (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)) ? DaysToMonth366 : DaysToMonth365;
 387             int days = (daysArray[m] - daysArray[m - 1]);
 388
 389             if (d > days)
 390             {
 391                 d = days;
 392             }
 393             long ticks = DateToTicks(y, m, d) + (time.Ticks % TicksPerDay);
 394             Calendar.CheckAddResult(ticks, m_Cal.MinSupportedDateTime, m_Cal.MaxSupportedDateTime);
 395             return (new DateTime(ticks));
 396         }
 397
 398         // Returns the DateTime resulting from adding the given number of
 399         // years to the specified DateTime. The result is computed by incrementing
 400         // (or decrementing) the year part of the specified DateTime by value
 401         // years. If the month and day of the specified DateTime is 2/29, and if the
 402         // resulting year is not a leap year, the month and day of the resulting
 403         // DateTime becomes 2/28. Otherwise, the month, day, and time-of-day
 404         // parts of the result are the same as those of the specified DateTime.
 405         //
 406         public DateTime AddYears(DateTime time, int years)
 407         {
 408             return (AddMonths(time, years * 12));
 409         }
 410
 411         // Returns the day-of-month part of the specified DateTime. The returned
 412         // value is an integer between 1 and 31.
 413         //
 414         public int GetDayOfMonth(DateTime time)
 415         {
 416             return (GetDatePart(time.Ticks, DatePartDay));
 417         }
 418
 419         // Returns the day-of-week part of the specified DateTime. The returned value
 420         // is an integer between 0 and 6, where 0 indicates Sunday, 1 indicates
 421         // Monday, 2 indicates Tuesday, 3 indicates Wednesday, 4 indicates
 422         // Thursday, 5 indicates Friday, and 6 indicates Saturday.
 423         //
 424         public DayOfWeek GetDayOfWeek(DateTime time)
 425         {
 426             CheckTicksRange(time.Ticks);
 427             return ((DayOfWeek)((time.Ticks / TicksPerDay + 1) % 7));
 428         }
 429
 430         // Returns the day-of-year part of the specified DateTime. The returned value
 431         // is an integer between 1 and 366.
 432         //
 433         public int GetDayOfYear(DateTime time)
 434         {
 435             return (GetDatePart(time.Ticks, DatePartDayOfYear));
 436         }
 437
 438         // Returns the number of days in the month given by the year and
 439         // month arguments.
 440         //
 441         public int GetDaysInMonth(int year, int month, int era)
 442         {
 443             //
 444             // Convert year/era value to Gregorain year value.
 445             //
 446             year = GetGregorianYear(year, era);
 447             if (month < 1 || month > 12)
 448             {
 449                 throw new ArgumentOutOfRangeException(nameof(month), SR.ArgumentOutOfRange_Month);
 450             }
 451             int[] days = ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? DaysToMonth366 : DaysToMonth365);
 452             return (days[month] - days[month - 1]);
 453         }
 454
 455         // Returns the number of days in the year given by the year argument for the current era.
 456         //
 457
 458         public int GetDaysInYear(int year, int era)
 459         {
 460             //
 461             // Convert year/era value to Gregorain year value.
 462             //
 463             year = GetGregorianYear(year, era);
 464             return ((year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 366 : 365);
 465         }
 466
 467         // Returns the era for the specified DateTime value.
 468         public int GetEra(DateTime time)
 469         {
 470             long ticks = time.Ticks;
 471             // The assumption here is that m_EraInfo is listed in reverse order.
 472             for (int i = 0; i < m_EraInfo.Length; i++)
 473             {
 474                 if (ticks >= m_EraInfo[i].ticks)
 475                 {
 476                     return (m_EraInfo[i].era);
 477                 }
 478             }
 479             throw new ArgumentOutOfRangeException(nameof(time), SR.ArgumentOutOfRange_Era);
 480         }
 481
 482
 483         public int[] Eras
 484         {
 485             get
 486             {
 487                 if (m_eras == null)
 488                 {
 489                     m_eras = new int[m_EraInfo.Length];
 490                     for (int i = 0; i < m_EraInfo.Length; i++)
 491                     {
 492                         m_eras[i] = m_EraInfo[i].era;
 493                     }
 494                 }
 495                 return ((int[])m_eras.Clone());
 496             }
 497         }
 498
 499         // Returns the month part of the specified DateTime. The returned value is an
 500         // integer between 1 and 12.
 501         //
 502         public int GetMonth(DateTime time)
 503         {
 504             return (GetDatePart(time.Ticks, DatePartMonth));
 505         }
 506
 507         // Returns the number of months in the specified year and era.
 508         public int GetMonthsInYear(int year, int era)
 509         {
 510             GetGregorianYear(year, era);
 511             return 12;
 512         }
 513
 514         // Returns the year part of the specified DateTime. The returned value is an
 515         // integer between 1 and 9999.
 516         //
 517         public int GetYear(DateTime time)
 518         {
 519             long ticks = time.Ticks;
 520             int year = GetDatePart(ticks, DatePartYear);
 521             for (int i = 0; i < m_EraInfo.Length; i++)
 522             {
 523                 if (ticks >= m_EraInfo[i].ticks)
 524                 {
 525                     return (year - m_EraInfo[i].yearOffset);
 526                 }
 527             }
 528             throw new ArgumentException(SR.Argument_NoEra);
 529         }
 530
 531         // Returns the year that match the specified Gregorian year. The returned value is an
 532         // integer between 1 and 9999.
 533         //
 534         public int GetYear(int year, DateTime time)
 535         {
 536             long ticks = time.Ticks;
 537             for (int i = 0; i < m_EraInfo.Length; i++)
 538             {
 539                 // while calculating dates with JapaneseLuniSolarCalendar, we can run into cases right after the start of the era
 540                 // and still belong to the month which is started in previous era. Calculating equivalent calendar date will cause
 541                 // using the new era info which will have the year offset equal to the year we are calculating year = m_EraInfo[i].yearOffset
 542                 // which will end up with zero as calendar year.
 543                 // We should use the previous era info instead to get the right year number. Example of such date is Feb 2nd 1989
 544                 if (ticks >= m_EraInfo[i].ticks && year > m_EraInfo[i].yearOffset)
 545                 {
 546                     return (year - m_EraInfo[i].yearOffset);
 547                 }
 548             }
 549             throw new ArgumentException(SR.Argument_NoEra);
 550         }
 551
 552         // Checks whether a given day in the specified era is a leap day. This method returns true if
 553         // the date is a leap day, or false if not.
 554         //
 555         public bool IsLeapDay(int year, int month, int day, int era)
 556         {
 557             // year/month/era checking is done in GetDaysInMonth()
 558             if (day < 1 || day > GetDaysInMonth(year, month, era))
 559             {
 560                 throw new ArgumentOutOfRangeException(
 561                             nameof(day),
 562                             SR.Format(
 563                                 SR.ArgumentOutOfRange_Range,
 564                                 1,
 565                                 GetDaysInMonth(year, month, era)));
 566             }
 567
 568             if (!IsLeapYear(year, era))
 569             {
 570                 return (false);
 571             }
 572
 573             if (month == 2 && day == 29)
 574             {
 575                 return (true);
 576             }
 577
 578             return (false);
 579         }
 580
 581         // Returns  the leap month in a calendar year of the specified era. This method returns 0
 582         // if this calendar does not have leap month, or this year is not a leap year.
 583         //
 584         public int GetLeapMonth(int year, int era)
 585         {
 586             GetGregorianYear(year, era);
 587             return 0;
 588         }
 589
 590         // Checks whether a given month in the specified era is a leap month. This method returns true if
 591         // month is a leap month, or false if not.
 592         //
 593         public bool IsLeapMonth(int year, int month, int era)
 594         {
 595             year = GetGregorianYear(year, era);
 596             if (month < 1 || month > 12)
 597             {
 598                 throw new ArgumentOutOfRangeException(
 599                             nameof(month),
 600                             SR.Format(
 601                                 SR.ArgumentOutOfRange_Range,
 602                                 1,
 603                                 12));
 604             }
 605             return (false);
 606         }
 607
 608         // Checks whether a given year in the specified era is a leap year. This method returns true if
 609         // year is a leap year, or false if not.
 610         //
 611         public bool IsLeapYear(int year, int era)
 612         {
 613             year = GetGregorianYear(year, era);
 614             return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
 615         }
 616
 617         // Returns the date and time converted to a DateTime value.  Throws an exception if the n-tuple is invalid.
 618         //
 619         public DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era)
 620         {
 621             year = GetGregorianYear(year, era);
 622             long ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second, millisecond);
 623             CheckTicksRange(ticks);
 624             return (new DateTime(ticks));
 625         }
 626
 627         public virtual int GetWeekOfYear(DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
 628         {
 629             CheckTicksRange(time.Ticks);
 630             // Use GregorianCalendar to get around the problem that the implmentation in Calendar.GetWeekOfYear()
 631             // can call GetYear() that exceeds the supported range of the Gregorian-based calendars.
 632             return (GregorianCalendar.GetDefaultInstance().GetWeekOfYear(time, rule, firstDayOfWeek));
 633         }
 634
 635
 636         public int ToFourDigitYear(int year, int twoDigitYearMax)
 637         {
 638             if (year < 0)
 639             {
 640                 throw new ArgumentOutOfRangeException(nameof(year),
 641                     SR.ArgumentOutOfRange_NeedPosNum);
 642             }
 643
 644             if (year < 100)
 645             {
 646                 int y = year % 100;
 647                 return ((twoDigitYearMax / 100 - (y > twoDigitYearMax % 100 ? 1 : 0)) * 100 + y);
 648             }
 649
 650             if (year < m_minYear || year > m_maxYear)
 651             {
 652                 throw new ArgumentOutOfRangeException(
 653                             nameof(year),
 654                             SR.Format(SR.ArgumentOutOfRange_Range, m_minYear, m_maxYear));
 655             }
 656             // If the year value is above 100, just return the year value.  Don't have to do
 657             // the TwoDigitYearMax comparison.
 658             return (year);
 659         }
 660     }
 661 }