time.h

/*
 *  Copyright (c) 2004    National Research Council
 *
 *  All rights reserved.
 *
 *  This material is confidential and proprietary information of
 *  National Research Council Canada ("Confidential Information").
 *  This Confidential Information may only be used and reproduced
 *  in accordance with the terms of the license agreement.
 *
 */

#ifndef __INCLUDED__SCOPIRA_TOOL_TIME_H__
#define __INCLUDED__SCOPIRA_TOOL_TIME_H__

#include <scopira/tool/platform.h>

#include <string>
#include <time.h>
#include <assert.h>

#ifdef PLATFORM_UNIX
#include <sys/time.h>
#endif

#include <scopira/tool/platform.h>
#include <scopira/tool/export.h>

namespace scopira
{
  namespace tool
  {
    class timespan;
    class timestamp;
    class chrono;
  }
}

class scopira::tool::timespan
{
  friend class timestamp;
  public:
    timespan(void) : dm_time(-1) {}
    timespan(time_t t) : dm_time(t) {}
    SCOPIRA_EXPORT timespan(int days, int hours, int minutes, int seconds);

    bool is_null(void) const { return dm_time == -1; }

    int get_days(void) const          { return static_cast<int>(dm_time / (24*60*60)); }

    int get_hours(void) const         { return get_total_hours() % 24; }
    int get_total_hours(void) const   { return static_cast<int>(dm_time / (60*60)); }

    int get_minutes(void) const       { return get_total_minutes() % 60; }
    int get_total_minutes(void) const { return static_cast<int>(dm_time / 60); }

    int get_seconds(void) const       { return static_cast<int>(dm_time % 60); }
    int get_total_seconds(void) const { return static_cast<int>(dm_time); }

    bool operator< (timespan rhs) const { return dm_time <  rhs.dm_time; }
    bool operator<=(timespan rhs) const { return dm_time <= rhs.dm_time; }
    bool operator> (timespan rhs) const { return dm_time >  rhs.dm_time; }
    bool operator>=(timespan rhs) const { return dm_time >= rhs.dm_time; }
    bool operator==(timespan rhs) const { return dm_time == rhs.dm_time; }
    bool operator!=(timespan rhs) const { return dm_time != rhs.dm_time; }

    timespan  operator+ (timespan rhs) const { return dm_time +  rhs.dm_time; }
    timespan& operator+=(timespan rhs)       { dm_time += rhs.dm_time; return *this; }
    timespan  operator- (timespan rhs) const { return dm_time -  rhs.dm_time; }
    timespan& operator-=(timespan rhs)       { dm_time -= rhs.dm_time; return *this; }

    timespan& operator= (timespan rhs)       { dm_time = rhs.dm_time; return *this; }

  private:
    time_t dm_time;  
};

class scopira::tool::timestamp
{
  public:
    timestamp(void) : dm_time(-1) {}
    timestamp(time_t t) : dm_time(t) {}

    bool is_null(void) const { return dm_time == -1; }

    SCOPIRA_EXPORT timestamp(int year, int month, int day, int hour, int minute, int second, int dst = -1);

    SCOPIRA_EXPORT void format(const std::string& format, std::string& out, bool gmt=false) const;

    SCOPIRA_EXPORT static timestamp current_time(void);

    int get_day(void) const { return get_tm()->tm_mday; }
    int get_day_of_week(void) const { return get_tm()->tm_wday; }
    int get_hour(void) const { return get_tm()->tm_hour; }
    int get_minute(void) const { return get_tm()->tm_min; }
    int get_month(void) const { return get_tm()->tm_mon; }
    int get_second(void) const { return get_tm()->tm_sec; }
    int get_year(void) const { return get_tm()->tm_year; }

    time_t get_time(void) const { return dm_time; }

#ifdef PLATFORM_win32
// disable depreacted warnings
#pragma warning(push)
#pragma warning(disable:4996)
#endif

    tm* get_tm(void) const { return localtime(&dm_time); }
#ifdef PLATFORM_win32
// disable depreacted warnings
#pragma warning(pop)
#endif

    bool operator< (timestamp rhs) const { return dm_time <  rhs.dm_time; }
    bool operator<=(timestamp rhs) const { return dm_time <= rhs.dm_time; }
    bool operator> (timestamp rhs) const { return dm_time >  rhs.dm_time; }
    bool operator>=(timestamp rhs) const { return dm_time >= rhs.dm_time; }
    bool operator==(timestamp rhs) const { return dm_time == rhs.dm_time; }
    bool operator!=(timestamp rhs) const { return dm_time != rhs.dm_time; }

    timestamp operator+ (timespan rhs) const { return dm_time + rhs.dm_time; }
    timestamp operator+=(timespan rhs)       { dm_time += rhs.dm_time; return *this; }
    timestamp operator- (timespan rhs) const { return dm_time - rhs.dm_time; }
    timestamp operator-=(timespan rhs)       { dm_time -= rhs.dm_time; return *this; }

    timestamp& operator=(timestamp rhs)   { dm_time = rhs.dm_time; return *this; }
    timestamp& operator=(time_t rhs) { dm_time = rhs; return *this; }

    timespan operator-(timestamp rhs) const { return dm_time - rhs.dm_time; }

    static int string_to_month(const std::string& month);

  private:
    void assign(int year, int month, int mday, int hour, int minute, int second, int isdst = -1, bool isgmt = false);

    time_t dm_time;   
};

class scopira::tool::chrono
{
  public:
    SCOPIRA_EXPORT chrono(void);

    SCOPIRA_EXPORT void reset(void);

    SCOPIRA_EXPORT void start(void);

    SCOPIRA_EXPORT void stop(void);

    SCOPIRA_EXPORT double get_total_time(void) const;
    SCOPIRA_EXPORT double get_lap_time(void) const;
    SCOPIRA_EXPORT double get_running_time(void) const;

  private:
    struct timeval dm_total, dm_delta; //current total, and current start-delta
};

#endif