Timestamp.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CORE_TIMESTAMP_HPP_
#define IV_SRC_CORE_TIMESTAMP_HPP_
 
#include "core/constants.hpp"
#include "core/defines.hpp"
#include "core/enums.hpp"
#include "core/structs.hpp"
 
#include <chrono>
#include <iostream>
#include <locale>
 
namespace iv::time
{
 
class Timestamp
{
public:
    Timestamp() : m_timestamp(std::chrono::system_clock::now())
    {
    }
 
    explicit Timestamp(const iv::types::timestamp milliseconds)
        : m_timestamp(std::chrono::time_point<std::chrono::system_clock>(std::chrono::milliseconds(milliseconds)))
    {
    }
 
    explicit Timestamp(const std::chrono::time_point<std::chrono::system_clock> &timestamp) : m_timestamp(timestamp)
    {
    }
 
    Timestamp(const Timestamp &other) = default;
 
    Timestamp(Timestamp &&other) noexcept : m_timestamp(other.m_timestamp)
    {
    }
 
    Timestamp &operator=(const Timestamp &other)
    {
        if (this != &other)
        {
            m_timestamp = other.m_timestamp;
        }
 
        return *this;
    }
 
    Timestamp &operator=(Timestamp &&other) noexcept
    {
        if (this != &other)
        {
            m_timestamp = other.m_timestamp;
        }
 
        return *this;
    }
 
    bool operator<(const Timestamp &other) const
    {
        return m_timestamp < other.m_timestamp;
    }
 
    bool operator>(const Timestamp &other) const
    {
        return m_timestamp > other.m_timestamp;
    }
 
    bool operator<=(const Timestamp &other) const
    {
        return m_timestamp <= other.m_timestamp;
    }
 
    bool operator>=(const Timestamp &other) const
    {
        return m_timestamp >= other.m_timestamp;
    }
 
    bool operator==(const Timestamp &other) const
    {
        return m_timestamp == other.m_timestamp;
    }
 
    bool operator!=(const Timestamp &other) const
    {
        return m_timestamp != other.m_timestamp;
    }
 
    Timestamp operator+(const std::chrono::seconds &seconds) const
    {
        return Timestamp(m_timestamp + seconds);
    }
 
    Timestamp operator-(const std::chrono::seconds &seconds) const
    {
        return Timestamp(m_timestamp - seconds);
    }
 
    Timestamp operator+(const iv::types::timestamp &milliseconds) const
    {
        return Timestamp(inMilliseconds() + milliseconds);
    }
 
    Timestamp operator-(const iv::types::timestamp &milliseconds) const
    {
        return Timestamp(inMilliseconds() - milliseconds);
    }
 
    void setTime(const std::chrono::time_point<std::chrono::system_clock> time = std::chrono::system_clock::now())
    {
        m_timestamp = time;
    }
 
    void setTime(const iv::types::timestamp milliseconds)
    {
        m_timestamp = std::chrono::time_point<std::chrono::system_clock>(std::chrono::milliseconds(milliseconds));
    }
 
    Timestamp &setLomsTime(uint16_t numDaysSince1984, uint32_t milliseconds);
    void getLomsTime(uint16_t &numDaysSince1984, uint32_t &milliseconds) const;
 
    void now()
    {
        m_timestamp = std::chrono::system_clock::now();
    }
 
    void roundToNextMinute()
    {
        iv::types::timestamp dateTime {inMilliseconds()};
 
        dateTime -= (dateTime % iv::constants::time::MillisecondsInMinutes);
        dateTime += iv::constants::time::MillisecondsInMinutes;
 
        setTime(dateTime);
    }
 
    [[nodiscard]] iv::types::milliseconds inMilliseconds() const
    {
        return static_cast<iv::types::timestamp>(
                std::chrono::duration_cast<std::chrono::milliseconds>(m_timestamp.time_since_epoch()).count());
    }
 
    [[nodiscard]] int64_t inSeconds() const
    {
        return std::chrono::duration_cast<std::chrono::seconds>(m_timestamp.time_since_epoch()).count();
    }
 
    [[nodiscard]] iv::DateTime getDateTime(const iv::eTimeZone timeZone = iv::eTimeZone::Localtime) const
    {
        const std::time_t time = std::chrono::system_clock::to_time_t(m_timestamp);
        std::tm timeInfo {};
 
        switch (timeZone)
        {
            case iv::eTimeZone::Gmt:
                gmtime_r(&time, &timeInfo);
                break;
 
            case iv::eTimeZone::Localtime:
                localtime_r(&time, &timeInfo);
                break;
 
            default:
                break;
        }
 
        iv::DateTime dt {};
        dt.year = static_cast<uint16_t>(timeInfo.tm_year + 1900);
        dt.month = static_cast<uint16_t>(timeInfo.tm_mon + 1);
        dt.day = static_cast<uint16_t>(timeInfo.tm_mday);
        dt.hour = static_cast<uint16_t>(timeInfo.tm_hour);
        dt.minute = static_cast<uint16_t>(timeInfo.tm_min);
        dt.second = static_cast<uint16_t>(timeInfo.tm_sec);
 
        return dt;
    }
 
private:
    std::chrono::time_point<std::chrono::system_clock> m_timestamp;
};
 
}// namespace iv::time
 
#endif//IV_SRC_CORE_TIMESTAMP_HPP_