Timestamp.cc

Go to the documentation of this file.

/*
 * Timestamp.cc
 *
 * Smalltalk like class library for C++
 * Timestamp.
 *
 * Copyright (c) 2005 Milan Cermak
 */
/*
 * 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 <time.h>
#include <sys/time.h>
#include <stlib/Date.h>
#include <stlib/String.h>
#include <stlib/Stream.h>
#include <stlib/Time.h>
#include <stlib/Timestamp.h>

Timestamp::Timestamp(int month, int day, int year, int hour,
                     int minute, int second, int millisecond)
{
    _timestamp.day = day;
    _timestamp.month = month;
    _timestamp.year = year;
    _timestamp.hours = hour;
    _timestamp.minutes = minute;
    _timestamp.seconds = second;
    _timestamp.milliseconds = millisecond;
}

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

/* Instance creating protocol */
Timestamp *Timestamp::now(void)
{
    struct timeval timestamp;
    struct timezone tz;
    Timestamp *inst;

    gettimeofday(&timestamp, &tz);
    const struct tm* time = localtime(&timestamp.tv_sec);
    return new Timestamp(time->tm_mon+1, time->tm_mday, time->tm_year+1900,
                         time->tm_hour, time->tm_min, time->tm_sec,
                         timestamp.tv_usec / 1000);
}

Timestamp *Timestamp::fromUnixTimestamp(time_t timestamp)
{
    const struct tm* time = localtime(&timestamp);
    return new Timestamp(time->tm_mon+1, time->tm_mday, time->tm_year+1900,
                         time->tm_hour, time->tm_min, time->tm_sec);
}

Timestamp *Timestamp::fromDateAndTime(Date *date, Time *time)
{
    return new Timestamp(date->month(), date->day(), date->year(),
                         time->hour(), time->minute(), time->second(),
                         time->millisecond());
}

/* Accessing protocol */
int Timestamp::month(void) const
{
    return _timestamp.month;
}

int Timestamp::day(void) const
{
    return _timestamp.day;
}

int Timestamp::year(void) const
{
    return _timestamp.year;
}

int Timestamp::weekday(void) const
{
    return asDate()->weekday();
}

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

int Timestamp::hour(void) const
{
    return _timestamp.hours;
}

int Timestamp::minute(void) const
{
    return _timestamp.minutes;
}

int Timestamp::second(void) const
{
    return _timestamp.seconds;
}

int Timestamp::millisecond(void) const
{
    return _timestamp.milliseconds;
}

/* Arithmetics protocol */
Timestamp *Timestamp::addDays(int dayCount)
{
    return fromDateAndTime(asDate()->addDays(dayCount), asTime());
}

Timestamp *Timestamp::addMonths(int monthCount)
{
    return fromDateAndTime(asDate()->addMonths(monthCount), asTime());
}

Timestamp *Timestamp::addYears(int yearCount)
{
    return fromDateAndTime(asDate()->addYears(yearCount), asTime());
}

Timestamp *Timestamp::addHours(int hours)
{
    hours += _timestamp.hours;
    int days = hours / 24;
    hours %= 24;
    Time *time = new Time(hours, _timestamp.minutes, _timestamp.seconds,
                          _timestamp.milliseconds);
    return fromDateAndTime(asDate()->addDays(days), time);
}

Timestamp *Timestamp::addMinutes(int minutes)
{
    return addSeconds(minutes * 60);
}

Timestamp *Timestamp::addSeconds(int seconds)
{
    return addMilliseconds(seconds * 1000);
}

Timestamp *Timestamp::addMilliseconds(int millis)
{
    int days, hours, minutes, seconds;
    millis += _timestamp.milliseconds;
    seconds = _timestamp.seconds + millis / 1000;
    minutes = _timestamp.minutes + seconds / 60;
    hours = _timestamp.hours + minutes / 60;
    days = hours / 24;
    hours = hours % 24;
    minutes = minutes % 60;
    seconds = seconds % 60;
    millis = millis % 1000;
    return fromDateAndTime(asDate()->addDays(days),
                           new Time(hours, minutes, seconds, millis));
}

Timestamp *Timestamp::subtractDays(int dayCount)
{
    return fromDateAndTime(asDate()->subtractDays(dayCount), asTime());
}

Timestamp *Timestamp::subtractMonths(int monthCount)
{
    return fromDateAndTime(asDate()->subtractMonths(monthCount), asTime());
}

Timestamp *Timestamp::subtractYears(int yearCount)
{
    return fromDateAndTime(asDate()->subtractYears(yearCount), asTime());
}

Timestamp *Timestamp::subtractHours(int hours)
{
    hours = _timestamp.hours - hours;
    int days = 0;
    while (hours < 0) {
        days++; hours += 24;
    }
    Time *time = new Time(hours, _timestamp.minutes, _timestamp.seconds,
                          _timestamp.milliseconds);
    return fromDateAndTime(asDate()->subtractDays(days), time);
}

Timestamp *Timestamp::subtractMinutes(int minutes)
{
    return subtractSeconds(minutes * 60);
}

Timestamp *Timestamp::subtractSeconds(int seconds)
{
    return subtractMilliseconds(seconds * 1000);
}

Timestamp *Timestamp::subtractMilliseconds(int millis)
{
    int seconds = millis / 1000;
    millis = _timestamp.milliseconds - millis % 1000;
    while (millis < 0) {
        seconds++; millis += 1000;
    }
    int minutes = seconds / 60;
    seconds = _timestamp.seconds - seconds % 60;
    while (seconds < 0) {
        minutes++; seconds += 60;
    }
    int hours = minutes / 60;
    minutes = _timestamp.minutes - minutes % 60;
    while (minutes < 0) {
        hours++; minutes += 60;
    }
    int days = hours / 24;
    hours = _timestamp.hours - hours % 24;
    while (hours < 0) {
        days++; hours += 24;
    }
    return fromDateAndTime(asDate()->subtractDays(days),
                           new Time(hours, minutes, seconds, millis));
}

Time *Timestamp::differenceFrom(Timestamp *stamp)
{
    int days = asDate()->dayDifferenceFrom(stamp->asDate());
    return asTime()->differenceFrom(stamp->asTime())->addHours(days * 24);
}

/* Comparing protocol */
long Timestamp::hash(void) const
{
    unsigned long hashVal, mon_year;
    mon_year = _timestamp.month;
    mon_year = _timestamp.year << 4;
    hashVal = _timestamp.milliseconds;
    hashVal += _timestamp.seconds << 10;
    hashVal += _timestamp.minutes << 16;
    hashVal += _timestamp.hours << 22;
    hashVal += _timestamp.day << 27;
    return (long) (hashVal ^ mon_year);
}

bool Timestamp::isEqual(const Object *object) const
{
    if (!object->className()->isEqual(className())) return false;

    const Timestamp *t = dynamic_cast<const Timestamp *>(object);
    return t->_timestamp.year == _timestamp.year &&
           t->_timestamp.month == _timestamp.month &&
           t->_timestamp.day == _timestamp.day &&
           t->_timestamp.hours == _timestamp.hours &&
           t->_timestamp.minutes == _timestamp.minutes &&
           t->_timestamp.seconds == _timestamp.seconds &&
           t->_timestamp.milliseconds == _timestamp.milliseconds;
}

/* Converting protocol */
Date *Timestamp::asDate(void) const
{
    return new Date(_timestamp.month, _timestamp.day, _timestamp.year);
}

Time *Timestamp::asTime(void) const
{
    return new Time(_timestamp.hours, _timestamp.minutes, _timestamp.seconds,
                    _timestamp.milliseconds);
}

time_t Timestamp::asUnixTimestamp(void) const
{
    struct tm time;

    time.tm_sec = _timestamp.seconds;
    time.tm_min = _timestamp.minutes;
    time.tm_hour = _timestamp.hours;
    time.tm_mday = _timestamp.day;
    time.tm_mon = _timestamp.month - 1;
    time.tm_year = _timestamp.year - 1900;
    return mktime(&time);
}

/* Printing protocol */
void Timestamp::printOn(Stream *stream) const
{
    asDate()->printOn(stream);
    stream->space();
    asTime()->printOn(stream);
}

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

---