class/corlib/System.Globalization/KoreanCalendar.cs

   1 // System.Globalization.KoreanCalendar.cs
   2 //
   3 // (C) Ulrich Kunitz 2002
   4 //
   5
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 namespace System.Globalization {
  30
  31 using System;
  32 using System.Runtime.InteropServices;
  33
  34 /// <summary>
  35 /// This is the Korean calendar. It differs from the Gegorian calendar only
  36 /// in the year counting.
  37 /// </summary>
  38 /// <remarks>
  39 /// <para>The implementation uses the
  40 /// <see cref="N:CalendricalCalculations"/> namespace.
  41 /// </para>
  42 /// </remarks>
  43 [Serializable]
  44 [ComVisible (true)]
  45 [MonoLimitation ("Serialization format not compatible with .NET")]
  46 public class KoreanCalendar : Calendar {
  47         /// <summary>
  48         /// Static protected field storing the
  49         /// <see cref="T:CalendricalCalculations.GregorianEraHandler"/>.
  50         /// </summary>
  51         internal static readonly CCGregorianEraHandler M_EraHandler;
  52
  53         /// <variable>
  54         /// The standard era for the <see cref="T:KoreanCalendar"/>.
  55         /// </variable>
  56         public const int KoreanEra = 1;
  57
  58         /// <summary>
  59         /// Static constructor, who creates and initializes
  60         /// <see cref="F:M_EraHandler"/>.
  61         /// </summary>
  62         static KoreanCalendar() {
  63                 M_EraHandler = new CCGregorianEraHandler();
  64                 M_EraHandler.appendEra(KoreanEra,
  65                         CCGregorianCalendar.fixed_from_dmy(1, 1, -2332));
  66         }
  67
  68         /// <summary>
  69         /// Default constructor.
  70         /// </summary>
  71         public KoreanCalendar() {
  72                 M_AbbrEraNames = new string[] {"K.C.E."};
  73                 M_EraNames = new string[] {"Korean Current Era"};
  74                 if (twoDigitYearMax == 99)
  75                         twoDigitYearMax = 4362;
  76         }
  77
  78         /// <value>Overridden. Gives the eras supported by the
  79         /// calendar as an array of integers.
  80         /// </value>
  81         public override int[] Eras {
  82                 get {
  83                         return (int[])M_EraHandler.Eras.Clone();
  84                 }
  85         }
  86
  87         public override int TwoDigitYearMax
  88         {
  89                 get {
  90                         return twoDigitYearMax;
  91                 }
  92                 set {
  93                         CheckReadOnly ();
  94                         M_ArgumentInRange ("value", value, 100, M_MaxYear);
  95
  96                         twoDigitYearMax = value;
  97                 }
  98         }
  99
 100         /// <summary>
 101         /// A protected method checking the era number.
 102         /// </summary>
 103         /// <param name="era">The era number as reference. It is set
 104         /// to <see cref="F:CurrentEra"/>, if the input value is 0.</param>
 105         /// <exception name="T:System.ArgumentException">
 106         /// The exception is thrown if the era is not supported by the class.
 107         /// </exception>
 108         internal void M_CheckEra(ref int era) {
 109                 if (era == CurrentEra)
 110                         era = KoreanEra;
 111                 if (!M_EraHandler.ValidEra(era))
 112                         throw new ArgumentException("Era value was not valid.");
 113         }
 114
 115         /// <summary>
 116         /// A protected method checking calendar year and the era number.
 117         /// </summary>
 118         /// <param name="year">An integer representing the calendar year.
 119         /// </param>
 120         /// <param name="era">The era number as reference.</param>
 121         /// <exception name="T:System.ArgumentException">
 122         /// The exception is thrown if the era is not supported by the class.
 123         /// </exception>
 124         /// <exception cref="T:System.ArgumentOutOfRangeException">
 125         /// The exception is thrown if the calendar year is outside of
 126         /// the supported range.
 127         /// </exception>
 128         internal int M_CheckYEG(int year, ref int era) {
 129                 M_CheckEra(ref era);
 130                 return M_EraHandler.GregorianYear(year, era);
 131         }
 132
 133         /// <summary>
 134         /// Checks whether the year is the era is valid, if era = CurrentEra
 135         /// the right value is set.
 136         /// </summary>
 137         /// <param name="year">The year to check.</param>
 138         /// <param name="era">The era to check.</Param>
 139         /// <exception cref="T:ArgumentOutOfRangeException">
 140         /// The exception will be thrown, if the year is not valid.
 141         /// </exception>
 142         internal override void M_CheckYE(int year, ref int era) {
 143                 M_CheckYEG(year, ref era);
 144         }
 145
 146         /// <summary>
 147         /// A protected method checking the calendar year, month, and
 148         /// era number.
 149         /// </summary>
 150         /// <param name="year">An integer representing the calendar year.
 151         /// </param>
 152         /// <param name="month">An integer giving the calendar month.
 153         /// </param>
 154         /// <param name="era">The era number as reference.</param>
 155         /// <exception name="T:System.ArgumentException">
 156         /// The exception is thrown if the era is not supported by the class.
 157         /// </exception>
 158         /// <exception cref="T:System.ArgumentOutOfRangeException">
 159         /// The exception is thrown if the calendar year or month is
 160         /// outside of the supported range.
 161         /// </exception>
 162         internal int M_CheckYMEG(int year, int month, ref int era) {
 163                 int gregorianYear = M_CheckYEG(year, ref era);
 164                 if (month < 1 || month > 12)
 165                         throw new ArgumentOutOfRangeException("month",
 166                                 "Month must be between one and twelve.");
 167                 return gregorianYear;
 168         }
 169
 170         /// <summary>
 171         /// A protected method checking the calendar day, month, and year
 172         /// and the era number.
 173         /// </summary>
 174         /// <param name="year">An integer representing the calendar year.
 175         /// </param>
 176         /// <param name="month">An integer giving the calendar month.
 177         /// </param>
 178         /// <param name="day">An integer giving the calendar day.
 179         /// </param>
 180         /// <param name="era">The era number as reference.</param>
 181         /// <exception name="T:System.ArgumentException">
 182         /// The exception is thrown if the era is not supported by the class.
 183         /// </exception>
 184         /// <exception cref="T:System.ArgumentOutOfRangeException">
 185         /// The exception is thrown if the calendar year, month, or day is
 186         /// outside of the supported range.
 187         /// </exception>
 188         internal int M_CheckYMDEG(int year, int month, int day, ref int era)
 189         {
 190                 int gregorianYear = M_CheckYMEG(year, month, ref era);
 191                 M_ArgumentInRange("day", day, 1,
 192                         GetDaysInMonth(year, month, era));
 193                 return gregorianYear;
 194         }
 195
 196         /// <summary>
 197         /// Overrideden. Adds months to a given date.
 198         /// </summary>
 199         /// <param name="time">The
 200         /// <see cref="T:System.DateTime"/> to which to add
 201         /// months.
 202         /// </param>
 203         /// <param name="months">The number of months to add.</param>
 204         /// <returns>A new <see cref="T:System.DateTime"/> value, that
 205         /// results from adding <paramref name="months"/> to the specified
 206         /// DateTime.</returns>
 207         public override DateTime AddMonths(DateTime time, int months) {
 208                 return CCGregorianCalendar.AddMonths(time, months);
 209         }
 210
 211         /// <summary>
 212         /// Overridden. Adds years to a given date.
 213         /// </summary>
 214         /// <param name="time">The
 215         /// <see cref="T:System.DateTime"/> to which to add
 216         /// years.
 217         /// </param>
 218         /// <param name="years">The number of years to add.</param>
 219         /// <returns>A new <see cref="T:System.DateTime"/> value, that
 220         /// results from adding <paramref name="years"/> to the specified
 221         /// DateTime.</returns>
 222         public override DateTime AddYears(DateTime time, int years) {
 223                 return CCGregorianCalendar.AddYears(time, years);
 224         }
 225
 226         /// <summary>
 227         /// Overriden. Gets the day of the month from
 228         /// <paramref name="time"/>.
 229         /// </summary>
 230         /// <param name="time">The
 231         /// <see cref="T:System.DateTime"/> that specifies a
 232         /// date.
 233         /// </param>
 234         /// <returns>An integer giving the day of months, starting with 1.
 235         /// </returns>
 236         public override int GetDayOfMonth(DateTime time) {
 237                 return CCGregorianCalendar.GetDayOfMonth(time);
 238         }
 239
 240         /// <summary>
 241         /// Overriden. Gets the day of the week from the specified date.
 242         /// </summary>
 243         /// <param name="time">The
 244         /// <see cref="T:System.DateTime"/> that specifies a
 245         /// date.
 246         /// </param>
 247         /// <returns>An integer giving the day of months, starting with 1.
 248         /// </returns>
 249         public override DayOfWeek GetDayOfWeek(DateTime time) {
 250                 int rd = CCFixed.FromDateTime(time);
 251                 return (DayOfWeek)CCFixed.day_of_week(rd);
 252         }
 253
 254         /// <summary>
 255         /// Overridden. Gives the number of the day in the year.
 256         /// </summary>
 257         /// <param name="time">The
 258         /// <see cref="T:System.DateTime"/> that specifies a
 259         /// date.
 260         /// </param>
 261         /// <returns>An integer representing the day of the year,
 262         /// starting with 1.</returns>
 263         public override int GetDayOfYear(DateTime time) {
 264                 return CCGregorianCalendar.GetDayOfYear(time);
 265         }
 266
 267         /// <summary>
 268         /// Overridden. Gives the number of days in the specified month
 269         /// of the given year and era.
 270         /// </summary>
 271         /// <param name="year">An integer that gives the year.
 272         /// </param>
 273         /// <param name="month">An integer that gives the month, starting
 274         /// with 1.</param>
 275         /// <param name="era">An integer that gives the era of the specified
 276         /// year.</param>
 277         /// <returns>An integer that gives the number of days of the
 278         /// specified month.</returns>
 279         /// <exception cref="T:System.ArgumentOutOfRangeException">
 280         /// The exception is thrown, if <paramref name="month"/>,
 281         /// <paramref name="year"/> ,or <paramref name="era"/> is outside
 282         /// the allowed range.
 283         /// </exception>
 284         public override int GetDaysInMonth(int year, int month, int era) {
 285                 int gregorianYear = M_CheckYMEG(year, month, ref era);
 286                 return CCGregorianCalendar.GetDaysInMonth(gregorianYear, month);
 287         }
 288
 289         /// <summary>
 290         /// Overridden. Gives the number of days of the specified
 291         /// year of the given era.
 292         /// </summary>
 293         /// <param name="year">An integer that specifies the year.
 294         /// </param>
 295         /// <param name="era">An ineger that specifies the era.
 296         /// </param>
 297         /// <returns>An integer that gives the number of days of the
 298         /// specified year.</returns>
 299         /// <exception cref="T:System.ArgumentOutOfRangeExceiption">
 300         /// The exception is thrown, if
 301         /// <paramref name="year"/> or <paramref name="era"/> are outside the
 302         /// allowed range.
 303         /// </exception>
 304         public override int GetDaysInYear(int year, int era) {
 305                 int gregorianYear = M_CheckYEG(year, ref era);
 306                 return CCGregorianCalendar.GetDaysInYear(gregorianYear);
 307         }
 308
 309         /// <summary>
 310         /// Overridden. Gives the era of the specified date.
 311         /// </summary>
 312         /// <param name="time">The
 313         /// <see cref="T:System.DateTime"/> that specifies a
 314         /// date.
 315         /// </param>
 316         /// <returns>An integer representing the era of the calendar.
 317         /// </returns>
 318         public override int GetEra(DateTime time) {
 319                 int rd = CCFixed.FromDateTime(time);
 320                 int era;
 321                 M_EraHandler.EraYear(out era, rd);
 322                 return era;
 323         }
 324
 325         [ComVisible (false)]
 326         public override int GetLeapMonth (int year, int era)
 327         {
 328                 return 0;
 329         }
 330
 331         /// <summary>
 332         /// Overridden. Gives the number of the month of the specified
 333         /// date.
 334         /// </summary>
 335         /// <param name="time">The
 336         /// <see cref="T:System.DateTime"/> that specifies a
 337         /// date.
 338         /// </param>
 339         /// <returns>An integer representing the month,
 340         /// starting with 1.</returns>
 341         public override int GetMonth(DateTime time) {
 342                 return CCGregorianCalendar.GetMonth(time);
 343         }
 344
 345         /// <summary>
 346         /// Overridden. Gives the number of months in the specified year
 347         /// and era.
 348         /// </summary>
 349         /// <param name="year">An integer that specifies the year.
 350         /// </param>
 351         /// <param name="era">An integer that specifies the era.
 352         /// </param>
 353         /// <returns>An integer that gives the number of the months in the
 354         /// specified year.</returns>
 355         /// <exception cref="T:System.ArgumentOutOfRangeException">
 356         /// The exception is thrown, if the year or the era are not valid.
 357         /// </exception>
 358         public override int GetMonthsInYear(int year, int era) {
 359                 M_CheckYEG(year, ref era);
 360                 return 12;
 361         }
 362
 363         [ComVisible (false)]
 364         public override int GetWeekOfYear (DateTime time, CalendarWeekRule rule, DayOfWeek firstDayOfWeek)
 365         {
 366                 return base.GetWeekOfYear (time, rule, firstDayOfWeek);
 367         }
 368
 369         /// <summary>
 370         /// Overridden. Gives the number of the year of the specified
 371         /// date.
 372         /// </summary>
 373         /// <param name="time">The
 374         /// <see cref="T:System.DateTime"/> that specifies a
 375         /// date.
 376         /// </param>
 377         /// <returns>An integer representing the year,
 378         /// starting with 1.</returns>
 379         public override int GetYear(DateTime time) {
 380                 int rd = CCFixed.FromDateTime(time);
 381                 int era;
 382                 return M_EraHandler.EraYear(out era, rd);
 383         }
 384
 385         /// <summary>
 386         /// Overridden. Tells whether the given day
 387         /// is a leap day.
 388         /// </summary>
 389         /// <param name="year">An integer that specifies the year in the
 390         /// given era.
 391         /// </param>
 392         /// <param name="month">An integer that specifies the month.
 393         /// </param>
 394         /// <param name="day">An integer that specifies the day.
 395         /// </param>
 396         /// <param name="era">An integer that specifies the era.
 397         /// </param>
 398         /// <returns>A boolean that tells whether the given day is a leap
 399         /// day.
 400         /// </returns>
 401         /// <exception cref="T:System.ArgumentOutOfRangeException">
 402         /// The exception is thrown, if the year, month, day, or era is not
 403         /// valid.
 404         /// </exception>
 405         public override bool IsLeapDay(int year, int month, int day, int era)
 406         {
 407                 int gregorianYear = M_CheckYMDEG(year, month, day, ref era);
 408                 return CCGregorianCalendar.IsLeapDay(gregorianYear, month, day);
 409         }
 410
 411         /// <summary>
 412         /// Overridden. Tells whether the given month
 413         /// is a leap month.
 414         /// </summary>
 415         /// <param name="year">An integer that specifies the year in the
 416         /// given era.
 417         /// </param>
 418         /// <param name="month">An integer that specifies the month.
 419         /// </param>
 420         /// <param name="era">An integer that specifies the era.
 421         /// </param>
 422         /// <returns>A boolean that tells whether the given month is a leap
 423         /// month.
 424         /// </returns>
 425         /// <exception cref="T:System.ArgumentOutOfRangeException">
 426         /// The exception is thrown, if the year, month, or era is not
 427         /// valid.
 428         /// </exception>
 429         public override bool IsLeapMonth(int year, int month, int era) {
 430                 M_CheckYMEG(year, month, ref era);
 431                 return false;
 432         }
 433
 434         /// <summary>
 435         /// Overridden. Tells whether the given year
 436         /// is a leap year.
 437         /// </summary>
 438         /// <param name="year">An integer that specifies the year in the
 439         /// given era.
 440         /// </param>
 441         /// <param name="era">An integer that specifies the era.
 442         /// </param>
 443         /// <returns>A boolean that tells whether the given year is a leap
 444         /// year.
 445         /// </returns>
 446         /// <exception cref="T:System.ArgumentOutOfRangeException">
 447         /// The exception is thrown, if the year or era is not
 448         /// valid.
 449         /// </exception>
 450         public override bool IsLeapYear(int year, int era) {
 451                 int gregorianYear = M_CheckYEG(year, ref era);
 452                 return CCGregorianCalendar.is_leap_year(gregorianYear);
 453         }
 454
 455         /// <summary>
 456         /// Overridden. Creates the
 457         /// <see cref="T:System.DateTime"/> from the parameters.
 458         /// </summary>
 459         /// <param name="year">An integer that gives the year in the
 460         /// <paramref name="era"/>.
 461         /// </param>
 462         /// <param name="month">An integer that specifies the month.
 463         /// </param>
 464         /// <param name="day">An integer that specifies the day.
 465         /// </param>
 466         /// <param name="hour">An integer that specifies the hour.
 467         /// </param>
 468         /// <param name="minute">An integer that specifies the minute.
 469         /// </param>
 470         /// <param name="second">An integer that gives the second.
 471         /// </param>
 472         /// <param name="milliseconds">An integer that gives the
 473         /// milliseconds.
 474         /// </param>
 475         /// <param name="era">An integer that specifies the era.
 476         /// </param>
 477         /// <returns>A
 478         /// <see cref="T:system.DateTime"/> representig the date and time.
 479         /// </returns>
 480         /// <exception cref="T:System.ArgumentOutOfRangeException">
 481         /// The exception is thrown, if at least one of the parameters
 482         /// is out of range.
 483         /// </exception>
 484         public override DateTime ToDateTime(int year, int month, int day,
 485                 int hour, int minute, int second, int millisecond,
 486                 int era)
 487         {
 488                 int gregorianYear = M_CheckYMDEG(year, month, day, ref era);
 489                 M_CheckHMSM(hour, minute, second, millisecond);
 490                 return CCGregorianCalendar.ToDateTime(gregorianYear,
 491                         month, day, hour, minute, second, millisecond);
 492         }
 493
 494         public override int ToFourDigitYear(int year)
 495         {
 496                 return base.ToFourDigitYear (year);
 497         }
 498
 499 #if !NET_2_1
 500         [ComVisible (false)]
 501         public override CalendarAlgorithmType AlgorithmType {
 502                 get {
 503                         return CalendarAlgorithmType.SolarCalendar;
 504                 }
 505         }
 506 #endif
 507
 508         static DateTime KoreanMin = new DateTime (1, 1, 1, 0, 0, 0);
 509         static DateTime KoreanMax = new DateTime (9999, 12, 31, 11, 59, 59);
 510
 511         [ComVisible (false)]
 512         public override DateTime MinSupportedDateTime {
 513                 get {
 514                         return KoreanMin;
 515                 }
 516         }
 517
 518         [ComVisible (false)]
 519         public override DateTime MaxSupportedDateTime {
 520                 get {
 521                         return KoreanMax;
 522                 }
 523         }
 524
 525 } // class KoreanCalendar
 526
 527 } // namespace System.Globalization