TimeZone.h

/*
 * MIT License
 * Copyright (c) 2018 Brian T. Park
 */
 
#ifndef ACE_TIME_TIME_ZONE_H
#define ACE_TIME_TIME_ZONE_H
 
#include <stdint.h> // uintptr_t
#include "TimeOffset.h"
#include "ZoneProcessor.h"
#include "BasicZoneProcessor.h"
#include "ExtendedZoneProcessor.h"
#include "CompleteZoneProcessor.h"
#include "TimeZoneData.h"
#include "ZonedExtra.h"
 
class Print;
 
namespace ace_time {
 
class TimeZone {
  public:
    static const uint8_t kTypeError = 0;
 
    static const uint8_t kTypeManual = 1;
 
    static const uint8_t kTypeReserved = 2;
 
    static TimeZone forUtc() {
      return TimeZone();
    }
 
    static TimeZone forTimeOffset(
        TimeOffset stdOffset,
        TimeOffset dstOffset = TimeOffset()
    ) {
      return TimeZone(stdOffset, dstOffset);
    }
 
    static TimeZone forHours(int8_t stdHours, int8_t dstHours = 0) {
      return TimeZone::forTimeOffset(
          TimeOffset::forHours(stdHours),
          TimeOffset::forHours(dstHours)
      );
    }
 
    static TimeZone forMinutes(int16_t stdMinutes, int16_t dstMinutes = 0) {
      return TimeZone::forTimeOffset(
          TimeOffset::forMinutes(stdMinutes),
          TimeOffset::forMinutes(dstMinutes)
      );
    }
 
    static TimeZone forHourMinute(
        int8_t stdHour,
        int8_t stdMinute,
        int8_t dstHour = 0,
        int8_t dstMinute = 0
    ) {
      return TimeZone::forTimeOffset(
          TimeOffset::forHourMinute(stdHour, stdMinute),
          TimeOffset::forHourMinute(dstHour, dstMinute)
      );
    }
 
    static TimeZone forZoneInfo(
        const basic::Info::ZoneInfo* zoneInfo,
        BasicZoneProcessor* zoneProcessor
    ) {
      return TimeZone(
          zoneProcessor->getType(),
          (uintptr_t) zoneInfo,
          zoneProcessor
      );
    }
 
    static TimeZone forZoneInfo(
        const extended::Info::ZoneInfo* zoneInfo,
        ExtendedZoneProcessor* zoneProcessor
    ) {
      return TimeZone(
          zoneProcessor->getType(),
          (uintptr_t) zoneInfo,
          zoneProcessor
      );
    }
 
    static TimeZone forZoneInfo(
        const complete::Info::ZoneInfo* zoneInfo,
        CompleteZoneProcessor* zoneProcessor
    ) {
      return TimeZone(
          zoneProcessor->getType(),
          (uintptr_t) zoneInfo,
          zoneProcessor
      );
    }
 
    static TimeZone forZoneKey(uintptr_t zoneKey, ZoneProcessor* processor) {
      return TimeZone(processor->getType(), zoneKey, processor);
    }
 
    static TimeZone forError() {
      return TimeZone(kTypeError);
    }
 
    TimeZone():
        mType(kTypeManual),
        mStdOffsetMinutes(0),
        mDstOffsetMinutes(0) {}
 
    uint8_t getType() const { return mType; }
 
    TimeOffset getStdOffset() const {
      return TimeOffset::forMinutes(mStdOffsetMinutes);
    }
 
    TimeOffset getDstOffset() const {
      return TimeOffset::forMinutes(mDstOffsetMinutes);
    }
 
    bool isLink() const {
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
        case kTypeManual:
          return false;
 
        default:
          return getBoundZoneProcessor()->isLink();
      }
    }
 
    uint32_t getZoneId() const {
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
        case kTypeManual:
          return 0;
 
        default:
          return getBoundZoneProcessor()->getZoneId();
      }
    }
 
    bool isError() const { return mType == kTypeError; }
 
    ZonedExtra getZonedExtra(const LocalDateTime& ldt) const {
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
          return ZonedExtra::forError();
 
        case kTypeManual:
          const char* abbrev;
          if (isUtc()) {
            abbrev = "UTC";
          } else {
            abbrev = (mDstOffsetMinutes != 0) ? "DST" : "STD";
          }
          return ZonedExtra(
              ZonedExtra::kTypeExact,
              mStdOffsetMinutes * 60,
              mDstOffsetMinutes * 60,
              mStdOffsetMinutes * 60,
              mDstOffsetMinutes * 60,
              abbrev);
 
        default: {
          FindResult result = getBoundZoneProcessor()->findByLocalDateTime(ldt);
          if (result.type == FindResult::kTypeNotFound) {
            return ZonedExtra::forError();
          }
          return ZonedExtra(
            result.type, // ZonedExtra::type is identical to FindResult::type
            result.stdOffsetSeconds,
            result.dstOffsetSeconds,
            result.reqStdOffsetSeconds,
            result.reqDstOffsetSeconds,
            result.abbrev);
        }
      }
    }
 
    ZonedExtra getZonedExtra(acetime_t epochSeconds) const {
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
          return ZonedExtra::forError();
 
        case kTypeManual:
          const char* abbrev;
          if (isUtc()) {
            abbrev = "UTC";
          } else {
            abbrev = (mDstOffsetMinutes != 0) ? "DST" : "STD";
          }
          return ZonedExtra(
              ZonedExtra::kTypeExact,
              mStdOffsetMinutes * 60,
              mDstOffsetMinutes * 60,
              mStdOffsetMinutes * 60,
              mDstOffsetMinutes * 60,
              abbrev);
 
        default: {
          FindResult result =
              getBoundZoneProcessor()->findByEpochSeconds(epochSeconds);
          if (result.type == FindResult::kTypeNotFound) {
            return ZonedExtra::forError();
          }
          return ZonedExtra(
            result.type, // ZonedExtra::type is identical to FindResult::type
            result.stdOffsetSeconds,
            result.dstOffsetSeconds,
            result.reqStdOffsetSeconds,
            result.reqDstOffsetSeconds,
            result.abbrev);
        }
      }
    }
 
    OffsetDateTime getOffsetDateTime(const LocalDateTime& ldt) const {
      OffsetDateTime odt = OffsetDateTime::forError();
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
          break;
 
        case kTypeManual:
          odt = OffsetDateTime::forLocalDateTimeAndOffset(
              ldt,
              TimeOffset::forMinutes(mStdOffsetMinutes + mDstOffsetMinutes));
          break;
 
        default: {
          FindResult result = getBoundZoneProcessor()->findByLocalDateTime(ldt);
          if (result.type == FindResult::kTypeNotFound) {
            break;
          }
 
          // Convert FindResult into OffsetDateTime using the requested offset.
          TimeOffset reqOffset = TimeOffset::forSeconds(
              result.reqStdOffsetSeconds + result.reqDstOffsetSeconds);
          odt = OffsetDateTime::forLocalDateTimeAndOffset(ldt, reqOffset);
          odt.fold(result.fold);
 
          // Special processing for kTypeGap: Convert to epochSeconds using the
          // reqStdOffsetMinutes and reqDstOffsetMinutes, then convert back to
          // OffsetDateTime using the target stdOffsetMinutes and
          // dstOffsetMinutes.
          if (result.type == FindResult::kTypeGap) {
            acetime_t epochSeconds = odt.toEpochSeconds();
            TimeOffset targetOffset = TimeOffset::forSeconds(
                result.stdOffsetSeconds + result.dstOffsetSeconds);
            odt = OffsetDateTime::forEpochSeconds(epochSeconds, targetOffset);
          }
          break;
        }
      }
      return odt;
    }
 
    OffsetDateTime getOffsetDateTime(acetime_t epochSeconds) const {
      OffsetDateTime odt = OffsetDateTime::forError();
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
          break;
 
        case kTypeManual:
          odt = OffsetDateTime::forEpochSeconds(
              epochSeconds,
              TimeOffset::forMinutes(mStdOffsetMinutes + mDstOffsetMinutes));
          break;
 
        default: {
          FindResult result =
              getBoundZoneProcessor()->findByEpochSeconds(epochSeconds);
          if (result.type == FindResult::kTypeNotFound) {
            break;
          }
 
          TimeOffset offset = TimeOffset::forSeconds(
              result.reqStdOffsetSeconds + result.reqDstOffsetSeconds);
          odt = OffsetDateTime::forEpochSeconds(
              epochSeconds, offset, result.fold);
          break;
        }
      }
      return odt;
    }
 
    bool isUtc() const {
      if (mType != kTypeManual) return false;
      return mStdOffsetMinutes == 0 && mDstOffsetMinutes == 0;
    }
 
    bool isDst() const {
      if (mType != kTypeManual) return false;
      return mDstOffsetMinutes != 0;
    }
 
    TimeZoneData toTimeZoneData() const {
      TimeZoneData d;
      switch (mType) {
        case kTypeError:
        case kTypeReserved:
          d.type = TimeZoneData::kTypeError;
          break;
 
        case TimeZone::kTypeManual:
          d.stdOffsetMinutes = mStdOffsetMinutes;
          d.dstOffsetMinutes = mDstOffsetMinutes;
          d.type = TimeZoneData::kTypeManual;
          break;
 
        default:
          d.zoneId = getZoneId();
          d.type = TimeZoneData::kTypeZoneId;
          break;
      }
      return d;
    }
 
    void printTo(Print& printer) const;
 
    void printShortTo(Print& printer) const;
 
    void printTargetNameTo(Print& printer) const;
 
    // Use default copy constructor and assignment operator.
    TimeZone(const TimeZone&) = default;
    TimeZone& operator=(const TimeZone&) = default;
 
  private:
    friend bool operator==(const TimeZone& a, const TimeZone& b);
 
    explicit TimeZone(TimeOffset stdOffset, TimeOffset dstOffset):
      mType(kTypeManual),
      mStdOffsetMinutes(stdOffset.toMinutes()),
      mDstOffsetMinutes(dstOffset.toMinutes()) {}
 
    explicit TimeZone(uint8_t type):
      mType(type) {}
 
    explicit TimeZone(
        uint8_t type,
        uintptr_t zoneKey,
        ZoneProcessor* zoneProcessor
    ):
        mType(type),
        mZoneKey(zoneKey),
        mZoneProcessor(zoneProcessor)
    {}
 
    ZoneProcessor* getBoundZoneProcessor() const {
      mZoneProcessor->setZoneKey(mZoneKey);
      return mZoneProcessor;
    }
 
  private:
    uint8_t mType;
 
    // 3 combinations:
    //   (kTypeError)
    //   (kTypeManual, mStdOffsetMinutes, mDstOffsetMinutes)
    //   (type, mZoneKey, mZoneProcessor)
    union {
      struct {
        int16_t mStdOffsetMinutes;
        int16_t mDstOffsetMinutes;
      };
 
      struct {
        uintptr_t mZoneKey;
 
        ZoneProcessor* mZoneProcessor;
      };
    };
};
 
inline bool operator==(const TimeZone& a, const TimeZone& b) {
  if (a.mType != b.mType) return false;
  switch (a.mType) {
    case TimeZone::kTypeError:
    case TimeZone::kTypeReserved:
      return true;
 
    case TimeZone::kTypeManual:
      return a.mStdOffsetMinutes == b.mStdOffsetMinutes
          && a.mDstOffsetMinutes == b.mDstOffsetMinutes;
 
    default:
      return (a.mZoneKey == b.mZoneKey);
  }
}
 
inline bool operator!=(const TimeZone& a, const TimeZone& b) {
  return ! (a == b);
}
 
}
 
#endif