class Poco::Timestamp

Overview

A Timestamp stores a monotonic* time value with (theoretical) microseconds resolution. More…

#include <Timestamp.h>

class Timestamp
{
public:
    // typedefs

    typedef Int64 TimeVal;
    typedef Int64 UtcTimeVal;
    typedef Int64 TimeDiff;

    // fields

    static const TimeVal TIMEVAL_MIN;
    static const TimeVal TIMEVAL_MAX;

    // construction

    Timestamp();
    Timestamp(TimeVal tv);
    Timestamp(const Timestamp& other);

    // methods

    Timestamp&
    operator=(const Timestamp& other);

    Timestamp&
    operator=(TimeVal tv);

    void
    swap(Timestamp& timestamp);

    void
    update();

    bool
    operator==(const Timestamp& ts) const;

    bool
    operator!=(const Timestamp& ts) const;

    bool
    operator>(const Timestamp& ts) const;

    bool
    operator>=(const Timestamp& ts) const;

    bool
    operator<(const Timestamp& ts) const;

    bool
    operator<=(const Timestamp& ts) const;

    Timestamp
    operator+(TimeDiff d) const;

    Timestamp
    operator+(const Timespan& span) const;

    Timestamp
    operator-(TimeDiff d) const;

    Timestamp
    operator-(const Timespan& span) const;

    TimeDiff
    operator-(const Timestamp& ts) const;

    Timestamp&
    operator+=(TimeDiff d);

    Timestamp&
    operator+=(const Timespan& span);

    Timestamp&
    operator-=(TimeDiff d);

    Timestamp&
    operator-=(const Timespan& span);

    std::time_t
    epochTime() const;

    UtcTimeVal
    utcTime() const;

    TimeVal
    epochMicroseconds() const;

    TimeDiff
    elapsed() const;

    bool
    isElapsed(TimeDiff interval) const;

    TimeVal
    raw() const;

    static
    Timestamp
    fromEpochTime(std::time_t t);

    static
    Timestamp
    fromUtcTime(UtcTimeVal val);

    static
    TimeDiff
    resolution();
};

Detailed Documentation

A Timestamp stores a monotonic* time value with (theoretical) microseconds resolution.

Timestamps can be compared with each other and simple arithmetics are supported.

[*] Note that Timestamp values are only monotonic as long as the systems’s clock is monotonic as well (and not, e.g. set back due to time synchronization or other reasons).

Timestamps are UTC (Coordinated Universal Time) based and thus independent of the timezone in effect on the system.

The internal reference time is the Unix epoch, midnight, January 1, 1970.

Typedefs

typedef Int64 TimeVal

Monotonic UTC time value in microsecond resolution, with base time midnight, January 1, 1970.

typedef Int64 UtcTimeVal

Monotonic UTC time value in 100 nanosecond resolution, with base time midnight, October 15, 1582.

typedef Int64 TimeDiff

Difference between two TimeVal values in microseconds.

Fields

static const TimeVal TIMEVAL_MIN

Minimum timestamp value.

static const TimeVal TIMEVAL_MAX

Maximum timestamp value.

Construction

Timestamp()

Creates a timestamp with the current time.

Timestamp(TimeVal tv)

Creates a timestamp from the given time value (microseconds since midnight, January 1, 1970).

Timestamp(const Timestamp& other)

Copy constructor.

Methods

void
swap(Timestamp& timestamp)

Swaps the Timestamp with another one.

void
update()

Updates the Timestamp with the current time.

std::time_t
epochTime() const

Returns the timestamp expressed in time_t.

time_t base time is midnight, January 1, 1970. Resolution is one second.

UtcTimeVal
utcTime() const

Returns the timestamp expressed in UTC-based time.

UTC base time is midnight, October 15, 1582. Resolution is 100 nanoseconds.

TimeVal
epochMicroseconds() const

Returns the timestamp expressed in microseconds since the Unix epoch, midnight, January 1, 1970.

TimeDiff
elapsed() const

Returns the time elapsed since the time denoted by the timestamp.

Equivalent to Timestamp() - *this.

bool
isElapsed(TimeDiff interval) const

Returns true iff the given interval has passed since the time denoted by the timestamp.

TimeVal
raw() const

Returns the raw time value.

Same as epochMicroseconds().

static
Timestamp
fromEpochTime(std::time_t t)

Creates a timestamp from a std::time_t.

static
Timestamp
fromUtcTime(UtcTimeVal val)

Creates a timestamp from a UTC time value (100 nanosecond intervals since midnight, October 15, 1582).

static
TimeDiff
resolution()

Returns the resolution in units per second.

Since the timestamp has microsecond resolution, the returned value is always 1000000.