Time.cc

Go to the documentation of this file.

/*
 * Time.cc
 *
 * Smalltalk like class library for C++
 * Time manipulation.
 *
 * 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 <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <stlib/String.h>
#include <stlib/Stream.h>
#include <stlib/Time.h>

Time::Time(int hour, int minute, int second, int milli)
{
    _hours = hour;
    _minutes = minute;
    _seconds = second;
    _milliseconds = milli;
}

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

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

    gettimeofday(&timestamp, &tz);
    const struct tm* time = localtime(&timestamp.tv_sec);
    return new Time(time->tm_hour, time->tm_min, time->tm_sec,
                    timestamp.tv_usec/1000);
}

Time *Time::midnight()
{
    return Time::zero();
}

Time *Time::zero()
{
    return new Time;
}

/* Accessing protocol */
int Time::hour(void) const
{
    return _hours;
}

int Time::minute(void) const
{
    return _minutes;
}

int Time::second(void) const
{
    return _seconds;
}

int Time::millisecond(void) const
{
    return _milliseconds;
}

/* Arithmetics protocol */
Time *Time::addHours(int hours)
{
    return new Time(_hours + hours, _minutes, _seconds, _milliseconds);
}

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

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

Time *Time::addMilliseconds(int millis)
{
    int hours, minutes, seconds;
    millis += _milliseconds;
    seconds = _seconds + millis / 1000;
    minutes = _minutes + seconds / 60;
    hours = _hours + minutes / 60;
    minutes = minutes % 60;
    seconds = seconds % 60;
    millis = millis % 1000;
    return new Time(hours, minutes, seconds, millis);
}

Time *Time::subtractHours(int hours)
{
    return new Time(_hours - hours, _minutes, _seconds, _milliseconds);
}

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

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

Time *Time::subtractMilliseconds(int millis)
{
    int seconds = millis / 1000;
    millis = _milliseconds - millis % 1000;
    while (millis < 1000) {
        seconds++; millis -= 1000;
    }
    int minutes = seconds / 60;
    seconds = _seconds - seconds % 60;
    while (seconds < 60) {
        minutes++; seconds -= 60;
    }
    int hours = minutes / 60;
    minutes = _minutes - minutes % 60;
    while (minutes < 60) {
        hours++; minutes -= 60;
    }
    hours = _hours - hours;
    return new Time(hours, minutes, seconds, millis);
}

Time *Time::differenceFrom(Time *time)
{
    unsigned long millis = abs(asMilliseconds() - time->asMilliseconds());
    return Time::zero()->addMilliseconds(millis);
}

/* Comparing protocol */
long Time::hash(void) const
{
    long hashVal = _hours;
    hashVal += _minutes << 10;
    hashVal += _seconds << 16;
    hashVal += _milliseconds << 22;
}

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

    const Time *t = dynamic_cast<const Time *>(object);
    return t->_hours == this->_hours &&
           t->_minutes == this->_minutes &&
           t->_seconds == this->_seconds &&
           t->_milliseconds == this->_milliseconds;
}

/* Converting protocol */
unsigned long Time::asMilliseconds(void) const
{
    return ((_hours * 60 + _minutes) * 60 + _seconds) * 1000 + _milliseconds;
}

/* Printing protocol */
void Time::printOn(Stream *stream) const
{
    String *timeStr;
    timeStr = String::format("%u:%02u:%02u.%03u",
                             hour(), minute(), second(), millisecond());
    stream->nextPutAll(timeStr);
}

---