xstimestamp.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#ifndef XSTIMESTAMP_H
#define XSTIMESTAMP_H

#include "xstypesconfig.h"
#include "pstdint.h"

#ifdef __cplusplus
extern "C" {
#else
#define XSTIMESTAMP_INITIALIZER \
    {                           \
        0                       \
    }
#endif

struct XsTimeStamp;
struct XsUtcTime;

XSTYPES_DLL_API void XsTimeStamp_setMilliSecondTime(
    struct XsTimeStamp* thisPtr, int64_t t);
XSTYPES_DLL_API double XsTimeStamp_timeOfDay(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int64_t
    XsTimeStamp_secondTime(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int32_t
    XsTimeStamp_milliSecondPart(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int32_t
    XsTimeStamp_secondPart(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int32_t
    XsTimeStamp_minutePart(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int32_t XsTimeStamp_hourPart(const struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int64_t XsTimeStamp_now(struct XsTimeStamp* thisPtr);
XSTYPES_DLL_API int64_t XsTimeStamp_maxValue();
XSTYPES_DLL_API int64_t XsTimeStamp_fromUtcTime(
    struct XsTimeStamp* thisPtr, const struct XsUtcTime* utc);
XSTYPES_DLL_API void XsTimeStamp_toUtcTime(
    struct XsTimeStamp* thisPtr, struct XsUtcTime* utc);

#ifdef __cplusplus
}  // extern "C"
#endif

/*! \struct XsTimeStamp
    \brief Class for managing timestamps in a unified way.
*/
struct XsTimeStamp
{
#ifdef __cplusplus
    /*! \brief Construct a timestamp with \a t as the time in milliseconds. */
    inline XsTimeStamp(int64_t t = 0) : m_msTime(t) {}
    /*! \brief Construct a timestamp with \a t as the time in milliseconds. */
    inline XsTimeStamp(int t) : m_msTime(t) {}
    /*! \brief Construct a copy of \a other. */
    inline XsTimeStamp(const XsTimeStamp& other) : m_msTime(other.m_msTime) {}
    /*! \brief Construct from \a utc */
    inline XsTimeStamp(const XsUtcTime& utc)
    {
        XsTimeStamp_fromUtcTime(this, &utc);
    }

    /*! \brief Convert this timestamp to UTC time \a utc */
    inline void toUtcTime(XsUtcTime& utc) { XsTimeStamp_toUtcTime(this, &utc); }
    /*! \brief Assign the contents of the \a other timestamp to this timestamp.
     */
    inline XsTimeStamp& operator=(const XsTimeStamp& other)
    {
        m_msTime = other.m_msTime;
        return *this;
    }

    /*! \brief Get the stored time as milliseconds. */
    inline int64_t msTime(void) const { return m_msTime; }
    /*! \brief Set the stored time to \a t milliseconds. */
    inline void setMsTime(int64_t t) { m_msTime = t; }
    /*! \brief Get the time of day component of the stored timestamp in seconds
     * as a double precision value.
    */
    inline double timeOfDay() const { return XsTimeStamp_timeOfDay(this); }
    /*! \brief Get the time of day component of the stored timestamp in
     * milliseconds
    */
    inline int64_t msTimeOfDay() const
    {
        return m_msTime % (24 * 60 * 60 * 1000);
    }

    /*! \brief Return the time as seconds */
    inline double secTime() const { return ((double)m_msTime) * 0.001; }
    /*! \brief Set the time as seconds */
    inline void setSecTime(double t) { m_msTime = (int64_t)(t * 1000.0); }
    /*! \brief Get the sum of the current and the given \a other timestamp.
     * \param other The value to add to this \returns The added timestamp values
     */
    inline XsTimeStamp operator+(const XsTimeStamp& other) const
    {
        return XsTimeStamp(m_msTime + other.m_msTime);
    }

    /*! \brief Get the current minus the given \a other timestamp. \param other
     * The value to subtract from this \returns The subtracted timestamp values
     */
    inline XsTimeStamp operator-(const XsTimeStamp& other) const
    {
        return XsTimeStamp(m_msTime - other.m_msTime);
    }

    /*! \brief Get the result of adding the given \a other timestamp to the
     * current timestamp. */
    inline XsTimeStamp& operator+=(const XsTimeStamp& other)
    {
        m_msTime += other.m_msTime;
        return *this;
    }

    /*! \brief Get the result of subtracting the given \a other timestamp from
     * the current timestamp. */
    inline XsTimeStamp& operator-=(const XsTimeStamp& d)
    {
        m_msTime -= d.m_msTime;
        return *this;
    }

    /*! \brief Test if the given \a other timestamp is smaller than the current
     * timestamp. */
    inline bool operator<(const XsTimeStamp& other) const
    {
        return m_msTime < other.m_msTime;
    }

    /*! \brief Test if the given \a other timestamp is smaller than or equal to
     * the current timestamp. */
    inline bool operator<=(const XsTimeStamp& other) const
    {
        return m_msTime <= other.m_msTime;
    }

    /*! \brief Test if the given \a other timestamp is equal to the current
     * timestamp. */
    inline bool operator==(const XsTimeStamp& other) const
    {
        return m_msTime == other.m_msTime;
    }

    /*! \brief Test if the given \a other timestamp is larger than the current
     * timestamp. */
    inline bool operator>(const XsTimeStamp& other) const
    {
        return m_msTime > other.m_msTime;
    }

    /*! \brief Test if the given \a other timestamp is larger than or equal to
     * the current timestamp. */
    inline bool operator>=(const XsTimeStamp& other) const
    {
        return m_msTime >= other.m_msTime;
    }

    /*! \brief Test if the given \a other timestamp is not equal to the current
     * timestamp. */
    inline bool operator!=(const XsTimeStamp& other) const
    {
        return m_msTime != other.m_msTime;
    }

    /*! \brief Test if the given \a other is smaller than the current timestamp.
     */
    inline bool operator<(int other) const { return m_msTime < other; }
    /*! \brief Test if the given \a other is smaller than or equal to the
     * current timestamp. */
    inline bool operator<=(int other) const { return m_msTime <= other; }
    /*! \brief Test if the given \a other is equal to the current timestamp. */
    inline bool operator==(int other) const { return m_msTime == other; }
    /*! \brief Test if the given \a other is larger than the current timestamp.
     */
    inline bool operator>(int other) const { return m_msTime > other; }
    /*! \brief Test if the given \a other is larger than or equal to the current
     * timestamp. */
    inline bool operator>=(int other) const { return m_msTime >= other; }
    /*! \brief Test if the given \a other is not equal to the current timestamp.
     */
    inline bool operator!=(int other) const { return m_msTime != other; }
    /*! \brief Returns the number of seconds elapsed since the epoch as stored
     * in the XsTimeStamp */
    inline int64_t secondTime() const { return m_msTime / 1000; }
    /*! \brief Returns the millisecond part of the time (in the range 0-999) */
    inline int32_t milliSecondPart() const
    {
        return (int32_t)(m_msTime % 1000);
    }

    /*! \brief Returns the seconds part of the time (in the range 0-59) */
    inline int32_t secondPart() const
    {
        return (int32_t)((m_msTime / (1000)) % 60);
    }

    /*! \brief Returns the minutes part of the time (in the range 0-59) */
    inline int32_t minutePart() const
    {
        return (int32_t)((m_msTime / (60 * 1000)) % 60);
    }

    /*! \brief Returns the hours part of the time (in the range 0-23) */
    inline int32_t hourPart() const
    {
        return (int32_t)((m_msTime / (60 * 60 * 1000)) % 24);
    }

    /*! \brief Returns the current time in ms since the epoch (Jan 1st 1970) */
    inline static XsTimeStamp now()
    {
        XsTimeStamp tmp;
        XsTimeStamp_now(&tmp);
        return tmp;
    }

    /*! \brief Returns the current time in ms since the epoch (Jan 1st 1970) */
    inline static int64_t nowMs()
    {
        XsTimeStamp tmp;
        XsTimeStamp_now(&tmp);
        return tmp.msTime();
    }

    /*! \brief Returns the maximum value of an %XsTimeStamp */
    inline static XsTimeStamp maxValue()
    {
        return XsTimeStamp(int64_t(9223372036854775807LL));  // INT64_MAX
    }

    /*! \brief Increment the timestamp by one ms, prefix */
    XsTimeStamp operator++() { return XsTimeStamp(++m_msTime); }
    /*! \brief Increment the timestamp by one ms, postfix */
    XsTimeStamp operator++(int) { return XsTimeStamp(m_msTime++); }
    /*! \brief Decrement the timestamp by one ms, prefix */
    XsTimeStamp operator--() { return XsTimeStamp(--m_msTime); }
    /*! \brief Decrement the timestamp by one ms, postfix */
    XsTimeStamp operator--(int) { return XsTimeStamp(m_msTime--); }
   private:
#endif

    /** The timestamp value */
    int64_t m_msTime;
};

typedef struct XsTimeStamp XsTimeStamp;

#endif  // file guard