Ejemplo n.º 1
0
 public UDNRecord(UDN udn, UDNCalendarType calendar, string description)
 {
     Calendar    = calendar;
     Description = description;
     Value       = udn;
     StrVal      = Value.ToString();
 }
Ejemplo n.º 2
0
 public UDNRecord(UDNCalendarType calendar, int year, int month, int day, string description)
 {
     Calendar    = calendar;
     Description = description;
     Value       = new UDN(calendar, year, month, day);
     StrVal      = Value.ToString();
 }
Ejemplo n.º 3
0
 public date(UDNCalendarType calendar, int year, int month, int day)
 {
     Calendar = calendar;
     Year     = year;
     Month    = month;
     Day      = day;
 }
Ejemplo n.º 4
0
        protected override void DateChanged()
        {
            int year = fYear;

            if (year == UNKNOWN_YEAR)
            {
                year = UDN.UnknownYear;
            }
            else
            {
                if (fYearBC)
                {
                    year = -year;
                }
            }

            UDNCalendarType udnCalendar = UDNCalendars[(int)fCalendar];

            fUDN = new UDN(udnCalendar, year, fMonth, fDay);
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Public constructor.
 /// </summary>
 /// <param name="calendar"></param>
 /// <param name="year"></param>
 /// <param name="month"></param>
 /// <param name="day"></param>
 public UDN(UDNCalendarType calendar, int year, int month, int day)
 {
     fValue = CreateVal(calendar, year, month, day);
 }
Ejemplo n.º 6
0
 /// <summary>
 /// Creates a new UDN instance that represents a date near the specified date in the specified
 /// <paramref name="calendar"/>.</summary>
 /// <param name="calendar">Source calendar. The <paramref name="year"/>, <paramref name="month"/> and
 /// <paramref name="day"/> are in this calendar.</param>
 /// <param name="year">Year number. Pass `UnknownYear` constant when year is unknown.
 /// This method DOES NOT check that `year` is inside a valid range. It's duty of a caller.</param>
 /// <param name="month">Month number. Pass `UnknownMonth` constant when month is unknown.
 /// This method DOES NOT check that `month` is inside a valid range. It's duty of a caller.</param>
 /// <param name="day">Day number. Pass `UnknownDay` constant when day is unknown.
 /// This method DOES NOT check that `day` is inside a valid range. It's duty of a caller.</param>
 /// <returns>UDN object representing a date near the specified one.</returns>
 public static UDN CreateApproximate(UDNCalendarType calendar, int year, int month, int day)
 {
     return(new UDN(CreateVal(calendar, year, month, day) | ApproximateDate));
 }
Ejemplo n.º 7
0
 /// <summary>
 /// Creates a new UDN instance that represents a date after the specified date in the specified
 /// <paramref name="calendar"/>.</summary>
 /// <param name="calendar">Source calendar. The <paramref name="year"/>, <paramref name="month"/> and
 /// <paramref name="day"/> are in this calendar.</param>
 /// <param name="year">Year number. Pass `UnknownYear` constant when year is unknown.
 /// This method DOES NOT check that `year` is inside a valid range. It's duty of a caller.</param>
 /// <param name="month">Month number. Pass `UnknownMonth` constant when month is unknown.
 /// This method DOES NOT check that `month` is inside a valid range. It's duty of a caller.</param>
 /// <param name="day">Day number. Pass `UnknownDay` constant when day is unknown.
 /// This method DOES NOT check that `day` is inside a valid range. It's duty of a caller.</param>
 /// <returns>UDN object representing a date after the specified one.</returns>
 public static UDN CreateAfter(UDNCalendarType calendar, int year, int month, int day)
 {
     return(new UDN(CreateVal(calendar, year, month, day) | DateAfter));
 }
Ejemplo n.º 8
0
        /// <summary>
        /// Calculates Julian day nubmer (JDN, https://en.wikipedia.org/wiki/Julian_day) using the specified date in
        /// the specified <paramref name="calendar"/>.
        /// Return value of this method ain't a usual JDN. See Returns section for more information.
        /// </summary>
        /// <param name="calendar">Source calendar. The <paramref name="year"/>, <paramref name="month"/> and
        /// <paramref name="day"/> are in this calendar.</param>
        /// <param name="year">Year number. Pass `UnknownYear` constant when year is unknown.
        /// This method DOES NOT check that `year` is inside a valid range. It's duty of a caller.</param>
        /// <param name="month">Month number. Pass `UnknownMonth` constant when month is unknown.
        /// This method DOES NOT check that `month` is inside a valid range. It's duty of a caller.</param>
        /// <param name="day">Day number. Pass `UnknownDay` constant when day is unknown.
        /// This method DOES NOT check that `day` is inside a valid range. It's duty of a caller.</param>
        /// <returns>Masked Julian day nubmer. See description of the <see cref="fValue"/> member for detailed
        /// information about masked JDN value.
        ///
        /// This method doesn't change the 27th and 28th bit ("date before" and "date after").
        /// </returns>
        private static int CreateVal(UDNCalendarType calendar, int year, int month, int day)
        {
            int result = 0;

            /*
             * @ruslangaripov:
             *
             * The next conversation assume that `UnknownYear` member is 0.
             *
             * If all the `CalendarConverter::{calendar type}_to_jd` functions guarantee valid JDN for 0th year, we can
             * safely use the following code:
             *
             * int uYear = year;
             *
             * But if at least one of `CalendarConverter::{calendar type}_to_jd` functions fails on 0th year (read:
             * gives incorrect JDN) we HAVE TO use code like this:
             *
             * int uYear = (UnknownYear != year) ? year : 1;
             *
             * Here `1` is the first valid year for an algorithm that calculates JDN. I believe any such calculation
             * succeeds doing such calculation with 1st year.
             *
             * Wikipedia says that "For the year (Y) astronomical year numbering is used", and therefore I currently
             * stick with "0th year always valid for calculation JDN". And therefore, a
             * `CalendarConverter::{calendar type}_to_jd` succeeds with `UnknownYear`:
             *
             * int result = (int) (CalendarConverter::{calendar type}_to_jd(UnknownYear, uMonth, uDay));
             *
             * `result` after the code from above is a valid JDN.
             */
            int uYear  = year;
            int uMonth = Math.Max(UnknownMonth + 1, month);
            int uDay   = Math.Max(UnknownDay + 1, day);

            switch (calendar)
            {
            case UDNCalendarType.ctGregorian:
                result = CalendarConverter.gregorian_to_jd2(uYear, uMonth, uDay);     // fixed
                break;

            case UDNCalendarType.ctJulian:
                result = CalendarConverter.julian_to_jd2(uYear, uMonth, uDay);     // fixed
                break;

            case UDNCalendarType.ctHebrew:
                result = CalendarConverter.hebrew_to_jd3(uYear, uMonth, uDay);     // fixed to the 3rd variant
                break;

            case UDNCalendarType.ctIslamic:
                result = CalendarConverter.islamic_to_jd3(uYear, uMonth, uDay);     // fixed to the 3rd variant
                break;
            }

            if (UnknownYear == year)
            {
                result |= IgnoreYear;
            }
            if (UnknownMonth + 1 > month)
            {
                result |= IgnoreMonth;
            }
            if (UnknownDay + 1 > day)
            {
                result |= IgnoreDay;
            }

            return(result);
        }