iso_week_conversions.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef TIME_SHIELD_HEADER_CONVERSIONS_ISO_WEEK_CONVERSIONS_HPP_INCLUDED
#define TIME_SHIELD_HEADER_CONVERSIONS_ISO_WEEK_CONVERSIONS_HPP_INCLUDED
 
 
#include <time_shield/core.hpp>
#include "date_conversions.hpp"
#include "date_time_conversions.hpp"
#include "time_unit_conversions.hpp"
 
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <inttypes.h>
#include <stdexcept>
#include <string>
 
namespace time_shield {
 
 
    TIME_SHIELD_CONSTEXPR inline int iso_weekday_from_weekday(Weekday weekday) noexcept {
        return static_cast<int>((static_cast<int>(weekday) + DAYS_PER_WEEK - 1) % DAYS_PER_WEEK) + 1;
    }
 
    template<class Y = year_t, class M = Month, class D = int>
    TIME_SHIELD_CONSTEXPR inline int iso_weekday_of_date(Y year, M month, D day) {
        return iso_weekday_from_weekday(day_of_week_date<Weekday>(year, month, day));
    }
 
    template<class Y = year_t, class M = Month, class D = int>
    inline IsoWeekDateStruct to_iso_week_date(Y year, M month, D day) {
        const int iso_weekday = iso_weekday_of_date(year, month, day);
        const dse_t unix_day = date_to_unix_day(year, month, day);
        const dse_t thursday_day = unix_day + static_cast<dse_t>(4 - iso_weekday);
 
        const DateTimeStruct thursday_date = to_date_time<DateTimeStruct>(unix_day_to_ts(thursday_day));
        const year_t iso_year = thursday_date.year;
 
        const dse_t jan4_day = date_to_unix_day(iso_year, 1, 4);
        const int jan4_iso_weekday = iso_weekday_of_date(iso_year, 1, 4);
        const dse_t first_thursday = jan4_day + static_cast<dse_t>(4 - jan4_iso_weekday);
 
        const int32_t week = static_cast<int32_t>((thursday_day - first_thursday) / DAYS_PER_WEEK + 1);
        return create_iso_week_date_struct(iso_year, week, static_cast<int32_t>(iso_weekday));
    }
 
    inline IsoWeekDateStruct to_iso_week_date(const DateStruct& date) {
        return to_iso_week_date(date.year, date.mon, date.day);
    }
 
    template<class T = ts_t>
    inline IsoWeekDateStruct to_iso_week_date(T ts) {
        const DateTimeStruct date_time = to_date_time<DateTimeStruct, T>(ts);
        return to_iso_week_date(date_time.year, date_time.mon, date_time.day);
    }
 
    inline int iso_weeks_in_year(year_t iso_year) {
        const IsoWeekDateStruct info = to_iso_week_date(iso_year, 12, 28);
        return static_cast<int>(info.week);
    }
 
    inline bool is_valid_iso_week_date(year_t iso_year, int week, int weekday) {
        if (iso_year < MIN_YEAR) return false;
        if (iso_year > MAX_YEAR) return false;
        if (weekday < 1 || weekday > 7) return false;
        if (week < 1) return false;
        const int max_week = iso_weeks_in_year(iso_year);
        return week <= max_week;
    }
 
    inline DateStruct iso_week_date_to_date(const IsoWeekDateStruct& iso_date) {
        if (!is_valid_iso_week_date(iso_date.year, iso_date.week, iso_date.weekday)) {
            throw std::invalid_argument("Invalid ISO week date");
        }
 
        const dse_t jan4_day = date_to_unix_day(iso_date.year, 1, 4);
        const int jan4_iso_weekday = iso_weekday_of_date(iso_date.year, 1, 4);
        const dse_t first_thursday = jan4_day + static_cast<dse_t>(4 - jan4_iso_weekday);
        const dse_t target_thursday = first_thursday + static_cast<dse_t>(iso_date.week - 1) * DAYS_PER_WEEK;
        const dse_t target_day = target_thursday + static_cast<dse_t>(iso_date.weekday - 4);
 
        const DateTimeStruct date_time = to_date_time<DateTimeStruct>(unix_day_to_ts(target_day));
        return create_date_struct(date_time.year, date_time.mon, date_time.day);
    }
 
    inline std::string format_iso_week_date(const IsoWeekDateStruct& iso_date, bool extended = true, bool include_weekday = true) {
        const bool has_valid_year = iso_date.year >= MIN_YEAR && iso_date.year <= MAX_YEAR;
        const bool has_valid_week = has_valid_year && iso_date.week >= 1 && iso_date.week <= iso_weeks_in_year(iso_date.year);
        const bool has_valid_weekday = iso_date.weekday >= 1 && iso_date.weekday <= 7;
        if (!has_valid_year || !has_valid_week || (include_weekday && !has_valid_weekday)) {
            throw std::invalid_argument("Invalid ISO week date");
        }
 
        if (!include_weekday) {
            const char* fmt = extended ? "%" PRId64 "-W%.2d" : "%" PRId64 "W%.2d";
            char buffer[32] = {0};
            std::snprintf(buffer, sizeof(buffer), fmt, iso_date.year, iso_date.week);
            return std::string(buffer);
        }
 
        const char* fmt = extended ? "%" PRId64 "-W%.2d-%d" : "%" PRId64 "W%.2d%d";
        char buffer[32] = {0};
        std::snprintf(buffer, sizeof(buffer), fmt, iso_date.year, iso_date.week, iso_date.weekday);
        return std::string(buffer);
    }
 
    inline bool parse_iso_week_date(const char* input, std::size_t length, IsoWeekDateStruct& iso_date) noexcept {
        if (input == nullptr) {
            return false;
        }
 
        iso_date = create_iso_week_date_struct(0, 0, 0);
 
        const char* p = input;
        const char* const end = input + length;
 
        bool negative = false;
        if (p < end && (*p == '+' || *p == '-')) {
            negative = (*p == '-');
            ++p;
        }
 
        const char* start_digits = p;
        int64_t value = 0;
        while (p < end && std::isdigit(static_cast<unsigned char>(*p)) != 0) {
            value = value * 10 + static_cast<int64_t>(*p - '0');
            ++p;
        }
 
        if (p == start_digits) return false;
        iso_date.year = negative ? -value : value;
 
        if (p >= end) return false;
 
        const bool has_dash_after_year = (*p == '-');
        if (has_dash_after_year) {
            ++p;
            if (p >= end) return false;
        }
 
        if (*p != 'W' && *p != 'w') return false;
        ++p;
 
        int week = 0;
        for (int i = 0; i < 2; ++i) {
            if (p >= end || std::isdigit(static_cast<unsigned char>(*p)) == 0) return false;
            week = week * 10 + (*p - '0');
            ++p;
        }
 
        if (week == 0) return false;
 
        bool has_weekday = false;
        if (p < end) {
            if ((*p == '-' && has_dash_after_year) || (!has_dash_after_year && std::isdigit(static_cast<unsigned char>(*p)) == 0)) {
                if (*p == '-') ++p;
                if (p >= end) return false;
                if (std::isdigit(static_cast<unsigned char>(*p)) == 0) return false;
                iso_date.weekday = *p - '0';
                ++p;
                has_weekday = true;
            } else if (std::isdigit(static_cast<unsigned char>(*p)) != 0) {
                iso_date.weekday = *p - '0';
                ++p;
                has_weekday = true;
            }
        }
 
        if (!has_weekday) {
            iso_date.weekday = 1;
        }
 
        iso_date.week = week;
 
        if (p != end) return false;
        return is_valid_iso_week_date(iso_date.year, iso_date.week, iso_date.weekday);
    }
 
    inline bool parse_iso_week_date(const std::string& input, IsoWeekDateStruct& iso_date) noexcept {
        return parse_iso_week_date(input.c_str(), input.size(), iso_date);
    }
 
    inline bool try_parse_iso_week_date(const char* input, std::size_t length, IsoWeekDateStruct& iso_date) noexcept {
        return parse_iso_week_date(input, length, iso_date);
    }
 
    inline bool try_parse_iso_week_date(const std::string& input, IsoWeekDateStruct& iso_date) noexcept {
        return parse_iso_week_date(input, iso_date);
    }
 
 
}; // namespace time_shield
 
#endif // TIME_SHIELD_HEADER_CONVERSIONS_ISO_WEEK_CONVERSIONS_HPP_INCLUDED