Changeset 3099

Timestamp:

01/15/08 20:19:00 (10 months ago)

Author:

schveiguy

Message:

Fixed bug in getDayOfWeek in Gregorian
Added addMonths and addYears to Calendar/Gregorian. Fixes #825

Files:

• trunk/tango/time/chrono/Calendar.d (modified) (1 diff)
• trunk/tango/time/chrono/Gregorian.d (modified) (4 diffs)

trunk/tango/time/chrono/Calendar.d

@@ -346 +346 @@
-        }
-
+        /**
+         * Returns a new Time with the specified number of months added.  If
+         * the months are negative, the months are subtracted.
+         *
+         * The default implementation uses information provided by the
+         * calendar to calculate the correct time to add.  Derived classes may
+         * override if there is a more optimized method.
+         *
+         * Note that the generic method does not take into account crossing
+         * era boundaries.  Derived classes may support this.
+         *
+         * Params: t = A time to add the months to
+         * Params: nMonths = The number of months to add.  This can be
+         * negative.
+         *
+         * Returns: A Time that represents the provided time with the number
+         * of months added.
+         */
+        Time addMonths(Time t, int nMonths)
+        {
+                uint era = getEra(t);
+                uint year = getYear(t);
+                uint month = getMonth(t);
+
+                //
+                // Assume we go back to day 1 of the current year, taking
+                // into account that offset using the nMonths and nDays
+                // offsets.
+                //
+                nMonths += month - 1;
+                long nDays = cast(int)getDayOfMonth(t) - cast(int)getDayOfYear(t);
+                if(nMonths > 0)
+                {
+                        //
+                        // Adding, add all the years until the year we want to
+                        // be in.
+                        //
+                        auto miy = getMonthsInYear(year, era);
+                        while(nMonths >= miy)
+                        {
+                                //
+                                // skip a whole year
+                                //
+                                nDays += getDaysInYear(year, era);
+                                nMonths -= miy;
+                                year++;
+
+                                //
+                                // update miy
+                                //
+                                miy = getMonthsInYear(year, era);
+                        }
+                }
+                else if(nMonths < 0)
+                {
+                        //
+                        // subtracting months
+                        //
+                        while(nMonths < 0)
+                        {
+                                auto miy = getMonthsInYear(--year, era);
+                                nDays -= getDaysInYear(year, era);
+                                nMonths += miy;
+                        }
+                }
+
+                //
+                // we now are offset to the resulting year.
+                // Add the rest of the months to get to the day we want.
+                //
+                for(int m = 0; m < nMonths; m++)
+                        nDays += getDaysInMonth(year, m + 1, era);
+                return t + TimeSpan.days(nDays);
+        }
+
+        /**
+         * Add the specified number of years to the given Time.
+         *
+         * The generic algorithm uses information provided by the abstract
+         * methods.  Derived classes may re-implement this in order to
+         * optimize the algorithm
+         *
+         * Note that the generic algorithm does not take into account crossing
+         * era boundaries.  Derived classes may support this.
+         *
+         * Params: t = A time to add the years to
+         * Params: nYears = The number of years to add.  This can be negative.
+         *
+         * Returns: A Time that represents the provided time with the number
+         * of years added.
+         */
+        Time addYears(Time t, int nYears)
+        {
+                auto date = toDate(t);
+                auto tod = t.ticks % TimeSpan.TicksPerDay;
+                if(tod < 0)
+                        tod += TimeSpan.TicksPerDay;
+                date.year += nYears;
+                return toTime(date) + TimeSpan(tod);
+        }
+
-        package static long getTimeTicks (uint hour, uint minute, uint second) 
-        {

trunk/tango/time/chrono/Gregorian.d

@@ -99 +99 @@
-        {
-                auto ticks = time.ticks;
+                int offset = 1;
-                if (ticks < 0)
+                {
-                    ++ticks;
+                    offset = 0;
+                }
-       
-
+ + offset
-                if (dow < 0)
-                    dow += 7;
@@ -242 +246 @@
-            splitDate(time.ticks, year, month, day, doy, era);
-            dow = getDayOfWeek(time);
+        }
+
+        override Time addMonths(Time t, int nMonths)
+        {
+                //
+                // We know all years are 12 months, so use the to/from date
+                // methods to make the calculation an O(1) operation
+                //
+                auto date = toDate(t);
+                nMonths += date.month - 1;
+                int nYears = nMonths / 12;
+                nMonths %= 12;
+                if(nMonths < 0)
+                {
+                        nYears--;
+                        nMonths += 12;
+                }
+                int realYear = date.year;
+                if(date.era == BC_ERA)
+                        realYear = -realYear + 1;
+                realYear += nYears;
+                if(realYear < 1)
+                {
+                        date.year = -realYear + 1;
+                        date.era = BC_ERA;
+                }
+                else
+                {
+                        date.year = realYear;
+                        date.era = AD_ERA;
+                }
+                date.month = nMonths + 1;
+                auto tod = t.ticks % TimeSpan.TicksPerDay;
+                if(tod < 0)
+                        tod += TimeSpan.TicksPerDay;
+                return toTime(date) + TimeSpan(tod);
+        }
+
+        override Time addYears(Time t, int nYears)
+        {
+                return addMonths(t, nYears * 12);
-        }
-
@@ -347 +392 @@
-                if(era == BC_ERA)
-                        return staticIsLeapYear(year - 1, AD_ERA);
-
+ || era == CURRENT_ERA
-                        return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
-                return false;
@@ -409 +454 @@
-                assert(d.dow == Gregorian.DayOfWeek.Saturday);
-
+                //
+                // check that addMonths works properly, add 15 months to
+                // 2/3/2004, 04:05:06.007008, then subtract 15 months again.
+                //
+                t = Gregorian.generic.toTime(2004, 2, 3, 4, 5, 6, 7) + TimeSpan.micros(8);
+                d = Gregorian.generic.toDate(t);
+                assert(d.year == 2004);
+                assert(d.month == 2);
+                assert(d.day == 3);
+                assert(d.era == Gregorian.AD_ERA);
+                assert(d.doy == 34);
+                assert(d.dow == Gregorian.DayOfWeek.Tuesday);
+
+                auto t2 = Gregorian.generic.addMonths(t, 15);
+                d = Gregorian.generic.toDate(t2);
+                assert(d.year == 2005);
+                assert(d.month == 5);
+                assert(d.day == 3);
+                assert(d.era == Gregorian.AD_ERA);
+                assert(d.doy == 123);
+                assert(d.dow == Gregorian.DayOfWeek.Tuesday);
+
+                t2 = Gregorian.generic.addMonths(t2, -15);
+                d = Gregorian.generic.toDate(t2);
+                assert(d.year == 2004);
+                assert(d.month == 2);
+                assert(d.day == 3);
+                assert(d.era == Gregorian.AD_ERA);
+                assert(d.doy == 34);
+                assert(d.dow == Gregorian.DayOfWeek.Tuesday);
+
+                assert(t == t2);
-        }
-}