Timestamp.hpp

//
// Copyright (c) 2004-2023 TIBCO Software Inc.  All rights reserved.
//

#ifndef STREAMBASE_TIMESTAMP_H
#define STREAMBASE_TIMESTAMP_H

#include "StreamBase.hpp"

#include <time.h>
#include "Exceptions.hpp"
#include <NMSTL/ntime.hpp>
#include <NMSTL/platform.hpp>

SB_NAMESPACE_BEGIN;
class Timestamp;
SB_NAMESPACE_END;

SB_INTERNAL_FWD(TimestampTest);
SB_INTERNAL_FWD(TimestampUtil);
SB_INTERNAL_FWD(Errors);


#ifndef DOXYGEN_SKIP
NMSTL_NAMESPACE_BEGIN;
inline sb::Timestamp getUnaligned(const sb::Timestamp *p);
inline void setUnaligned(sb::Timestamp *p, sb::Timestamp value);
NMSTL_NAMESPACE_END;
#endif //DOXYGEN_SKIP


SB_NAMESPACE_BEGIN;

/// Attempted to parse an invalid Timestamp string.
STREAMBASE_EXCEPTION_TYPE(TimestampException, sb_internal::Errors::NON_FATAL_ERROR);
/// Class for representing moments in time and intervals at
/// millisecond granularity.
class Timestamp
{
  private:
    enum TIMESTAMPTYPE { TIMESTAMP = 0, INTERVAL = 1 };
    enum TIMESTAMP_FIELD {YEAR, MONTH, DAY, HOUR, MINUTE, SECOND};
    // Field. Measures milliseconds since the start of the Unix epoch.
    struct MS {
#ifdef sparc
        // swap order for sparc
        long long int value : 63;
        long long int type : 1;
#else
        long long int type : 1;
        long long int value : 63;
#endif
    };

  public:
    static const int MIN_YEAR = 1400;
    static const int MAX_YEAR = 9999;
    static const int MIN_MONTH = 1;
    static const int MAX_MONTH = 12;
    static const int MIN_DAY = 1;
    static const int MAX_DAY = 31;
    static const int MIN_HOUR = 0;
    static const int MAX_HOUR = 23;
    static const int MIN_MINUTE = 0;
    static const int MAX_MINUTE = 59;
    static const int MIN_SECOND = 0;
    static const int MAX_SECOND = 59;
    
    /// Create a default Timestamp.
    /// Will initialized to 00:00:00 1 Jan 1970.
    Timestamp()
    {
        _ms.type = TIMESTAMP;
        _ms.value = 0;
    }

    /// Return a Timestamp representing the current moment in time.
    static Timestamp now();

    /// Negate an interval to return an interval.  Negate a timestamp
    /// to return a timestamp, even though that doesn't make much sense.
    Timestamp operator-() const;

    /// Subtract two Timestamps to return an interval. Subtract two
    /// intervals to return an interval. Subtract an interval from a
    /// Timestamp to return a Timestamp.
    Timestamp operator-(const Timestamp &rhs) const;

    /// Add a Timestamp and an interval to get a Timestamp. Add two
    /// intervals to return an interval.
    Timestamp operator+(const Timestamp &rhs) const;

    /// Increment the Timestamp by the interval.
    Timestamp &operator+=(const Timestamp &rhs);

    /// Decrement the Timestamp by the interval.
    Timestamp &operator-=(const Timestamp &rhs);

    /// Multiply a Timestamp representing an interval by a constant.
    template<typename T>
    Timestamp operator*(T rhs) const {
        MS t = makeMS((TIMESTAMPTYPE)_ms.type, (long long int)(_ms.value * rhs));
        return Timestamp(t);
    }
    /// Multiply a Timestamp representing an interval by a constant.
    template<typename T>
    Timestamp &operator*=(T rhs) {
        *this = *this * rhs;
        return *this;
    }
    /// Divide a Timestamp representing an interval by a constant.
    template<typename T>
    Timestamp operator/(T rhs) const {
        MS t = makeMS((TIMESTAMPTYPE)_ms.type, (long long int)(_ms.value / rhs));
        return Timestamp(t);
    }
    /// Divide a Timestamp representing an interval by a constant.
    template<typename T>
    Timestamp &operator/=(T rhs) {
        *this = *this / rhs;
        return *this;
    }

    /// Divide two Timestamps representing an interval to find their
    /// quotient.
    double operator/(Timestamp rhs) const {
        return (double)_ms.value / (double)rhs._ms.value;
    }

    /// Modulo a Timestamp by an interval.
    Timestamp operator%(const Timestamp &rhs) const {
        MS t = makeMS(INTERVAL, _ms.value % rhs._ms.value);
        return Timestamp(t);
    }

    /// Modulo a Timestamp by an interval.
    Timestamp operator%=(const Timestamp &rhs) {
        *this = *this % rhs;
        return *this;
    }

    /// Return true if this Timestamp is before rhs.
    bool operator<(const Timestamp &rhs) const {
            return (_ms.value < rhs._ms.value);
    }
    /// Return true if this Timestamp is before or at the same time as
    /// rhs.
    bool operator<=(const Timestamp &rhs) const {
            return (_ms.value <= rhs._ms.value);
    }
    /// Return true if this Timestamp is at the same time as rhs.
    bool operator==(const Timestamp &rhs) const {
            return (_ms.value == rhs._ms.value);
    }
    /// Return true if this Timestamp is not at the same time as rhs.
    bool operator!=(const Timestamp &rhs) const {
            return (_ms.value != rhs._ms.value);
    }
    /// Return true if this Timestamp is after or at the same time as
    /// rhs.
    bool operator>=(const Timestamp &rhs) const {
            return (_ms.value >= rhs._ms.value);
    }
    /// Return true if this Timestamp is after rhs.
    bool operator>(const Timestamp &rhs) const {
            return (_ms.value > rhs._ms.value);
    }
    
    /// Return true if this Timestamp is an interval.
    bool isInterval() const {
        return (_ms.type != TIMESTAMP);
    }

    /// Create a time from a count of milliseconds.
    static Timestamp milliseconds(long long milliseconds) {
        MS t = makeMS(INTERVAL, milliseconds);
        return Timestamp(t);
    }

    /// Create a time from a count of seconds.
    template<typename T>
    static Timestamp seconds(T seconds) {
        MS t = makeMS(INTERVAL, ((long long)(seconds * THOUSAND)));
        return Timestamp(t);
    }
    /// Create a time from a count of seconds.
    static Timestamp seconds(double seconds) {
        double roundingValue = seconds > 0 ? 0.5 : -0.5;
        MS t = makeMS(INTERVAL, ((long long)(seconds * THOUSAND + roundingValue)));
        return Timestamp(t);
    }

    /// Construct an interval from minutes
    template<typename T>
    static Timestamp minutes(T minutes) {
        MS t = makeMS(INTERVAL, ((long long)minutes) * MILLISECONDS_PER_MINUTE);
        return Timestamp(t);
    }
    /// Construct an interval from minutes
    static Timestamp minutes(double minutes) {
        double roundingValue = minutes > 0 ? 0.5 : -0.5;
        MS t = makeMS(INTERVAL, (long long int)(minutes * MILLISECONDS_PER_MINUTE + roundingValue));
        return Timestamp(t);
    }

    /// Construct an interval from hours
    template<typename T>
    static Timestamp hours(T hours) {
        MS t = makeMS(INTERVAL, ((long long)hours) * MILLISECONDS_PER_HOUR);
        return Timestamp(t);
    }
    /// Construct an interval from hours
    static Timestamp hours(double hours) {
        double roundingValue = hours > 0 ? 0.5 : -0.5;
        MS t = makeMS(INTERVAL, (long long int)(hours * MILLISECONDS_PER_HOUR + roundingValue));
        return Timestamp(t);
    }

    /// Construct an interval from days
    template<typename T>
    static Timestamp days(T days) {
        MS t = makeMS(INTERVAL, ((long long)days) * MILLISECONDS_PER_DAY);
        return Timestamp(t);
    }
    /// Construct an interval from days
    static Timestamp days(double days) {
        double roundingValue = days > 0 ? 0.5 : -0.5;
        MS t = makeMS(INTERVAL, (long long int)(days * MILLISECONDS_PER_DAY + roundingValue));
        return Timestamp(t);
    }

    /// Construct an interval from weeks
    template<typename T>
    static Timestamp weeks(T weeks) {
        MS t = makeMS(INTERVAL, ((long long)weeks)  * MILLISECONDS_PER_DAY * DAYS_PER_WEEK);
        return Timestamp(t);
    }
    /// Construct an interval from weeks
    static Timestamp weeks(double weeks) {
        double roundingValue = weeks > 0 ? 0.5 : -0.5;
        MS t = makeMS(INTERVAL, (long long int)(weeks * MILLISECONDS_PER_DAY * DAYS_PER_WEEK + roundingValue));
        return Timestamp(t);
    }

    /// Return the time as milliseconds.
    long long toMsecs() const {
        return _ms.value;
    }

    /// Return the time as seconds
    long long toSecs() const {
        return _ms.value / THOUSAND;
    }

    /// compare 2 timestamps
    /// return less than zero this < other
    /// return greater than zero this > other
    /// return 0 if they are the same
    int compare(const Timestamp &other) const {
        assert(_ms.type == other._ms.type);
        if(_ms.value < other._ms.value) { return -1; }
        if(_ms.value > other._ms.value) { return 1; }
        return 0;
    }

    /// Return seconds after the minute
    double getSecond() const;

    /// Return milliseconds after the second
    double getMillisecond() const;

    /// Return minutes after hour
    int getMinute() const;

    /// Return hours since midnight
    int getHour() const;

    /// Return day since Sunday
    int getDayOfWeek() const;

    /// Return day of month
    int getDayOfMonth() const;

    /// Return month since January
    int getMonth() const;

    /// Return year
    int getYear() const;

    /// Set seconds after the minute
    void setSecond(double seconds);

    /// Set minutes after the hour
    void setMinute(int minutes);

    /// Set hours since midnight
    void setHour(int hours);

    /// Set day of month
    void setDayOfMonth(int day_of_month);

    /// Set month since January
    void setMonth(int month);

    /// Set year
    void setYear(int year);

    /// Return a human readable string rep of this Timestamp
    std::string as_string(bool displayTimezone=true) const;

private:
    friend class sb_internal::TimestampTest;

    /// Set an arbitrary Timestamp field
    void setField(TIMESTAMP_FIELD, int *value);

    // Constants for use in our math when dealing with timevals.
    static const long long MILLISECONDS_PER_MINUTE = 60000LL;
    static const long long MILLISECONDS_PER_HOUR = 3600000LL;
    static const long long MILLISECONDS_PER_DAY = 86400000LL;
    static const long long DAYS_PER_WEEK = 7LL;
    static const long long THOUSAND = 1000LL;
    static const long long MILLION = 1000000LL;

    MS _ms;

    static MS makeMS(TIMESTAMPTYPE t, long long v);

    // Private constructor from a long long int.
    explicit Timestamp(MS ms)
    { _ms = ms;}

    static bool validateTimestampFields(
        int year,
        int month,
        int day,
        int hour,
        int minute,
        int second);

    Timestamp(long long int ts, int type=TIMESTAMP)
    {
        _ms.type = type;
        _ms.value = ts;
    }

    // Routines for dealing with potentially unaligned Timestamps.  On
    // SPARC, copy an int at a time; on Intel, read/write directly.
#ifdef sparc
    union MSAndInts {
        Timestamp::MS ms;
        struct { int i1; int i2; };
    };

    inline static Timestamp
    getUnaligned(const Timestamp *p)
    {
        const int *dip = (const int*)p;
        MSAndInts di;
        di.i1 = dip[0];
        di.i2 = dip[1];
        return Timestamp(di.ms);
    }

    inline static void
    setUnaligned(Timestamp *p, Timestamp value)
    {
        int *dip = (int*)p;
        MSAndInts di;
        di.ms = value._ms;
        dip[0] = di.i1;
        dip[1] = di.i2;
    }
#else
    // Intel
    inline static Timestamp getUnaligned(const Timestamp *p) { return *p; }
    inline static void setUnaligned(Timestamp *p, Timestamp value) { *p = value; }
#endif

    friend class sb_internal::TimestampUtil;

#ifndef DOXYGEN_SKIP
    friend sb::Timestamp NMSTL::getUnaligned(const sb::Timestamp *p);
    friend void NMSTL::setUnaligned(sb::Timestamp *p, sb::Timestamp value);
#endif

    // constants to be used in conjunction with the cpu counter to determine current time more efficiently
    static const long long RESOLUTION_PER_SEC = 1000LL;    // time resolution units = milliseconds
    static const long long MIN_SYSTEM_INTERVAL = 10LL;     // min system synchronization time interval = 10ms 
    static const long long MAX_SYSTEM_INTERVAL = 100LL;    // max system synchronization time interval = 100ms 
    static const unsigned long long TICKS_PER_SEC;         // computed from cpu frequency
    static const unsigned long long TICKS_PER_RESOLUTION;  // computed from cpu frequency
    
    // thread local storage to be used in conjunction with the cpu counter to determine current time more efficiently
#ifndef sun
#ifndef SWIG
    static SB_THREAD_LOCAL unsigned long long systemTicks;    
    static SB_THREAD_LOCAL long long systemTime;
    static SB_THREAD_LOCAL long long systemInterval;
    static SB_THREAD_LOCAL long long lastTimestamp;
#endif  // SWIG
#endif  // sun
    static unsigned long long initCpuTicksPerSecond();
    
    static unsigned long long cpuTicks();
};

inline unsigned long long Timestamp::cpuTicks()
{
    unsigned int low, high;

#ifdef sparc
    asm volatile ("rd %%tick, %%g1; srlx %%g1, 32, %1" : "=r" (low), "=r" (high));
#else
#if defined(WIN32)
LARGE_INTEGER timestamp;

#if defined(_WIN64)
        QueryPerformanceCounter(&timestamp);
#else
        _asm 
        {
                rdtsc
                        mov timestamp.LowPart, EAX
                        mov timestamp.HighPart, EDX
        }
#endif /*WIN64*/

high = timestamp.HighPart;
low = timestamp.LowPart;

#else /*WIN32*/
    asm volatile ("rdtsc" : "=a" (low), "=d" (high));
#endif
#endif
    return ((unsigned long long)high<<32) + low;
};

SB_NAMESPACE_END;

#ifndef DOXYGEN_SKIP
NMSTL_NAMESPACE_BEGIN;

inline sb::Timestamp getUnaligned(const sb::Timestamp *p)
{
    return sb::Timestamp::getUnaligned(p);
}

inline void setUnaligned(sb::Timestamp *p, sb::Timestamp value)
{
    sb::Timestamp::setUnaligned(p, value);
}

NMSTL_NAMESPACE_END;
#endif //DOXYGEN_SKIP

#endif

//  LocalWords:  StreamBase NMSTL ntime Timestamp timevals timeval tm TODO rhs
//  LocalWords:  gettimeofday