BasicZoneProcessor.h

/*
 * MIT License
 * Copyright (c) 2019 Brian T. Park
 */
 
#ifndef ACE_TIME_BASIC_ZONE_PROCESSOR_H
#define ACE_TIME_BASIC_ZONE_PROCESSOR_H
 
#include <stdint.h>
#include <AceCommon.h> // strncpy_T()
#include "../zoneinfo/infos.h"
#include "../zoneinfo/brokers.h"
#include "common/common.h" // kAbbrevSize
#include "common/logging.h"
#include "TimeOffset.h"
#include "LocalDate.h"
#include "OffsetDateTime.h"
#include "ZoneProcessor.h"
 
#ifndef ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG
#define ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG 0
#endif
 
class BasicZoneProcessorTest_priorYearOfRule;
class BasicZoneProcessorTest_compareRulesBeforeYear;
class BasicZoneProcessorTest_findLatestPriorRule;
class BasicZoneProcessorTest_findZoneEra;
class BasicZoneProcessorTest_init_primitives;
class BasicZoneProcessorTest_initForLocalDate;
class BasicZoneProcessorTest_setZoneKey;
class BasicZoneProcessorTest_calcRuleOffsetMinutes;
 
class Print;
 
namespace ace_time {
namespace basic {
 
template <typename ZIB, typename ZEB, typename ZPB, typename ZRB>
struct TransitionTemplate {
  ZEB era;
 
  ZRB rule;
 
  acetime_t startEpochSeconds;
 
  int16_t offsetMinutes;
 
  int16_t deltaMinutes;
 
  int16_t year;
 
  uint8_t month;
 
  char abbrev[internal::kAbbrevSize];
 
  void log() const {
    if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
      logging::printf("(%d/%d)", year, month);
      if (sizeof(acetime_t) == sizeof(int)) {
        logging::printf("; stEps: %d", startEpochSeconds);
      } else {
        logging::printf("; stEps: %ld", startEpochSeconds);
      }
      logging::printf("; offMin: %d", offsetMinutes);
      logging::printf("; abbrev: %s", abbrev);
      if (! rule.isNull()) {
        logging::printf("; r.fromYear: %d", rule.fromYear());
        logging::printf("; r.toYear: %d", rule.toYear());
        logging::printf("; r.inMonth: %d", rule.inMonth());
        logging::printf("; r.onDayOfMonth: %d", rule.onDayOfMonth());
      }
      logging::printf("\n");
    }
  }
};
 
inline int8_t compareYearMonth(int16_t aYear, uint8_t aMonth,
    int16_t bYear, uint8_t bMonth) {
  if (aYear < bYear) return -1;
  if (aYear > bYear) return 1;
  if (aMonth < bMonth) return -1;
  if (aMonth > bMonth) return 1;
  return 0;
}
 
} // namespace basic
 
template <typename ZIS, typename ZIB, typename ZEB, typename ZPB, typename ZRB>
class BasicZoneProcessorTemplate: public ZoneProcessor {
  public:
    typedef basic::TransitionTemplate<ZIB, ZEB, ZPB, ZRB> Transition;
 
    bool isLink() const override {
      return ! mZoneInfoBroker.targetInfo().isNull();
    }
 
    uint32_t getZoneId() const override {
      return mZoneInfoBroker.zoneId();
    }
 
    FindResult findByLocalDateTime(
        const LocalDateTime& ldt) const override {
      FindResult result;
      bool success = initForLocalDate(ldt.localDate());
      if (!success) return result;
 
      // 0) Use the UTC epochSeconds to get intial guess of offset.
      acetime_t epochSeconds0 = ldt.toEpochSeconds();
      auto result0 = findByEpochSeconds(epochSeconds0);
      if (result0.type == FindResult::kTypeNotFound) return result;
      auto offset0 = TimeOffset::forSeconds(
          result0.reqStdOffsetSeconds + result0.reqDstOffsetSeconds);
 
      // 1) Use offset0 to get the next epochSeconds and offset.
      auto odt = OffsetDateTime::forLocalDateTimeAndOffset(ldt, offset0);
      acetime_t epochSeconds1 = odt.toEpochSeconds();
      auto result1 = findByEpochSeconds(epochSeconds1);
      if (result1.type == FindResult::kTypeNotFound) return result;
      auto offset1 = TimeOffset::forSeconds(
          result1.reqStdOffsetSeconds + result1.reqDstOffsetSeconds);
 
      // 2) Use offset1 to get the next epochSeconds and offset.
      odt = OffsetDateTime::forLocalDateTimeAndOffset(ldt, offset1);
      acetime_t epochSeconds2 = odt.toEpochSeconds();
      auto result2 = findByEpochSeconds(epochSeconds2);
      if (result2.type == FindResult::kTypeNotFound) return result;
      auto offset2 = TimeOffset::forSeconds(
          result2.reqStdOffsetSeconds + result2.reqDstOffsetSeconds);
 
      // If offset1 and offset2 are equal, then we have an equilibrium
      // and odt(1) must equal odt(2).
      if (offset1 == offset2) {
        // I think this happens for kTypeExact or kTypeOverlap, but the current
        // algorithm cannot distinguish between the two, so let's pretend that
        // it is kTypeExact. Pick either of result1 or result2.
        result = result1;
      } else {
        // If the offsets don't match, then I think we have a kTypeGap.
        // Pick the stdOffset and dstOffset that generate the later epochSeconds
        // (the earlier transition), but convert into the LocalDateTime of the
        // earlier epochSeconds (the later transition).
        if (epochSeconds1 > epochSeconds2) {
          result = result1;
        } else {
          result = result2;
        }
        result.type = FindResult::kTypeGap;
      }
 
      return result;
    }
 
    FindResult findByEpochSeconds(acetime_t epochSeconds) const override {
      FindResult result;
      const Transition* transition = getTransition(epochSeconds);
      if (!transition) return result;
 
      result.dstOffsetSeconds = transition->deltaMinutes * kSecPerMin;
      result.stdOffsetSeconds = transition->offsetMinutes * kSecPerMin;
      result.reqStdOffsetSeconds = result.stdOffsetSeconds;
      result.reqDstOffsetSeconds = result.dstOffsetSeconds;
      result.type = FindResult::kTypeExact;
      result.abbrev = transition->abbrev;
 
      return result;
    }
 
    void printNameTo(Print& printer) const override {
      mZoneInfoBroker.printNameTo(printer);
    }
 
    void printShortNameTo(Print& printer) const override {
      mZoneInfoBroker.printShortNameTo(printer);
    }
 
    void printTargetNameTo(Print& printer) const override {
      if (isLink()) {
        mZoneInfoBroker.targetInfo().printNameTo(printer);
      }
    }
 
    void setZoneKey(uintptr_t zoneKey) override {
      if (! mZoneInfoStore) return;
      if (mZoneInfoBroker.equals(zoneKey)) return;
 
      mZoneInfoBroker = mZoneInfoStore->createZoneInfoBroker(zoneKey);
      mYear = LocalDate::kInvalidYear;
      mNumTransitions = 0;
    }
 
    bool equalsZoneKey(uintptr_t zoneKey) const override {
      return mZoneInfoBroker.equals(zoneKey);
    }
 
    void log() const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("BasicZoneProcessor:\n");
        logging::printf("  mEpochYear: %d\n", mEpochYear);
        logging::printf("  mYear: %d\n", mYear);
        logging::printf("  mNumTransitions: %d\n", mNumTransitions);
        for (int i = 0; i < mNumTransitions; i++) {
          logging::printf("  mT[%d]=", i);
          mTransitions[i].log();
        }
      }
    }
 
    void setZoneInfoStore(const ZIS* zoneInfoStore) {
      mZoneInfoStore = zoneInfoStore;
    }
 
  protected:
 
    explicit BasicZoneProcessorTemplate(
        uint8_t type,
        const ZIS* zoneInfoStore /*nullable*/,
        uintptr_t zoneKey
    ) :
        ZoneProcessor(type),
        mZoneInfoStore(zoneInfoStore)
    {
      setZoneKey(zoneKey);
    }
 
  private:
    friend class ::BasicZoneProcessorTest_priorYearOfRule;
    friend class ::BasicZoneProcessorTest_compareRulesBeforeYear;
    friend class ::BasicZoneProcessorTest_findLatestPriorRule;
    friend class ::BasicZoneProcessorTest_findZoneEra;
    friend class ::BasicZoneProcessorTest_init_primitives;
    friend class ::BasicZoneProcessorTest_initForLocalDate;
    friend class ::BasicZoneProcessorTest_setZoneKey;
    friend class ::BasicZoneProcessorTest_calcRuleOffsetMinutes;
 
    static const uint8_t kMaxCacheEntries = 5;
 
    static const acetime_t kMinEpochSeconds = INT32_MIN + 1;
 
    // Disable copy constructor and assignment operator.
    BasicZoneProcessorTemplate(const BasicZoneProcessorTemplate&) = delete;
    BasicZoneProcessorTemplate& operator=(const BasicZoneProcessorTemplate&) =
        delete;
 
    bool equals(const ZoneProcessor& other) const override {
      return mZoneInfoBroker.equals(
          ((const BasicZoneProcessorTemplate&) other).mZoneInfoBroker);
    }
 
    const Transition* getTransition(acetime_t epochSeconds) const {
      bool success = initForEpochSeconds(epochSeconds);
      return (success) ? findMatch(epochSeconds) : nullptr;
    }
 
    bool initForLocalDate(const LocalDate& ld) const {
      int16_t year = ld.year();
      if (ld.month() == 1 && ld.day() == 1) {
        year--;
      }
      // Restrict to [1,9999], even though LocalDate should be able to handle
      // [0,10000].
      if (year <= LocalDate::kMinYear || LocalDate::kMaxYear <= year) {
        return false;
      }
 
      if (isFilled(year)) return true;
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("initForLocalDate(): %d (new year %d)\n",
            ld.year(), year);
      }
 
      mYear = year;
      mEpochYear = Epoch::currentEpochYear();
      mNumTransitions = 0; // clear cache
 
      ZEB priorEra = addTransitionPriorToYear(year);
      ZEB currentEra = addTransitionsForYear(year, priorEra);
      addTransitionAfterYear(year, currentEra);
      calcTransitions();
      calcAbbreviations();
 
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        log();
      }
 
      return true;
    }
 
    bool initForEpochSeconds(acetime_t epochSeconds) const {
      LocalDate ld = LocalDate::forEpochSeconds(epochSeconds);
      return initForLocalDate(ld);
    }
 
    ZEB addTransitionPriorToYear(int16_t year) const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("addTransitionPriorToYear(): %d\n", year);
      }
 
      const ZEB era = findZoneEra(mZoneInfoBroker, year - 1);
 
      // If the prior ZoneEra has a ZonePolicy), then find the latest rule
      // within the ZoneEra. Otherwise, add a Transition using a rule==nullptr.
      ZRB latest = findLatestPriorRule(era.zonePolicy(), year);
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("addTransitionsPriorToYear(): adding latest prior ");
        if (latest.isNull()) {
          logging::printf("ZR(null)\n");
        } else {
          logging::printf("ZR[%d,%d]\n", latest.fromYear(), latest.toYear());
        }
      }
      addTransition(year - 1, 0 /*month*/, era, latest);
 
      return era;
    }
 
    static ZRB findLatestPriorRule(const ZPB& zonePolicy, int16_t year) {
      ZRB latest;
      if (zonePolicy.isNull()) return latest;
 
      uint8_t numRules = zonePolicy.numRules();
      for (uint8_t i = 0; i < numRules; i++) {
        const ZRB rule = zonePolicy.rule(i);
        // Check if rule is effective prior to the given year
        if (rule.fromYear() < year) {
          if ((latest.isNull()) ||
              compareRulesBeforeYear(year, rule, latest) > 0) {
            latest = rule;
          }
        }
      }
 
      return latest;
    }
 
    static int8_t compareRulesBeforeYear(
        int16_t year, const ZRB& a, const ZRB& b) {
      return basic::compareYearMonth(
          priorYearOfRule(year, a), a.inMonth(),
          priorYearOfRule(year, b), b.inMonth());
    }
 
    static int16_t priorYearOfRule(int16_t year, const ZRB& rule) {
      if (rule.toYear() < year) {
        return rule.toYear();
      }
      return year - 1;
    }
 
    ZEB addTransitionsForYear(int16_t year, const ZEB& priorEra) const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("addTransitionsForYear(): %d\n", year);
      }
 
      const ZEB era = findZoneEra(mZoneInfoBroker, year);
 
      // If the ZonePolicy has no rules, then add a Transition which takes
      // effect at the start time of the current year.
      const ZPB zonePolicy = era.zonePolicy();
      if (zonePolicy.isNull()) {
        if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
          logging::printf("addTransitionsForYear(): adding ZE.untilY=%d\n",
              era.untilYear());
        }
        addTransition(year, 0 /*month*/, era, ZRB());
        return era;
      }
 
      if (! era.equals(priorEra)) {
        // The ZoneEra has changed, so we need to find the Rule in effect at
        // the start of the current year of the current ZoneEra. This may be a
        // rule far in the past, but shift the rule forward to {year, 1, 1}.
        ZRB latestPrior = findLatestPriorRule(era.zonePolicy(), year);
        if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
          logging::printf(
              "addTransitionsForYear(): adding latest prior ");
          if (latestPrior.isNull()) {
            logging::printf("ZR(null)\n");
          } else {
            logging::printf("ZR[%d,%d]\n",
              latestPrior.fromYear(), latestPrior.toYear());
          }
        }
        addTransition(year, 1 /*month*/, era, latestPrior);
      }
 
      // Find all directly matching transitions (i.e. the [from, to] overlap
      // with the current year) and add them to mTransitions, in sorted order
      // according to the ZoneRule::inMonth field.
      uint8_t numRules = zonePolicy.numRules();
      for (uint8_t i = 0; i < numRules; i++) {
        const ZRB rule = zonePolicy.rule(i);
        if ((rule.fromYear() <= year) && (year <= rule.toYear())) {
          if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
            logging::printf(
                "addTransitionsForYear(): adding rule ");
            if (rule.isNull()) {
              logging::printf("ZR(null)\n");
            } else {
              logging::printf("ZR[%d,%d]\n", rule.fromYear(), rule.toYear());
            }
          }
          addTransition(year, 0 /*month*/, era, rule);
        }
      }
 
      return era;
    }
 
    void addTransitionAfterYear(int16_t year, const ZEB& currentEra) const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("addTransitionAfterYear(): %d\n", year);
      }
 
      const ZEB eraAfter = findZoneEra(mZoneInfoBroker, year + 1);
 
      // If the current era is the same as the following year, then we'll just
      // assume that the latest ZoneRule carries over to Jan 1st of the next
      // year. tzcompiler.py guarantees no ZoneRule occurs on Jan 1st.
      if (currentEra.equals(eraAfter)) {
        return;
      }
 
      // If the ZoneEra did change, find the latest transition prior to
      // {year + 1, 1, 1}, then shift that Transition to Jan 1st of the
      // following year.
      ZRB latest = findLatestPriorRule(eraAfter.zonePolicy(), year + 1);
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf(
            "addTransitionsAfterYear(): adding latest prior ");
        if (latest.isNull()) {
          logging::printf("ZR(null)\n");
        } else {
          logging::printf("ZR[%d,%d]\n", latest.fromYear(), latest.toYear());
        }
      }
      addTransition(year + 1, 1 /*month*/, eraAfter, latest);
    }
 
    void addTransition(int16_t year, uint8_t month, const ZEB& era,
          const ZRB& rule) const {
 
      // If a zone needs more transitions than kMaxCacheEntries, the check below
      // will cause the DST transition information to be inaccurate, and it is
      // highly likely that this situation would be caught in the
      // AceTimeValidation tests. Since these integration tests pass, I feel
      // confident that those zones which need more than kMaxCacheEntries are
      // already filtered out by tzcompiler.py.
      //
      // Ideally, the tzcompiler.py script would explicitly remove those zones
      // which need more than kMaxCacheEntries Transitions. But this would
      // require a Python version of the BasicZoneProcessor, and unfortunately,
      // zone_processor.py implements only the ExtendedZoneProcessor algorithm
      // An early version of zone_processor.py may have implemented something
      // close to BasicZoneProcessor, and it may be available in the git
      // history. But it seems like too much work right now to try to dig that
      // out, just to implement the explicit check for kMaxCacheEntries. It
      // would mean maintaining another version of zone_processor.py.
      if (mNumTransitions >= kMaxCacheEntries) return;
 
      // Insert new element at the end of the list.
      // NOTE: It is probably tempting to pass a pointer (or reference) to
      // mTransitions[mNumTransitions] into createTransition(), instead of
      // returning it by value. However, MemoryBenchmark shows that directly
      // updating the Transition through the pointer increases flash memory
      // consumption by ~110 bytes on AVR processors. It seems that creating a
      // local copy of Transition on the stack, filling it, and then copying it
      // by value takes fewer instructions.
      mTransitions[mNumTransitions] = createTransition(year, month, era, rule);
      mNumTransitions++;
 
      // perform an insertion sort based on ZoneRule.inMonth()
      for (uint8_t i = mNumTransitions - 1; i > 0; i--) {
        Transition& left = mTransitions[i - 1];
        Transition& right = mTransitions[i];
        // assume only 1 rule per month
        if (basic::compareYearMonth(left.year, left.month,
            right.year, right.month) > 0) {
          Transition tmp = left;
          left = right;
          right = tmp;
        }
      }
    }
 
    static Transition createTransition(int16_t year, uint8_t month,
        const ZEB& era, const ZRB& rule) {
 
      Transition transition;
      int16_t deltaMinutes;
      uint8_t mon;
      if (rule.isNull()) {
        mon = 1; // RULES is either '-' or 'hh:mm' so takes effect in Jan
        deltaMinutes = era.deltaSeconds() / kSecPerMin;
        transition.abbrev[0] = '\0';
      } else {
        mon = rule.inMonth();
        deltaMinutes = rule.deltaSeconds() / kSecPerMin;
        ace_common::strncpy_T(
            transition.abbrev, rule.letter(), internal::kAbbrevSize - 1);
        transition.abbrev[internal::kAbbrevSize - 1] = '\0';
      }
      // Clobber the month if specified.
      if (month != 0) {
        mon = month;
      }
      int16_t offsetMinutes = era.offsetSeconds() / kSecPerMin;
 
      transition.era = era;
      transition.rule = rule;
      transition.startEpochSeconds = 0;
      transition.offsetMinutes = offsetMinutes;
      transition.deltaMinutes = deltaMinutes;
      transition.year = year;
      transition.month = mon;
      return transition;
    }
 
    static ZEB findZoneEra(const ZIB& info, int16_t year) {
      for (uint8_t i = 0; i < info.numEras(); i++) {
        const ZEB era = info.era(i);
        if (year < era.untilYear()) return era;
      }
      // Return the last ZoneEra if we run off the end.
      return info.era(info.numEras() - 1);
    }
 
    void calcTransitions() const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("calcTransitions():\n");
      }
 
      // Set the initial startEpochSeconds to be -Infinity
      Transition* prevTransition = &mTransitions[0];
      prevTransition->startEpochSeconds = kMinEpochSeconds;
 
      for (uint8_t i = 1; i < mNumTransitions; i++) {
        Transition& transition = mTransitions[i];
        const int16_t year = transition.year;
 
        if (transition.rule.isNull()) {
          // If the transition is simple (has no named rule), then the
          // ZoneEra applies for the entire year (since BasicZoneProcessor
          // supports only whole year in the UNTIL field). The whole year UNTIL
          // field has an implied 'w' suffix on 00:00, we don't need to call
          // calcRuleOffsetMinutes() with a 'w', we can just use the previous
          // transition's offset to calculate the startDateTime of this
          // transition.
          //
          // Also, when transition.rule == nullptr, the mNumTransitions should
          // be 1, since only a single transition is added by
          // addTransitionsForYear().
          const int16_t prevTotalOffsetMinutes = prevTransition->offsetMinutes
              + prevTransition->deltaMinutes;
          OffsetDateTime startDateTime = OffsetDateTime::forComponents(
              year, 1, 1, 0, 0, 0,
              TimeOffset::forMinutes(prevTotalOffsetMinutes));
          transition.startEpochSeconds = startDateTime.toEpochSeconds();
        } else {
          // In this case, the transition points to a named ZonePolicy, which
          // means that there could be multiple ZoneRules associated with the
          // given year. For each transition, determine the startEpochSeconds,
          // and the effective offset time.
 
          // Determine the start date of the rule.
          const internal::MonthDay monthDay = internal::calcStartDayOfMonth(
              year, transition.month, transition.rule.onDayOfWeek(),
              transition.rule.onDayOfMonth());
 
          // Determine the offset of the 'atTimeSuffix'. The 'w' suffix
          // requires the offset of the previous transition.
          const int16_t prevTotalOffsetMinutes = calcRuleOffsetMinutes(
              prevTransition->offsetMinutes + prevTransition->deltaMinutes,
              transition.era.offsetSeconds() / kSecPerMin,
              transition.rule.atTimeSuffix());
 
          // startDateTime
          const uint16_t minutes = transition.rule.atTimeSeconds() / 60;
          const uint8_t atHour = minutes / 60;
          const uint8_t atMinute = minutes % 60;
          OffsetDateTime startDateTime = OffsetDateTime::forComponents(
              year, monthDay.month, monthDay.day,
              atHour, atMinute, 0 /*second*/,
              TimeOffset::forMinutes(prevTotalOffsetMinutes));
          transition.startEpochSeconds = startDateTime.toEpochSeconds();
        }
 
        prevTransition = &transition;
      }
    }
 
    static int16_t calcRuleOffsetMinutes(int16_t prevTotalOffsetMinutes,
        int16_t currentBaseOffsetMinutes, uint8_t atSuffix) {
      if (atSuffix == basic::ZoneContext::kSuffixW) {
        return prevTotalOffsetMinutes;
      } else if (atSuffix == basic::ZoneContext::kSuffixS) {
        return currentBaseOffsetMinutes;
      } else { // 'u', 'g' or 'z'
        return 0;
      }
    }
 
    void calcAbbreviations() const {
      if (ACE_TIME_BASIC_ZONE_PROCESSOR_DEBUG) {
        logging::printf("calcAbbreviations():\n");
      }
 
      for (uint8_t i = 0; i < mNumTransitions; i++) {
        Transition* transition = &mTransitions[i];
        internal::createAbbreviation(
            transition->abbrev,
            internal::kAbbrevSize,
            transition->era.format(),
            transition->offsetMinutes * kSecPerMin,
            transition->deltaMinutes * kSecPerMin,
            transition->abbrev);
      }
    }
 
    const Transition* findMatch(acetime_t epochSeconds) const {
      const Transition* closestMatch = nullptr;
      for (uint8_t i = 0; i < mNumTransitions; i++) {
        const Transition* m = &mTransitions[i];
        if (closestMatch == nullptr || m->startEpochSeconds <= epochSeconds) {
          closestMatch = m;
        }
      }
      return closestMatch;
    }
 
  private:
    static const int32_t kSecPerMin = 60;
 
    const ZIS* mZoneInfoStore; // nullable
    ZIB mZoneInfoBroker;
 
    mutable uint8_t mNumTransitions = 0;
    mutable Transition mTransitions[kMaxCacheEntries];
};
 
class BasicZoneProcessor: public BasicZoneProcessorTemplate<
    basic::ZoneInfoStore,
    basic::ZoneInfoBroker,
    basic::ZoneEraBroker,
    basic::ZonePolicyBroker,
    basic::ZoneRuleBroker> {
 
  public:
    static const uint8_t kTypeBasic = 3;
 
    explicit BasicZoneProcessor(const basic::ZoneInfo* zoneInfo = nullptr)
      : BasicZoneProcessorTemplate<
          basic::ZoneInfoStore,
          basic::ZoneInfoBroker,
          basic::ZoneEraBroker,
          basic::ZonePolicyBroker,
          basic::ZoneRuleBroker>(
              kTypeBasic, &mZoneInfoStore, (uintptr_t) zoneInfo)
    {}
 
  private:
    basic::ZoneInfoStore mZoneInfoStore;
};
 
} // namespace ace_time
 
#endif