TimeStamp.cc

Go to the documentation of this file.

 
#include "utility/TimeStamp.hh"
#include "utility/Exception.hh"
 
#ifndef WIN32
#include <sys/time.h>
#endif
#include <time.h>
 
namespace crl {
namespace multisense {
namespace details {
namespace utility {
#if defined (WIN32)
ULARGE_INTEGER TimeStamp::offsetSecondsSince1970;
#endif
/*
 * Constructor. Empty. We rely on the getter methods to do
 * things that are more useful.
 */
TimeStamp::TimeStamp()
{
    this->set(0, 0);
}
 
/*
 * Constructor. Initializes with the specified
 */
TimeStamp::TimeStamp(int32_t seconds, int32_t microSeconds)
{
    this->set(seconds, microSeconds);
}
 
/*
 * Constructor. Initializes with the specified
 */
TimeStamp::TimeStamp(int64_t nanoseconds)
{
    const int64_t totalMicroSeconds = nanoseconds / 1000;
 
    const int64_t seconds = totalMicroSeconds / 1000000;
    const int64_t microSeconds = totalMicroSeconds - (seconds * 1000000);
 
    this->set(static_cast<int32_t>(seconds), static_cast<int32_t>(microSeconds));
}
 
/*
 * Constructor. Initializes with the specified timestamp value.
 */
TimeStamp::TimeStamp(const struct timeval& value)
{
    this->set(value);
}
 
/*
 * Sets this timestamp equal to the timestamp specified.
 */
void TimeStamp::set(const struct timeval& value)
{
    set(value.tv_sec, value.tv_usec);
}
 
/*
 * Sets this timestamp to a specific time
 */
void TimeStamp::set(int32_t seconds, int32_t microSeconds)
{
    const int32_t rollover_sec = microSeconds / 1000000;
 
    // Convention is for tv_usec to be between 0 and 999999
    // Handle rollover by moving seconds to the
    if (rollover_sec != 0)
    {
        seconds += rollover_sec;
        microSeconds %= 1000000;
    }
 
    if (microSeconds < 0)
    {
        // we know that abs(tv_usec) is less than 1,000,000 at this point
        seconds -= 1;
        microSeconds += 1000000;
    }
 
    this->time.tv_sec = seconds;
    this->time.tv_usec = microSeconds;
}
 
#ifndef SENSORPOD_FIRMWARE
 
/*
 * This routine will get the current time (as gettimeofday()) and
 * store it off. It is the normal way of initializing time. Notice
 * that there may be large time skips when you call this routine, due
 * to time synchronization jumps.
 *
 * Notice that the timestamp returned by this object *is* atomic. It
 * will not change, even if time synchronization skews things.
 */
TimeStamp TimeStamp::getCurrentTime()
{
    //
    // Create a new timestamp object and fill it in with
    // the current time of day.
    //
 
    TimeStamp timeStamp;
 
#if defined (WIN32)
 
    // gettimeofday does not exist on Windows
    FILETIME currentTimeAsFileTime;
    GetSystemTimeAsFileTime (&currentTimeAsFileTime);
 
    ULARGE_INTEGER currentTimeAsLargeInteger;
    currentTimeAsLargeInteger.LowPart = currentTimeAsFileTime.dwLowDateTime;
    currentTimeAsLargeInteger.HighPart = currentTimeAsFileTime.dwHighDateTime;
    currentTimeAsLargeInteger.QuadPart -= offsetSecondsSince1970.QuadPart;
 
    // convert time to nanoseconds
    timeStamp = TimeStamp(static_cast<int64_t>(currentTimeAsLargeInteger.QuadPart) * 100);
 
#else
 
#if defined (USE_MONOTONIC_CLOCK)
    struct timespec ts;
    ts.tv_sec = 0;
    ts.tv_nsec = 0;
 
    if (0 != clock_gettime(CLOCK_MONOTONIC, &ts))
    {
        CRL_EXCEPTION("Failed to call clock_gettime().");
    }
 
    TIMESPEC_TO_TIMEVAL(&timeStamp.time, &ts);
#else
    gettimeofday(&timeStamp.time, 0);
#endif
 
#endif
 
    return timeStamp;
}
 
#endif // SENSORPOD_FIRMWARE
 
/*
 * Returns the seconds portion of the timestamp.
 */
int32_t TimeStamp::getSeconds() const
{
    return this->time.tv_sec;
}
 
/*
 * Returns the microseconds portion of the timestamp.
 */
int32_t TimeStamp::getMicroSeconds() const
{
    return this->time.tv_usec;
}
 
/*
 * Returns the total time as nanoseconds, aggregates seconds and microseconds
 */
int64_t TimeStamp::getNanoSeconds() const
{
    return static_cast<int64_t>(this->time.tv_sec) * 1000000000 + static_cast<int64_t>(this->time.tv_usec) * 1000;
}
 
TimeStamp TimeStamp::operator+(TimeStamp const& other) const
{
    // newly constructed TimeStamp handles usec rollover
    return {static_cast<int32_t>(this->time.tv_sec + other.time.tv_sec),
            static_cast<int32_t>(this->time.tv_usec + other.time.tv_usec)};
}
 
TimeStamp TimeStamp::operator-(TimeStamp const& other) const
{
    // newly constructed TimeStamp handles usec rollover
    return {static_cast<int32_t>(this->time.tv_sec - other.time.tv_sec),
            static_cast<int32_t>(this->time.tv_usec - other.time.tv_usec)};
}
 
TimeStamp& TimeStamp::operator+=(TimeStamp const& other)
{
    *this = *this + other;
    return *this;
}
 
TimeStamp& TimeStamp::operator-=(TimeStamp const& other)
{
    *this = *this - other;
    return *this;
}
 
}}}} // namespaces