Time.cc

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 

#include <sys/time.h> // for ::gettimeofday()
#if LSST_AP_HAVE_CLOCK_GETTIME
#   include <time.h> // for ::clock_gettime()
#endif

#include <ostream>
#include <sstream>

#include <boost/numeric/conversion/converter.hpp>

#include <lsst/ap/Time.h>


namespace lsst {
namespace ap {


// -- TimeSpec ----------------

typedef boost::numeric::converter<
    time_t,
    double,
    boost::numeric::conversion_traits<time_t, double>,
    boost::numeric::def_overflow_handler,
    boost::numeric::Floor<double>
> DoubleToTime;

TimeSpec::TimeSpec(double const seconds) {
    time_t const sec = DoubleToTime::convert(seconds);
    tv_sec  = sec;
    tv_nsec = static_cast<long>((seconds - static_cast<double>(sec))*1e9);
}


TimeSpec & TimeSpec::operator=(double const seconds) {
    time_t const sec = DoubleToTime::convert(seconds);
    tv_sec  = sec;
    tv_nsec = static_cast<long>((seconds - static_cast<double>(sec))*1e9);
    return *this;
}


TimeSpec & TimeSpec::operator+=(double const seconds) {
    time_t const sec = DoubleToTime::convert(seconds);
    tv_sec  += sec;
    tv_nsec += static_cast<long>((seconds - static_cast<double>(sec))*1e9);
    if (tv_nsec >=  1000000000l) {
        tv_nsec -= 1000000000l;
        ++tv_sec;
    }
    return *this;
}


TimeSpec & TimeSpec::now() {
#if LSST_AP_HAVE_CLOCK_GETTIME
#   if defined(CLOCK_MONOTONIC)
    clock_gettime(CLOCK_MONOTONIC, this);
#   elif defined(CLOCK_HIGHRES)
    clock_gettime(CLOCK_HIGHRES, this);
#   else
    clock_gettime(CLOCK_REALTIME, this); // Use system clock if nothing else is available
#   endif
    return *this;
#else
    return systemTime();
#endif
}


TimeSpec & TimeSpec::systemTime() {
    ::timeval tv;
    ::gettimeofday(&tv, 0);
    tv_sec  = tv.tv_sec;
    tv_nsec = tv.tv_usec*1000l;
    return *this;
}


// -- Stopwatch ----------------

Stopwatch::Stopwatch(bool const go) : _ts(), _stopped(true) {
    if (go) {
        start();
    }
}


void Stopwatch::start() {
    if (_stopped) {
        _ts.now();
        _stopped = false;
    }
}


void Stopwatch::stop() {
    if (!_stopped) {
        TimeSpec t;
        t.now() -= _ts;
        _ts      = t;
        _stopped = true;
    }
}


std::string const Stopwatch::toString() const {
    std::ostringstream os;
    os << *this;
    return os.str();
}


double Stopwatch::seconds() const {
    TimeSpec t;
    if (_stopped) {
        t = _ts;
    } else {
        t.now();
        t -= _ts;
    }
    return t.seconds();
}


std::ostream & operator<<(std::ostream & os, Stopwatch const & watch) {
    TimeSpec t;
    if (watch._stopped) {
        t = watch._ts;
    } else {
        t.now();
        t -= watch._ts;
    }
    long nsec = t.tv_nsec % 1000000000l;
    long sec  = t.tv_sec + t.tv_nsec/1000000000l;
    long min  = (sec/60) % 60;
    long hour = sec/3600;

    double s = static_cast<double>(sec % 60) + 1e-9 * static_cast<double>(nsec);

    if (hour > 0) {
        os << hour << "hr ";
    }
    if (min > 0) {
        os << min << "min ";
    }
    os << s << "sec";
    return os;
}


}} // end of namespace lsst::ap