Timestamp.h

Go to the documentation of this file.

#ifndef TIMESTAMP_H_
#define TIMESTAMP_H_

#include <sys/time.h>

class Str;
class Timespan;

class Timestamp
{
public:
    static const Timestamp NOT_SET_TIME;

    static const Timestamp EPOCH_START_TIME;

    Timestamp( const double& seconds );

    Timestamp( const int seconds, const unsigned int microseconds );

    Timestamp( const int year, const int month, const int day,
               const int hour, const int minute, const int second );

    Timestamp( const struct timeval& timeval );

    Timestamp( const char* timeString );

    Timestamp( const Timestamp& copyMe = NOT_SET_TIME );

    static Timestamp FromMicros( const long long& micros );

    void addFromMicros( const long long& micros );

    static Timestamp FromMillis( const long long& millis );

    void addFromMillis( const long long& millis );

    // Round to the nearest #of seconds indicated.
    // i.e., use 60 for nearest minute, 3600 for hour, etc
    void round( int seconds );

    virtual ~Timestamp()
    {}
    ;

    Timespan elapsed() const;

    virtual double asDouble() const;

    virtual double asFloat() const;

    long long asMicros() const;

    long long asMillis() const;

    inline time_t asTimeT() const
    {
        return timeval_.tv_sec;
    }

    struct tm asStructTm() const;

    //== Copy operators ==
    Timestamp& operator= ( const Timestamp& rhs );
    Timestamp& operator= ( const double& seconds );
    Timestamp& operator= ( const struct timeval& timeval );

    //== Math operator ==
    Timestamp& operator+= ( const Timespan& rhs );
    Timestamp& operator-= ( const Timespan& rhs );
    Timestamp operator+ ( const Timespan& rhs ) const;
    Timestamp operator- ( const Timespan& rhs ) const;
    Timespan operator- ( const struct timeval& rhs ) const;
    Timespan operator- ( const Timestamp& rhs ) const;

    //== Inequalities ==
    bool operator== ( const Timestamp& rhs ) const;
    bool operator!= ( const Timestamp& rhs ) const;
    bool operator> ( const Timestamp& rhs ) const;
    bool operator< ( const Timestamp& rhs ) const;
    bool operator<= ( const Timestamp& rhs ) const;
    bool operator>= ( const Timestamp& rhs ) const;

    //== Functions for setting time ==
    Timestamp& setToCurrentTime();

#ifdef __FASTSIM
    Timestamp& setToRealCurrentTime();
#endif

    Timestamp& setToMonoTime();

    static Timestamp Now();

#ifdef __FASTSIM

    static Timespan SetNow( const Timestamp newNow );

#endif

    void sleepTill();

    void toTimespec( struct timespec* ) const;

    void fromTimespec( const struct timespec* in );

    const struct timeval& getTimeval() const
    {
        return timeval_;
    };

    //== Put input/output functions here... ==

    const char* toString( char* buf, int buflen, int precision = 3 ) const;

    const Str toString( int precision = 3 ) const;

    const Str toSmallString() const;

    const Str toSmallerString() const;

    const Str toDateHourString() const;


protected:

    struct timeval timeval_;

    struct timeval& fromDouble( const double& seconds );

    struct timeval& fromIntegers( const int seconds, const unsigned int microseconds );

    struct timeval& fromIntegers( const int year, const int month, const int day,
                                  const int hour, const int minute, const int second );

    struct timeval& fromString( const char* timeString );

    static struct timeval TimevalFromIntegers( const int seconds, const unsigned int microseconds );

    static struct timeval TimevalFromMicros( const long long& micros );

    static struct timeval TimevalFromMillis( const long long& millis );

#ifdef __FASTSIM
    // Allows for fast simulation
    static Timespan TimeOffset_;
#endif

};

class Timespan : public Timestamp
{
public:
    static const Timespan INVALID_TIMESPAN;

    static const Timespan ZERO_TIMESPAN;

    Timespan( const double& seconds );

    Timespan( const struct timeval& timeval );

    Timespan( const Timespan& copyMe = ZERO_TIMESPAN );

    static Timespan FromMicros( const long long& micros );

    static Timespan FromMillis( const long long& millis );

    ~Timespan()
    {}
    ;

    virtual double asDouble() const;

    virtual double asFloat() const;

    bool setDuration( const char* duration );

    //== Math operator ==
    Timespan& operator+= ( const Timespan& rhs );
    Timespan& operator-= ( const Timespan& rhs );
    Timespan& operator-= ( const struct timeval& rhs );

    //== Functions for dealing with "whole units" of time ==
    static Timespan Milliseconds( float msec )
    {
        return Timespan( msec / 1000.0 );
    }

    static Timespan Seconds( double sec )
    {
        return Timespan( sec );
    };

    static Timespan Minutes( int min )
    {
        return Timespan( 60.0 * min );
    };

    static Timespan Hours( int hour )
    {
        return Timespan( hour * 3600.0 );
    };

    static Timespan Days( int day )
    {
        return Timespan( day * 3600.0 * 24.0 );
    };

#ifdef __FASTSIM
    void sleepFast( void ) const
    {
        TimeOffset_ += *this;
    }
#endif

    void sleepFor( void ) const;

    //== Input/output ==


    const char* toString( char* buf, int buflen, int precision = 3 ) const;

    const Str toString( int precision = 3 ) const;

};

#endif /*TIMESTAMP_H_*/