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 "Zone.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 D, typename ZP, typename Z>
class ZoneManagerTemplate : public ZoneManager {
  public:
    ZoneManagerTemplate(
        uint16_t zoneRegistrySize,
        const typename D::ZoneInfo* const* zoneRegistry,
        ZoneProcessorCacheBaseTemplate<ZP>& zoneProcessorCache
    ):
        mZoneRegistrar(zoneRegistrySize, zoneRegistry),
        mZoneProcessorCache(zoneProcessorCache)
    {}
 
    TimeZone createForZoneName(const char* name) {
      const typename D::ZoneInfo* zoneInfo =
          mZoneRegistrar.getZoneInfoForName(name);
      return createForZoneInfo(zoneInfo);
    }
 
    TimeZone createForZoneId(uint32_t id) {
      const typename D::ZoneInfo* zoneInfo =
          mZoneRegistrar.getZoneInfoForId(id);
      return createForZoneInfo(zoneInfo);
    }
 
    TimeZone createForZoneIndex(uint16_t index) {
      const typename D::ZoneInfo* 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 typename D::ZoneInfo* zoneInfo) {
      if (! zoneInfo) return TimeZone::forError();
      ZP* processor = mZoneProcessorCache.getZoneProcessor(
          (uintptr_t) zoneInfo);
      return TimeZone::forZoneInfo(zoneInfo, processor);
    }
 
    ZP* getZoneProcessor(const char* name) {
      const typename D::ZoneInfo* zoneInfo =
          this->mZoneRegistrar.getZoneInfoForName(name);
      if (! zoneInfo) return nullptr;
      return this->mZoneProcessorCache.getZoneProcessor((uintptr_t) zoneInfo);
    }
 
    Z getZoneForIndex(uint16_t index) const {
      const typename D::ZoneInfo* 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 ZoneRegistrarTemplate<D> mZoneRegistrar;
    ZoneProcessorCacheBaseTemplate<ZP>& mZoneProcessorCache;
};
 
using BasicZoneManager = ZoneManagerTemplate<
    basic::Info, BasicZoneProcessor, BasicZone>;
 
using ExtendedZoneManager = ZoneManagerTemplate<
    extended::Info, ExtendedZoneProcessor, ExtendedZone>;
 
using CompleteZoneManager = ZoneManagerTemplate<
    complete::Info, CompleteZoneProcessor, CompleteZone>;
 
}
 
#endif