mcs/class/corlib/System.Globalization/JulianCalendar.cs

   1 // ::MONO
   2 //
   3 // System.Globalization.JulianCalendar.cs
   4 //
   5 // Copyright (C) Wictor Wilén 2001 (wictor@iBizkit.se)
   6 //
   7 // Contributors:
   8 //
   9 // Revisions
  10 // 2001-09-14:  First draft
  11 // 2001-09-15:  First release
  12 //
  13 //
  14 // TODO: testing
  15 //
  16 //
  17
  18 using System;
  19
  20 namespace System.Globalization
  21 {
  22
  23
  24         /// <summary>
  25         /// Summary description for JulianCalendar.
  26         /// </summary>
  27         public class JulianCalendar : System.Globalization.Calendar
  28         {
  29
  30
  31                 // Public Static (Shared) Fields
  32                 // DONE!
  33                 public static int JulianEra
  34                 {
  35                         get
  36                         {
  37                                 return 1;
  38                         }
  39                 }
  40
  41                 // Public Instance Constructors
  42                 // DONE!
  43                 public JulianCalendar()
  44                 {
  45                 }
  46
  47                 // Public Instance Properties
  48                 // DONE!
  49                 public override int[] Eras
  50                 {
  51                         get
  52                         {
  53                                 return new int[] {1};
  54                         }
  55                 }
  56                 // DONE!
  57                 public override int TwoDigitYearMax
  58                 {
  59                         get
  60                         {
  61                                 return _TwoDigitYearMax;
  62                         }
  63                         set
  64                         {
  65                                 _TwoDigitYearMax = value;
  66                         }
  67                 }
  68
  69                 // Public Instance Methods
  70                 // DONE!
  71                 public override DateTime AddMonths ( DateTime time, int months )
  72                 {
  73                         if(months < -120000 || months > 120000)
  74                                 throw new System.ArgumentOutOfRangeException();
  75                         DateTime dt = new DateTime(time.Ticks);
  76                         dt =  dt.AddMonths(months);
  77                         return dt;
  78
  79                 }
  80                 // DONE!
  81                 public override DateTime AddYears ( DateTime time, int years )
  82                 {
  83                         DateTime dt = new DateTime(time.Ticks);
  84                         return dt.AddYears(years);
  85                 }
  86
  87                 // DONE!
  88                 public override int GetDayOfMonth ( DateTime time )
  89                 {
  90                         return time.Day;
  91                 }
  92
  93                 // DONE!
  94                 public override DayOfWeek GetDayOfWeek ( DateTime time )
  95                 {
  96                         return time.DayOfWeek;
  97                 }
  98
  99                 // DONE!
 100                 public override int GetDayOfYear ( DateTime time )
 101                 {
 102                         return time.DayOfYear;
 103                 }
 104
 105                 // DONE!
 106                 public override int GetDaysInMonth ( int year, int month, int era )
 107                 {
 108                         if(     year < _MinYear || year > _MaxYear ||
 109                                 month < _MinMonth || month > _MaxMonth ||
 110                                 era != JulianEra)
 111                                 throw new System.ArgumentOutOfRangeException();
 112
 113                         if(this.IsLeapYear(year))
 114                                 return _DaysInMonthLeap[month];
 115                         else
 116                                 return _DaysInMonth[month];
 117                 }
 118
 119
 120                 // DONE!
 121                 public override int GetDaysInYear ( int year, int era )
 122                 {
 123                         if(year < _MinYear || year > _MaxYear || era != JulianEra)
 124                                 throw new System.ArgumentOutOfRangeException();
 125                         return this.GetDaysInYear(year);
 126                 }
 127
 128                 // DONE!
 129                 public override int GetEra ( DateTime time )
 130                 {
 131                         return JulianEra;
 132                 }
 133                 // DONE!
 134                 public override int GetMonth ( DateTime time )
 135                 {
 136                         return time.Month;
 137                 }
 138
 139                 // DONE!
 140                 public override int GetMonthsInYear ( int year, int era )
 141                 {
 142                         if(year < _MinYear || year > _MaxYear || era != JulianEra)
 143                                 throw new System.ArgumentOutOfRangeException();
 144                         return _MaxMonth;
 145                 }
 146
 147                 // DONE!
 148                 public override int GetYear ( DateTime time )
 149                 {
 150                         return time.Year;
 151                 }
 152
 153                 // DONE!
 154                 public override bool IsLeapDay ( int year, int month, int day, int era )
 155                 {
 156                         int dim;
 157
 158                         if(day < _MinDay || month < _MinMonth || month > _MaxMonth)
 159                                 throw new System.ArgumentOutOfRangeException();
 160
 161                         if(this.IsLeapYear(year,era))
 162                                 dim = _DaysInMonthLeap[month-1];
 163                         else
 164                                 dim = _DaysInMonth[month-1];
 165
 166                         if( day > dim)
 167                                 throw new System.ArgumentOutOfRangeException();
 168
 169                         if( month == 2 && day == 29)
 170                                 return true;
 171
 172                         return false;
 173                 }
 174                 // DONE!
 175                 public override bool IsLeapMonth ( int year, int month )
 176                 {
 177                         if( year < _MinYear || year > _MaxYear || month < _MinMonth || month > _MaxMonth)
 178                                 throw new System.ArgumentException();
 179                         return false;
 180                 }
 181                 // DONE!
 182                 public override bool IsLeapMonth ( int year, int month, int era )
 183                 {
 184                         if( year < _MinYear || year > _MaxYear || month < _MinMonth || month > _MaxMonth || era != JulianEra)
 185                                 throw new System.ArgumentException();
 186                         return false;
 187                 }
 188
 189                 // DONE!
 190                 public override bool IsLeapYear ( int year, int era )
 191                 {
 192                         if(year < _MinYear || year > _MaxYear || era != JulianEra)
 193                                 throw new System.ArgumentOutOfRangeException();
 194                         if(year % 4 == 0)
 195                                 return true;
 196                         return false;
 197                 }
 198
 199                 // DONE!
 200                 public override DateTime ToDateTime ( int year, int month, int day, int hour, int minute, int second, int millisecond, int era )
 201                 {
 202                         // INFO: year, era and month is checked by GetDaysInMonth()
 203                         int dim;
 204                         dim = GetDaysInMonth(year,month);
 205                         if( day < _MinDay || day > dim ||
 206                                 hour < _MinHour || hour > _MaxHour ||
 207                                 minute < _MinMinute || minute > _MaxMinute ||
 208                                 second < _MinSecond || second > _MaxSecond ||
 209                                 millisecond < _MinMillisecond || millisecond > _MaxMillisecond)
 210                                 throw new System.ArgumentOutOfRangeException();
 211
 212                         return new DateTime(year,month,day,hour,minute,second,millisecond,this);
 213                 }
 214
 215                 // DONE!
 216                 public override int ToFourDigitYear ( int year )
 217                 {
 218                         int y = _TwoDigitYearMax % 100;
 219                         if( year > y )
 220                                 y = _TwoDigitYearMax - y - 100 + year;
 221                         else
 222                                 y = _TwoDigitYearMax - y + year;
 223
 224                         if( y < _MinYear || y > _MaxYear)
 225                                 throw new System.ArgumentException();
 226                         return y;
 227                 }
 228
 229         }
 230 }