time.h

Go to the documentation of this file.

#pragma once
 
#include "esphome/core/defines.h"
 
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <span>
#include <string>
 
#ifdef USE_TIME_TIMEZONE
#include "esphome/components/time/posix_tz.h"
#endif
 
namespace esphome {
 
template<typename T> bool increment_time_value(T &current, uint16_t begin, uint16_t end);
 
uint8_t days_in_month(uint8_t month, uint16_t year);
 
struct ESPTime {
  static constexpr size_t STRFTIME_BUFFER_SIZE = 128;
 
  uint8_t second;
  uint8_t minute;
  uint8_t hour;
  uint8_t day_of_week;
  uint8_t day_of_month;
  uint16_t day_of_year;
  uint8_t month;
  uint16_t year;
  bool is_dst;
  time_t timestamp;
 
  size_t strftime(char *buffer, size_t buffer_len, const char *format);
 
  size_t strftime_to(std::span<char, STRFTIME_BUFFER_SIZE> buffer, const char *format);
 
  std::string strftime(const std::string &format);
 
  std::string strftime(const char *format);
 
  bool is_valid() const { return this->year >= 2019 && this->fields_in_range(); }
 
  bool fields_in_range(bool check_day_of_week = true, bool check_day_of_year = true) const {
    bool valid = this->second < 61 && this->minute < 60 && this->hour < 24 && this->month > 0 && this->month < 13 &&
                 this->day_of_month > 0 && this->day_of_month <= days_in_month(this->month, this->year);
    if (check_day_of_week) {
      valid = valid && this->day_of_week > 0 && this->day_of_week < 8;
    }
    if (check_day_of_year) {
      valid = valid && this->day_of_year > 0 && this->day_of_year < 367;
    }
    return valid;
  }
 
  static bool strptime(const char *time_to_parse, size_t len, ESPTime &esp_time);
  static bool strptime(const char *time_to_parse, ESPTime &esp_time) {
    return strptime(time_to_parse, strlen(time_to_parse), esp_time);
  }
  static bool strptime(const std::string &time_to_parse, ESPTime &esp_time) {
    return strptime(time_to_parse.c_str(), time_to_parse.size(), esp_time);
  }
 
  static ESPTime from_c_tm(struct tm *c_tm, time_t c_time);
 
  static ESPTime from_epoch_local(time_t epoch) {
#ifdef USE_TIME_TIMEZONE
    struct tm local_tm;
    if (time::epoch_to_local_tm(epoch, time::get_global_tz(), &local_tm)) {
      return ESPTime::from_c_tm(&local_tm, epoch);
    }
    // Fallback to UTC if conversion failed
    return ESPTime::from_epoch_utc(epoch);
#else
    // No timezone support - return UTC (no TZ configured, localtime would return UTC anyway)
    return ESPTime::from_epoch_utc(epoch);
#endif
  }
  static ESPTime from_epoch_utc(time_t epoch) {
    struct tm *c_tm = ::gmtime(&epoch);
    if (c_tm == nullptr) {
      return ESPTime{};  // Return an invalid ESPTime
    }
    return ESPTime::from_c_tm(c_tm, epoch);
  }
 
  void recalc_timestamp_utc(bool use_day_of_year = true);
 
  void recalc_timestamp_local();
 
  struct tm to_c_tm();
 
  static int32_t timezone_offset();
 
  void increment_second();
  void increment_day();
  bool operator<(const ESPTime &other) const;
  bool operator<=(const ESPTime &other) const;
  bool operator==(const ESPTime &other) const;
  bool operator>=(const ESPTime &other) const;
  bool operator>(const ESPTime &other) const;
};
}  // namespace esphome