Date.cc

Go to the documentation of this file.

/*
 * Date.cc
 *
 * Smalltalk like class library for C++
 * Date manipulation.
 *
 * Copyright (c) 2005 Milan Cermak
 * This class is based on K. E. Gorlen's NIHCL library implementation
 * Copyright (c) 1992 K.E. Gorlen
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stlib/Date.h>
#include <stlib/String.h>
#include <stlib/Stream.h>

static const unsigned char days_in_month[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

Date::Date(unsigned long julianDate)
{
    julian_day_number = julianDate;
}

Date::Date(int month, int day, int year)
{
    julian_day_number = julianDay(month, day, year);
}

/* Class-accessing protocol */
String *Date::className(void) const
{
    return new String("Date");
}

/* Instance creation protocol */
Date *Date::today(void)
{
    time_t timestamp = time(NULL);
    const struct tm* date = localtime(&timestamp);
    return new Date(date->tm_mon+1, date->tm_mday, date->tm_year+1900);
}

/* Accessing protocol */
int Date::month(void) const
{
    int m, d, y;
    gregorianDate(m, d, y);
    return m;
}

int Date::day(void) const
{
    int m, d, y;
    gregorianDate(m, d, y);
    return d;
}

int Date::year(void) const
{
    int m, d, y;
    gregorianDate(m, d, y);
    return y;
}

int Date::weekday(void) const
/* Although this seems a little strange, it works.  (julnum + 1) % 7 gives the
 * value 0 for Sunday ... 6 for Saturday.  Since we want the list to start at
 * Monday, add 6 (mod 7) to this.  Now we have Monday at 0 ... Sunday at
 * 6.  Simply add 1 to the result to obtain Monday (1) ... Sunday (7).
 */
{
    return ((((julian_day_number + 1) % 7) + 6) % 7) + 1;
}

int Date::century(void) const
{
    return year() / 100;
}

int Date::daysInMonth(int month, int year)
{
    int dayCount = days_in_month[month];
    if (month == 2 && isLeapYear(year))      // Take care of February
        dayCount = 29;
    return dayCount;
}

/* Arithmetics protocol */
Date *Date::addDays(int dayCount)
{
    return new Date(julian_day_number + dayCount);
}

Date *Date::addMonths(int monthCount)
{
    int m, d, y;
    gregorianDate(m, d, y);
    m += monthCount;
    while (m > 12) {
        m -= 12; y += 1;
    }
    int dm = daysInMonth(m, y);
    if (d > dm) d = dm;
    return new Date(m, d, y);
}

Date *Date::addYears(int yearCount)
{
    int m, d, y;
    gregorianDate(m, d, y);
    return new Date(m, d, y+yearCount);
}

Date *Date::subtractDays(int dayCount)
{
    return new Date(julian_day_number - dayCount);
}

Date *Date::subtractMonths(int monthCount)
{
    int m, d, y;
    gregorianDate(m, d, y);
    m -= monthCount;
    while (m <= 0) {
        m += 12; y -= 1;
    }
    int dm = daysInMonth(m, y);
    if (d > dm) d = dm;
    return new Date(m, d, y);
}

Date *Date::subtractYears(int yearCount)
{
    int m, d, y;
    gregorianDate(m, d, y);
    return new Date(m, d, y-yearCount);
}

unsigned long Date::dayDifferenceFrom(Date *date)
{
    unsigned long myDays, dateDays;
    myDays = asDays();
    dateDays = date->asDays();
    if (myDays > dateDays)
        return myDays - dateDays;
    return dateDays - myDays;
}

/* Comparing protocol */
long Date::hash(void) const
{
    return (long) julian_day_number;
}

bool Date::isEqual(const Object *object) const
{
    if (!object->className()->isEqual(this->className())) return false;
    return object->hash() == this->hash();
}

/* Converting protocol */
unsigned long Date::asDays(void) const
{
    return julian_day_number;
}

/* Printing protocol */
void Date::printOn(Stream *stream) const
{
    /* Print self in numbers. Locale should know month names. */
    String *dateStr;
    int m, d, y;
    gregorianDate(m, d, y);
    dateStr = String::format("%u.%u.%u", d, m, y);
    stream->nextPutAll(dateStr);
}

/* Testing protocol */
bool Date::isLeapYear(void) const
{
    return isLeapYear(year());
}

bool Date::isLeapYear(short year)
/* Algorithm from K & R, "The C Programming Language", 1st ed. */
{
    return ((year & 3) == 0 && year % 100 != 0 || year % 400 == 0);
}

/* private protocol */
/*
Convert Gregorian calendar date to the corresponding Julian day number
j.  Algorithm 199 from Communications of the ACM, Volume 6, No. 8,
(Aug. 1963), p. 444.  Gregorian calendar started on Sep. 14, 1752.
This function not valid before that.
*/
unsigned long Date::julianDay(int month, int day, int year)
{
    unsigned long c, ya;
    if (month > 2) month -= 3;
    else {
        month += 9;
        year--;
    }
    ya = year % 100;
    c = year / 100;
    return ((146097*c)>>2) + ((1461*ya)>>2) + (153*month + 2)/5 + day + 1721119;
}

/*
Convert a Julian day number to its corresponding Gregorian calendar
date.  Algorithm 199 from Communications of the ACM, Volume 6, No. 8,
(Aug. 1963), p. 444.  Gregorian calendar started on Sep. 14, 1752.
This function not valid before that.
*/
void Date::gregorianDate(int &month, int &day, int &year) const
{
    unsigned long j = julian_day_number - 1721119;
    unsigned long y = ((j<<2) - 1) / 146097;
    j = (j<<2) - 1 - 146097*y;
    unsigned long d = j>>2;
    j = ((d<<2) + 3) / 1461;
    d = (d<<2) + 3 - 1461*j;
    d = (d + 4)>>2;
    unsigned long m = (5*d - 3)/153;
    d = 5*d - 3 - 153*m;
    d = (d + 5)/5;
    y = 100*y + j;
    if (m < 10) m += 3;
    else {
        m -= 9;
        y++;
    }
    month = (int) m;
    day   = (int) d;
    year  = (int) y;
}

---