Timezone.h

Go to the documentation of this file.

/****
 * Timezone.h - Time Zone support library
 *
 * Original code (c) Jack Christensen Mar 2012
 * Arduino Timezone Library Copyright (C) 2018 by Jack Christensen and
 * licensed under GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
 *
 * This file is part of the Timezone Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 * @author mikee47 <mike@sillyhouse.net>
 * July 2018 Ported to Sming
 * May 2024 Added Posix TZ string and IANA database support
 *
 ****/
 
#pragma once
 
#include <ZonedTime.h>
#include <Print.h>
#include <limits>
 
namespace TZ
{
enum week_t {
    First,
    Second,
    Third,
    Fourth,
    Last,
};
 
enum dow_t {
    Sun = 0,
    Mon,
    Tue,
    Wed,
    Thu,
    Fri,
    Sat,
};
 
enum month_t {
    Jan = 0,
    Feb,
    Mar,
    Apr,
    May,
    Jun,
    Jul,
    Aug,
    Sep,
    Oct,
    Nov,
    Dec,
};
 
static constexpr time_t minTime = std::max(-5364662400LL, (long long)std::numeric_limits<time_t>::min() + 1);
 
static constexpr time_t maxTime = std::min(253402300799LL, (long long)std::numeric_limits<time_t>::max() - 1);
 
static constexpr time_t invalidTime = maxTime + 1;
 
struct Rule {
    struct Time {
        int16_t minutes;
 
        constexpr Time(float hours = 0) : minutes(hours * MINS_PER_HOUR)
        {
        }
    };
 
    using Tag = DateTime::ZoneInfo::Tag;
    Tag tag; 
    week_t week : 4;
    dow_t dow : 4;
    month_t month : 8;
    Time time;
    int16_t offsetMins; 
 
    int offsetSecs() const
    {
        return int(offsetMins) * SECS_PER_MIN;
    }
 
    time_t operator()(unsigned year) const;
 
    explicit operator int() const
    {
        return (month << 6) | (week << 3) | dow;
    }
 
    bool operator==(const Rule& other) const
    {
        return this == &other || memcmp(this, &other, sizeof(other)) == 0;
    }
 
    bool operator!=(const Rule& other) const
    {
        return !operator==(other);
    }
 
    static const Rule UTC;
};
 
#ifndef __WIN32
static_assert(sizeof(Rule) == 12, "Rule size unexpected");
#endif
 
class Timezone
{
public:
    Timezone()
    {
    }
 
    Timezone(const Rule& dstStart, const Rule& stdStart)
        : dstRule(dstStart), stdRule(stdStart), hasDst(dstRule.tag[0] && dstRule != stdRule)
    {
    }
 
    explicit Timezone(const Rule& std) : dstRule(std), stdRule(std), hasDst(false)
    {
    }
 
    void init(const Rule& dstStart, const Rule& stdStart) SMING_DEPRECATED
    {
        *this = Timezone(dstStart, stdStart);
    }
 
    static Timezone fromPosix(const char* tzstr);
 
    static Timezone fromPosix(const String& tzstr)
    {
        return fromPosix(tzstr.c_str());
    }
    explicit operator bool() const
    {
        return *stdRule.tag != '\0';
    }
 
    time_t toLocal(time_t utc, const Rule** rule = nullptr);
 
    ZonedTime makeZoned(time_t utc, bool beforeTransition = false);
 
    ZonedTime toUTC(time_t local);
 
    bool utcIsDST(time_t utc);
 
    bool locIsDST(time_t local);
 
    const char* timeTag(bool isDst) const
    {
        return isDst ? dstRule.tag : stdRule.tag;
    }
 
    const char* utcTimeTag(time_t utc)
    {
        return timeTag(utcIsDST(utc));
    }
 
    const char* localTimeTag(time_t local)
    {
        return timeTag(locIsDST(local));
    }
 
    ZonedTime getNextChange(time_t utcFrom);
 
    ZonedTime getTransition(uint16_t year, bool toDst);
 
    const Rule& getRule(bool isDst) const
    {
        return isDst ? dstRule : stdRule;
    }
 
    bool hasDaylightSavings() const
    {
        return hasDst;
    }
 
    String toString() const;
 
    size_t printTo(Print& p) const;
 
private:
    /*
     * Calculate the DST and standard time change points for the given
     * given year as local and UTC time_t values.
     */
    void calcTimeChanges(unsigned yr);
 
private:
    Rule dstRule{};                  
    Rule stdRule{};                  
    time_t dstStartUTC{invalidTime}; 
    time_t stdStartUTC{invalidTime}; 
    bool hasDst{};                   
};
 
} // namespace TZ
 
String toString(TZ::week_t week);
 
using Timezone = TZ::Timezone;
using TimeChangeRule SMING_DEPRECATED = TZ::Rule;