/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/Time.cpp

/*
** libutil++
** $Id: Time.cpp 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Time.cpp 1230 2014-11-16 02:32:01Z sella $";

#include "Time.h"

#include <time.h>
#include <assert.h>
#include <string.h>
//#include <arpa/inet.h>

using namespace sella::util;
using namespace std::chrono;

/* Explanation of the different clock_gettime() arguments.
** http://juliusdavies.ca/posix_clocks/clock_realtime_linux_faq.html
*/

struct timeval Time::htontv(const struct timeval &tv) throw () {
        struct timeval ret_val;

        ret_val.tv_sec = htonl(tv.tv_sec);
        ret_val.tv_usec = htonl(tv.tv_usec);

        return ret_val;
}

struct timeval Time::ntohtv(const struct timeval &tv) throw () {
        struct timeval ret_val;

        ret_val.tv_sec = ntohl(tv.tv_sec);
        ret_val.tv_usec = ntohl(tv.tv_usec);

        return ret_val;
}

int Time::comparetv(const struct timeval &a, const struct timeval &b) throw () {
        if (a.tv_sec > b.tv_sec) {
                return 1;
        } else if (a.tv_sec < b.tv_sec) {
                return -1;
        } else if (a.tv_usec > b.tv_usec) {
                return 1;
        } else if (a.tv_usec < b.tv_usec) {
                return -1;
        }

        return 0;
}

void Time::cleartv(struct timeval &tv) throw () {
        tv = { 0, 0 };
}

void Time::copytv(struct timeval &dst, const struct timeval &src) throw () {
        dst = src;
}

void Time::subtracttv(struct timeval &dst, const struct timeval &src) throw () {
   if ((dst.tv_usec -= src.tv_usec) < 0) {
      dst.tv_usec += 1000000LL;
      dst.tv_sec--;
   }
   dst.tv_sec -= src.tv_sec;
}

void Time::addtv(struct timeval &dst, const struct timeval &src) throw () {
   if ((dst.tv_usec -= src.tv_usec) > 1000000LL) {
      dst.tv_usec -= 1000000LL;
      dst.tv_sec++;
   }
   dst.tv_sec -= src.tv_sec;
}

struct timespec Time::htonts(const struct timespec &ts) throw () {
        struct timespec ret_spec;

        ret_spec.tv_sec = htonl(ts.tv_sec);
        ret_spec.tv_nsec = htonl(ts.tv_nsec);

        return ret_spec;
}

struct timespec Time::ntohts(const struct timespec &ts) throw () {
        struct timespec ret_spec;

        ret_spec.tv_sec = ntohl(ts.tv_sec);
        ret_spec.tv_nsec = ntohl(ts.tv_nsec);

        return ret_spec;
}

int Time::comparets(const struct timespec &a, const struct timespec &b) throw () {
        if (a.tv_sec > b.tv_sec) {
                return 1;
        } else if (a.tv_sec < b.tv_sec) {
                return -1;
        } else if (a.tv_nsec > b.tv_nsec) {
                return 1;
        } else if (a.tv_nsec < b.tv_nsec) {
                return -1;
        }

        return 0;
}

void Time::clearts(struct timespec &ts) throw () {
        ts = { 0, 0 };
}

void Time::copyts(struct timespec &dst, const struct timespec &src) throw () {
        dst = src;
}

void Time::subtractts(struct timespec &dst, const struct timespec &src) throw () {
   if ((dst.tv_nsec -= src.tv_nsec) < 0) {
      dst.tv_nsec += 1000000000LL;
      dst.tv_sec--;
   }
   dst.tv_sec -= src.tv_sec;
}

void Time::addts(struct timespec &dst, const struct timespec &src) throw () {
   if ((dst.tv_nsec -= src.tv_nsec) > 1000000000LL) {
      dst.tv_nsec -= 1000000000LL;
      dst.tv_sec++;
   }
   dst.tv_sec -= src.tv_sec;
}

struct timespec Time::clock_realtime(struct timezone *tz) throw () {
        struct timespec now = { 0, 0 };

        ::clock_gettime(CLOCK_REALTIME, &now);

        return now;
}

struct timespec Time::clock_monotonic(struct timezone *tz) throw () {
        struct timespec now = { 0, 0 };

        ::clock_gettime(CLOCK_MONOTONIC, &now);

        return now;
}

struct timespec Time::clock_monotonic_raw(struct timezone *tz) throw () {
        struct timespec now = { 0, 0 };

        ::clock_gettime(CLOCK_MONOTONIC_RAW, &now);

        return now;
}

struct timespec Time::clock_process_cputime_id(struct timezone *tz) throw () {
        struct timespec now = { 0, 0 };

        ::clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &now);

        return now;
}

struct timespec Time::clock_thread_cputime_id(struct timezone *tz) throw () {
        struct timespec now = { 0, 0 };

        ::clock_gettime(CLOCK_THREAD_CPUTIME_ID, &now);

        return now;
}

uint64_t Time::tstosec(const struct timespec &ts) throw () { /* Good */
        return ((ts.tv_nsec / 1000000000LL) + ts.tv_sec);
}

uint64_t Time::tstomsec(const struct timespec &ts) throw () { /* Good, but may overflow */
        return ((ts.tv_nsec / 1000000LL) + (ts.tv_sec * 1000LL));
}

uint64_t Time::tstousec(const struct timespec &ts) throw () { /* Good, but may overflow */
        return (ts.tv_nsec / 1000LL + (ts.tv_sec * 1000000LL));
}

#if 0
struct timespec Time::usectots(uint64_t usec) throw () {
        struct timespec ret_val;

        ret_val.tv_sec = usec / 1000;
        ret_val.tv_nsec = (usec % 1000) * 1000000;

        return ret_val;
}

struct timespec Time::msectots(const uint64_t msec) throw () {
        struct timespec ret_val;

        ret_val.tv_sec = msec / 1000000;
        ret_val.tv_nsec = ((msec % 1000000) * 1000000);

        return ret_val;
}
#endif

struct timespec Time::sectots(uint64_t sec) throw () { /* Good */
        struct timespec ret_val;

        ret_val.tv_sec = sec;
        ret_val.tv_nsec = 0;

        return ret_val;
}

std::string Time::tmtostr(const struct tm &tm, const char* format) throw () {
        char buf[512] = { 0 };

        strftime(buf, sizeof(buf), format, &tm);

        return std::string(buf);
}

std::string Time::tstostr(const struct timespec &ts, const char* format) throw () {
        return sectostr(tstosec(ts), format);
}

std::string Time::sectostr(uint64_t sec, const char* format) throw () {
        time_t s = (sec == 0) ? time(NULL) : sec;
        struct tm tm = *::localtime(&s);

        return tmtostr(tm, format);
}

std::string Time::msectostr(uint64_t msec, const char* format) throw () {
        return sectostr(msec / 1000LL, format);

}
std::string Time::usectostr(uint64_t usec, const char* format) throw () {
        return sectostr(usec / 1000000LL, format);
}

struct timeval Time::gettimeofday(struct timezone *tz) throw () {
        struct timeval now;

        ::gettimeofday(&now, tz);

        return now;
}

uint64_t Time::gettimeofday_usec(struct timezone *tz) throw () {
        struct timeval now;

        ::gettimeofday(&now, tz);

        return tvtousec(now);
}

uint64_t Time::gettimeofday_msec(struct timezone *tz) throw () {
        struct timeval now;

        ::gettimeofday(&now, tz);

        return tvtomsec(now);
}

uint64_t Time::gettimeofday_sec(struct timezone *tz) throw () {
        struct timeval now;

        ::gettimeofday(&now, tz);

        return tvtosec(now);
}

uint64_t Time::tvtousec(const struct timeval &tv) throw () {
        return (tv.tv_usec + (tv.tv_sec * 1000000LL));
}

uint64_t Time::tvtomsec(const struct timeval &tv) throw () {
        return ((tv.tv_usec / 1000LL) + (tv.tv_sec * 1000LL));
}

uint64_t Time::tvtosec(const struct timeval &tv) throw () {
        return ((tv.tv_usec / 1000000LL) + tv.tv_sec);
}

struct timeval Time::chronototv(const std::chrono::system_clock::duration &duration) throw () {
        struct timeval ret_val;
        microseconds usec = duration_cast<microseconds>(duration);

        if (usec <= microseconds(0)) {
                ret_val.tv_sec = ret_val.tv_usec = 0;
        } else {
                ret_val.tv_sec = usec.count() / 1000000LL;
                ret_val.tv_usec = usec.count() % 1000000LL;
        }

        return ret_val;
}

struct timeval Time::chronototv(const std::chrono::system_clock::time_point &tp) throw () {
        return chronototv(duration_cast<milliseconds>(tp.time_since_epoch()));
}

struct timeval Time::sectotv(uint64_t sec) throw () {
        struct timeval ret_val;

        ret_val.tv_sec = sec;
        ret_val.tv_usec = 0;

        return ret_val;
}

struct timeval Time::msectotv(uint64_t msec) throw () {
        struct timeval ret_val;

        ret_val.tv_sec = msec / 1000LL;
        ret_val.tv_usec = ((msec % 1000LL) * 1000LL);

        return ret_val;
}

struct timeval Time::usectotv(uint64_t usec) throw () {
        struct timeval ret_val;

        ret_val.tv_sec = usec / 1000000LL;
        ret_val.tv_usec = usec - (ret_val.tv_sec * 1000000LL);

        return ret_val;
}

struct timeval* Time::add_usectotv(struct timeval &tv, uint64_t usec) throw () {
        tv.tv_sec += (usec / 1000000LL);
        tv.tv_usec += (usec % 1000000LL);

        if (tv.tv_usec > 1000000LL) {
                tv.tv_usec -= 1000000LL;
                tv.tv_sec++;
        }

        return &tv;
}

struct timeval* Time::add_msectotv(struct timeval &tv, uint64_t msec) throw () {
        tv.tv_sec += (msec / 1000LL);
        tv.tv_usec += ((msec % 1000LL) * 1000LL);

        if (tv.tv_usec > 1000000LL) {
                tv.tv_usec -= 1000000LL;
                tv.tv_sec++;
        }

        return &tv;
}

struct timeval* Time::add_sectotv(struct timeval &tv, uint64_t sec) throw () {
        tv.tv_sec += sec;

        if (tv.tv_usec > 1000000LL) {
                tv.tv_usec -= 1000000LL;
                tv.tv_sec++;
        }

        return &tv;
}

std::string Time::getRFC1123Date(void) throw () {
        static const char *days[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
        static const char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };

        time_t now;
        struct tm tm;
        char buf[32];

        time(&now);
        gmtime_r(&now, &tm);

        strftime(buf, sizeof(buf), "---, %d --- %Y %H:%M:%S GMT", &tm);
        memcpy(buf, days[tm.tm_wday], 3);
        memcpy(buf + 8, months[tm.tm_mon], 3);

        return std::string(buf);
}

/*
** vim: noet ts=3 sw=3
*/

---