datetime.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  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, SA.
*/

#include <sstream>
#include <iomanip>

#include <SDL/SDL_timer.h>

#include <wt/datetime.h>
#include <wt/trace.h>

namespace Wt {

Time::Time() :
        hour_(0),
        minute_(0),
        second_(0),
msec_(0) {}

Time::Time(int h, int m, int s, int ms) :
        hour_(h),
        minute_(m),
        second_(s),
msec_(ms) {}

bool Time::isNull() const {
    return (hour_ == 0 && minute_ == 0 && second_ == 0 && msec_ == 0);
}

bool Time::isValid() const {
    return (0 <= hour_ && hour_ <= 23 &&
            0 <= minute_ && minute_ <= 59 &&
            0 <= second_ && second_ <= 59 &&
            0 <= msec_ && msec_ <= 999);
}

Time::operator std::string() const {
    std::stringstream s;
    s << std::setw(2) << std::setfill('0') << hour_ << ":"
    << std::setw(2) << std::setfill('0') << minute_ <<  ":"
    << std::setw(2) << std::setfill('0') << second_ << "."
    << std::setw(3) << std::setfill('0') << msec_;
    return s.str();
}

std::string Time::toString() const {
    return *this;
}

bool Time::setHMS(int h, int m, int s, int ms) {
    hour_ = h;
    minute_ = m;
    second_ = s;
    msec_ = ms;
    return isValid();
}

int Time::add_and_wrap(int& start, int duration, int range) const {
    start += duration;
    int p = start % range;
    int wrap = (start != p) ? 1 : 0;
    start = p;
    return wrap;
}

Time Time::addSecs(int nsecs) const {
    int nh = nsecs / 3600;
    int nm = (nsecs - nh * 3600) / 60;
    int ns = (nsecs - nh * 3600 - nm * 60);

    Time t = *this;
    int wrap;
    wrap = add_and_wrap(t.second_, ns, 60);
    wrap = add_and_wrap(t.minute_, nm + wrap, 60);
    wrap = add_and_wrap(t.hour_, nh + wrap, 24);
    return t;
}

int Time::secsTo(const Time& t) const {
    int dh = t.hour_ - hour_;
    int dm = dh * 60 + t.minute_ - minute_;
    int ds = dm * 60 + t.second_ - second_;
    return ds;
}

Time Time::addMSecs(int ms) const {
    int nh = ms / 3600000;
    int nm = (ms - nh * 3600000) / 60000;
    int ns = (ms - nh * 3600000 - nm * 60000) / 1000;
    int nms = (ms - nh * 3600000 - nm * 60000 - ns * 1000);

    Time t = *this;
    int wrap;
    wrap = add_and_wrap(t.msec_, nms, 1000);
    wrap = add_and_wrap(t.second_, ns + wrap, 60);
    wrap = add_and_wrap(t.minute_, nm + wrap, 60);
    wrap = add_and_wrap(t.hour_, nh + wrap, 24);
    return t;
}

int Time::msecsTo(const Time& t) const {
    return secsTo(t) * 1000 + t.msec_ - msec_;
}

bool Time::operator==(const Time& t) const {
    return (hour_ == t.hour_ && minute_ == t.minute_ &&
            second_ == t.second_ && msec_ == t.msec_);
}

bool Time::operator!=(const Time& t) const {
    return !(*this == t);
}

bool Time::operator<(const Time& t) const {
    if (hour_ < t.hour_)
        return true;
    if (hour_ > t.hour_)
        return false;

    if (minute_ < t.minute_)
        return true;
    if (minute_ > t.minute_)
        return false;

    if (second_ < t.second_)
        return true;
    if (second_ > t.second_)
        return false;

    if (msec_ < t.msec_)
        return true;
    if (msec_ > t.msec_)
        return false;

    return false;
}

bool Time::operator>=(const Time& t) const {
    return !(*this < t);
}

bool Time::operator>(const Time& t) const {
    if (hour_ > t.hour_)
        return true;
    if (hour_ < t.hour_)
        return false;

    if (minute_ > t.minute_)
        return true;
    if (minute_ < t.minute_)
        return false;

    if (second_ > t.second_)
        return true;
    if (second_ < t.second_)
        return false;

    if (msec_ > t.msec_)
        return true;
    if (msec_ < t.msec_)
        return false;

    return false;
}

bool Time::operator<=(const Time& t) const {
    return !(*this > t);
}

void Time::start() {
    *this = currentTime();
}

int Time::restart() {
    const Time& t = currentTime();
    int ms = msecsTo(t);
    *this = t;
    return ms;
}

int Time::elapsed() const {
    Time t = currentTime();
    int ms = msecsTo(t);
    return ms;
}

Time Time::currentTime() {
    Time t;
    Uint32 ticks = SDL_GetTicks();
    trace("time", "Ticks %u\n", ticks);
    return t.addMSecs(ticks);
}

Time Time::fromString(const std::string& timedesctiption) {
    std::istringstream iss(timedesctiption);
    std::string h, m, s, ms;
    std::getline(iss, h, ':');
    std::getline(iss, m, ':');
    std::getline(iss, s, '.');
    std::getline(iss, ms, ' ');

    return Time(atoi(h.c_str()), atoi(m.c_str()),
                atoi(s.c_str()), atoi(ms.c_str()));
}

bool Time::isValid(int h, int m, int s, int ms) {
    Time t(h, m, s, ms);
    return t.isValid();
}

} // namespace

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.