ZonedClock.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef _TIME_SHIELD_ZONED_CLOCK_HPP_INCLUDED
#define _TIME_SHIELD_ZONED_CLOCK_HPP_INCLUDED

 
#include "config.hpp"
#include "constants.hpp"
#include "DateTime.hpp"
#include "enums.hpp"
#include "time_parser.hpp"
#include "time_utils.hpp"
#include "time_zone_conversions.hpp"
#include "time_zone_offset_conversions.hpp"
 
#if TIME_SHIELD_ENABLE_NTP_CLIENT
#   include "ntp_time_service.hpp"
#endif
 
#include <cstddef>
#include <stdexcept>
#include <string>
 
namespace time_shield {

    class ZonedClock final {
    public:
        ZonedClock() noexcept
            : m_zone(UNKNOWN)
            , m_offset(0)
            , m_is_named_zone(false)
            , m_use_ntp(false) {}

        explicit ZonedClock(TimeZone zone, bool use_ntp = false) noexcept
            : m_zone(UNKNOWN)
            , m_offset(0)
            , m_is_named_zone(false)
            , m_use_ntp(use_ntp) {
            set_zone(zone);
        }

        explicit ZonedClock(tz_t utc_offset, bool use_ntp = false)
            : m_zone(UNKNOWN)
            , m_offset(0)
            , m_is_named_zone(false)
            , m_use_ntp(use_ntp) {
            if (!try_set_offset(utc_offset)) {
                throw std::invalid_argument("Invalid UTC offset");
            }
        }

        static bool try_from_offset(tz_t utc_offset, ZonedClock& out) noexcept {
            ZonedClock candidate;
            if (!candidate.try_set_offset(utc_offset)) {
                return false;
            }
            out = candidate;
            return true;
        }

        void set_zone(TimeZone zone) noexcept {
            if (zone == UNKNOWN) {
                m_zone = UNKNOWN;
                m_offset = 0;
                m_is_named_zone = false;
                return;
            }
 
            m_zone = zone;
            m_offset = 0;
            m_is_named_zone = true;
        }

        bool try_set_offset(tz_t utc_offset) noexcept {
            if (!is_valid_tz_offset(utc_offset)) {
                return false;
            }
 
            m_zone = UNKNOWN;
            m_offset = utc_offset;
            m_is_named_zone = false;
            return true;
        }

        bool try_set_zone(const std::string& zone_spec) noexcept {
            const std::string trimmed = trim_ascii(zone_spec);
            if (trimmed.empty()) {
                return false;
            }
 
            TimeZone parsed_zone = UNKNOWN;
            if (parse_time_zone_name(trimmed, parsed_zone)) {
                set_zone(parsed_zone);
                return true;
            }
 
            TimeZoneStruct parsed_offset = create_time_zone_struct(0, 0, true);
            if (!parse_time_zone(trimmed, parsed_offset)) {
                return false;
            }
 
            return try_set_offset(time_zone_struct_to_offset(parsed_offset));
        }

        void set_use_ntp(bool use_ntp) noexcept {
            m_use_ntp = use_ntp;
        }

        bool has_named_zone() const noexcept {
            return m_is_named_zone;
        }

        TimeZone zone() const noexcept {
            return m_is_named_zone ? m_zone : UNKNOWN;
        }

        bool use_ntp() const noexcept {
            return m_use_ntp;
        }

        bool ntp_active() const noexcept {
#if TIME_SHIELD_ENABLE_NTP_CLIENT
            return m_use_ntp && NtpTimeService::instance().running();
#else
            return false;
#endif
        }

        tz_t offset_now() const noexcept {
            return offset_at_utc_ms(current_utc_ms());
        }

        tz_t offset_at_utc_ms(ts_ms_t utc_ms) const noexcept {
            tz_t offset = 0;
            return try_offset_at_utc_ms(utc_ms, offset) ? offset : 0;
        }

        bool try_offset_at_utc_ms(ts_ms_t utc_ms, tz_t& out) const noexcept {
            if (utc_ms == ERROR_TIMESTAMP) {
                return false;
            }
 
            if (!m_is_named_zone) {
                out = m_offset;
                return true;
            }
 
            return zone_offset_at_utc_ms(utc_ms, m_zone, out);
        }

        LocalTimeResolution resolve_local_time_ms(ts_ms_t local_ms) const noexcept {
            if (local_ms == ERROR_TIMESTAMP) {
                LocalTimeResolution result = {
                    LocalTimeStatus::unsupported,
                    ERROR_TIMESTAMP,
                    ERROR_TIMESTAMP
                };
                return result;
            }
 
            if (m_is_named_zone) {
                return time_shield::resolve_local_time_ms(local_ms, m_zone);
            }
 
            LocalTimeResolution result = {
                LocalTimeStatus::valid,
                time_shield::to_utc_ms(local_ms, m_offset),
                ERROR_TIMESTAMP
            };
            return result;
        }

        ts_ms_t to_utc_ms(
            ts_ms_t local_ms,
            AmbiguousTimePolicy ambiguous_policy = AmbiguousTimePolicy::error,
            NonexistentTimePolicy nonexistent_policy =
                NonexistentTimePolicy::error) const noexcept {
            if (m_is_named_zone) {
                return zone_to_gmt_ms(local_ms,
                                      m_zone,
                                      ambiguous_policy,
                                      nonexistent_policy);
            }
 
            return time_shield::to_utc_ms(local_ms, m_offset);
        }

        ts_t utc_time_sec() const noexcept {
            return static_cast<ts_t>(current_utc_us() / US_PER_SEC);
        }

        ts_ms_t utc_time_ms() const noexcept {
            return current_utc_ms();
        }

        ts_us_t utc_time_us() const noexcept {
            return current_utc_us();
        }

        ts_t local_time_sec() const noexcept {
            const ts_t utc_sec = utc_time_sec();
            return utc_sec + static_cast<ts_t>(offset_at_utc_ms(static_cast<ts_ms_t>(utc_sec) * MS_PER_SEC));
        }

        ts_ms_t local_time_ms() const noexcept {
            const ts_ms_t utc_ms = current_utc_ms();
            return utc_ms + static_cast<ts_ms_t>(offset_at_utc_ms(utc_ms)) * MS_PER_SEC;
        }

        ts_us_t local_time_us() const noexcept {
            const ts_us_t utc_us = current_utc_us();
            return utc_us + static_cast<ts_us_t>(offset_at_utc_ms(static_cast<ts_ms_t>(utc_us / MS_PER_SEC))) * US_PER_SEC;
        }

        DateTime now() const noexcept {
            return from_utc_ms(current_utc_ms());
        }

        DateTime from_utc_ms(ts_ms_t utc_ms) const noexcept {
            return DateTime::from_unix_ms(utc_ms, offset_at_utc_ms(utc_ms));
        }

        DateTime from_utc_s(ts_t utc_s) const noexcept {
            return from_utc_ms(static_cast<ts_ms_t>(utc_s) * MS_PER_SEC);
        }

        std::string zone_name() const {
            return m_is_named_zone ? std::string(to_cstr(m_zone)) : std::string();
        }

        std::string zone_full_name() const {
            if (m_is_named_zone) {
                return to_str(m_zone, FULL_NAME);
            }
            return std::string("UTC") + offset_string_for_offset(m_offset);
        }

        std::string offset_string() const {
            return offset_string_for_offset(offset_now());
        }

        std::string to_iso8601() const {
            return now().to_iso8601();
        }

        std::string to_iso8601_utc() const {
            return now().to_iso8601_utc();
        }

        std::string format(const std::string& fmt) const {
            return now().format(fmt);
        }
 
    private:
        static std::string trim_ascii(const std::string& value) {
            std::size_t begin = 0;
            std::size_t end = value.size();
            while (begin < end && is_ascii_space(value[begin])) {
                ++begin;
            }
            while (end > begin && is_ascii_space(value[end - 1])) {
                --end;
            }
            return value.substr(begin, end - begin);
        }
 
        static bool is_ascii_space(char ch) noexcept {
            return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\f' || ch == '\v';
        }
 
        static std::string offset_string_for_offset(tz_t utc_offset) {
            return time_zone_struct_to_string(to_time_zone_struct(utc_offset));
        }
 
        ts_ms_t current_utc_ms() const noexcept {
            return static_cast<ts_ms_t>(current_utc_us() / 1000);
        }
 
        ts_us_t current_utc_us() const noexcept {
#if TIME_SHIELD_ENABLE_NTP_CLIENT
            if (m_use_ntp) {
                if (!NtpTimeService::instance().running()) {
                    (void)ntp::init(30000, true);
                }
                return static_cast<ts_us_t>(ntp::utc_time_us());
            }
#endif
            return static_cast<ts_us_t>(now_realtime_us());
        }
 
    private:
        TimeZone m_zone;
        tz_t m_offset;
        bool m_is_named_zone;
        bool m_use_ntp;
    };
 
} // namespace time_shield
 
#endif // _TIME_SHIELD_ZONED_CLOCK_HPP_INCLUDED