ZoneProcessor.h

/*
 * MIT License
 * Copyright (c) 2019 Brian T. Park
 */
 
#ifndef ACE_TIME_ZONE_PROCESSOR_H
#define ACE_TIME_ZONE_PROCESSOR_H
 
#include "common/common.h" // kAbbrevSize
#include "OffsetDateTime.h"
 
class Print;
 
namespace ace_time {
 
class LocalDateTime;
 
class FindResult {
  public:
    static const uint8_t kTypeNotFound = 0;
    static const uint8_t kTypeExact = 1;
    static const uint8_t kTypeGap = 2;
    static const uint8_t kTypeOverlap = 3;
 
    uint8_t type = kTypeNotFound;
 
    uint8_t fold = 0;
 
    int32_t stdOffsetSeconds = 0;
 
    int32_t dstOffsetSeconds = 0;
 
    int32_t reqStdOffsetSeconds = 0;
 
    int32_t reqDstOffsetSeconds = 0;
 
    const char* abbrev = "";
};
 
class ZoneProcessor {
  public:
    uint8_t getType() const { return mType; }
 
    virtual bool isLink() const = 0;
 
    virtual uint32_t getZoneId() const = 0;
 
    virtual FindResult findByLocalDateTime(
        const LocalDateTime& ldt) const = 0;
 
    virtual FindResult findByEpochSeconds(
        acetime_t epochSeconds) const = 0;
 
    virtual void printNameTo(Print& printer) const = 0;
 
    virtual void printShortNameTo(Print& printer) const = 0;
 
    virtual void printTargetNameTo(Print& printer) const = 0;
 
    virtual void setZoneKey(uintptr_t zoneKey) = 0;
 
    virtual bool equalsZoneKey(uintptr_t zoneKey) const = 0;
 
  protected:
    friend bool operator==(const ZoneProcessor& a, const ZoneProcessor& b);
 
    // Disable copy constructor and assignment operator.
    ZoneProcessor(const ZoneProcessor&) = delete;
    ZoneProcessor& operator=(const ZoneProcessor&) = delete;
 
    ZoneProcessor(uint8_t type):
      mType(type) {}
 
    bool isFilled(int16_t year) const {
      return year == mYear && mEpochYear == Epoch::currentEpochYear();
    }
 
    virtual bool equals(const ZoneProcessor& other) const = 0;
 
  protected:
    // The order of the fields is optimized to save space on 32-bit processors.
    uint8_t const mType;
 
    mutable int16_t mYear = LocalDate::kInvalidYear;
 
    mutable int16_t mEpochYear = LocalDate::kInvalidYear;
};
 
inline bool operator==(const ZoneProcessor& a, const ZoneProcessor& b) {
  if (a.mType != b.mType) return false;
  return a.equals(b);
}
 
inline bool operator!=(const ZoneProcessor& a, const ZoneProcessor& b) {
  return ! (a == b);
}
 
struct MonthDay {
  uint8_t month;
  uint8_t day;
};
 
MonthDay calcStartDayOfMonth(int16_t year, uint8_t month,
    uint8_t onDayOfWeek, int8_t onDayOfMonth);
 
void createAbbreviation(
    char* dest,
    uint8_t destSize,
    const char* format,
    int32_t stdSeconds,
    int32_t dstSeconds,
    const char* letterString);
 
} // ace_time
 
#endif