ZoneManager.h

/*
 * MIT License
 * Copyright (c) 2019 Brian T. Park
 */
 
#ifndef ACE_TIME_ZONE_MANAGER_H
#define ACE_TIME_ZONE_MANAGER_H
 
#include <AceCommon.h>
#include <AceSorting.h>
#include "../zoneinfo/infos.h"
#include "ZoneRegistrar.h"
#include "TimeOffset.h"
#include "ZoneProcessorCache.h"
#include "TimeZoneData.h"
#include "TimeZone.h"
#include "BasicZone.h"
#include "ExtendedZone.h"
#include "CompleteZone.h"
 
namespace ace_time {
 
class ZoneManager {
  public:
 
    static const uint16_t kInvalidIndex = 0xffff;
};
 
class ManualZoneManager {
  public:
    TimeZone createForTimeZoneData(const TimeZoneData& d) {
      switch (d.type) {
        case TimeZoneData::kTypeError:
          return TimeZone::forError();
        case TimeZoneData::kTypeManual:
          return TimeZone::forTimeOffset(
              TimeOffset::forMinutes(d.stdOffsetMinutes),
              TimeOffset::forMinutes(d.dstOffsetMinutes));
        default:
          return TimeZone::forError();
      }
    }
 
    uint16_t zoneRegistrySize() const { return 0; }
};
 
template <typename ZI, typename ZRR, typename ZP, typename Z>
class ZoneManagerTemplate : public ZoneManager {
  public:
    ZoneManagerTemplate(
        uint16_t zoneRegistrySize,
        const ZI* const* zoneRegistry,
        ZoneProcessorCacheBaseTemplate<ZP>& zoneProcessorCache
    ):
        mZoneRegistrar(zoneRegistrySize, zoneRegistry),
        mZoneProcessorCache(zoneProcessorCache)
    {}
 
    TimeZone createForZoneName(const char* name) {
      const ZI* zoneInfo = mZoneRegistrar.getZoneInfoForName(name);
      return createForZoneInfo(zoneInfo);
    }
 
    TimeZone createForZoneId(uint32_t id) {
      const ZI* zoneInfo = mZoneRegistrar.getZoneInfoForId(id);
      return createForZoneInfo(zoneInfo);
    }
 
    TimeZone createForZoneIndex(uint16_t index) {
      const ZI* zoneInfo = mZoneRegistrar.getZoneInfoForIndex(index);
      return createForZoneInfo(zoneInfo);
    }
 
    TimeZone createForTimeZoneData(const TimeZoneData& d) {
      switch (d.type) {
        case TimeZoneData::kTypeError:
          return TimeZone::forError();
        case TimeZoneData::kTypeManual:
          return TimeZone::forTimeOffset(
              TimeOffset::forMinutes(d.stdOffsetMinutes),
              TimeOffset::forMinutes(d.dstOffsetMinutes));
        case TimeZoneData::kTypeZoneId:
          return createForZoneId(d.zoneId);
        default:
          // Maybe this should return TimeZone::forError()?
          return TimeZone();
      }
    }
 
    uint16_t indexForZoneName(const char* name) const {
      return mZoneRegistrar.findIndexForName(name);
    }
 
    uint16_t indexForZoneId(uint32_t id) const {
      return mZoneRegistrar.findIndexForId(id);
    }
 
    uint16_t zoneRegistrySize() const {
      return mZoneRegistrar.zoneRegistrySize();
    }
 
    TimeZone createForZoneInfo(const ZI* zoneInfo) {
      if (! zoneInfo) return TimeZone::forError();
      ZP* processor = mZoneProcessorCache.getZoneProcessor(
          (uintptr_t) zoneInfo);
      return TimeZone::forZoneInfo(zoneInfo, processor);
    }
 
    ZP* getZoneProcessor(const char* name) {
      const ZI* zoneInfo = this->mZoneRegistrar.getZoneInfoForName(name);
      if (! zoneInfo) return nullptr;
      return this->mZoneProcessorCache.getZoneProcessor((uintptr_t) zoneInfo);
    }
 
    Z getZoneForIndex(uint16_t index) const {
      const ZI* zoneInfo = this->mZoneRegistrar.getZoneInfoForIndex(index);
      return Z(zoneInfo);
    }
 
  private:
    // disable copy constructor and assignment operator
    ZoneManagerTemplate(const ZoneManagerTemplate&) = delete;
    ZoneManagerTemplate& operator=(const ZoneManagerTemplate&) = delete;
 
  private:
    const ZRR mZoneRegistrar;
    ZoneProcessorCacheBaseTemplate<ZP>& mZoneProcessorCache;
};
 
using BasicZoneManager = ZoneManagerTemplate<
    basic::ZoneInfo,
    basic::ZoneRegistrar,
    BasicZoneProcessor,
    BasicZone
>;
 
using ExtendedZoneManager = ZoneManagerTemplate<
    extended::ZoneInfo,
    extended::ZoneRegistrar,
    ExtendedZoneProcessor,
    ExtendedZone
>;
 
using CompleteZoneManager = ZoneManagerTemplate<
    complete::ZoneInfo,
    complete::ZoneRegistrar,
    CompleteZoneProcessor,
    CompleteZone
>;
 
}
 
#endif