ZoneProcessorCache.h

/*
 * MIT License
 * Copyright (c) 2019 Brian T. Park
 */
 
#ifndef ACE_TIME_ZONE_PROCESSOR_CACHE_H
#define ACE_TIME_ZONE_PROCESSOR_CACHE_H
 
#include "common/common.h"
#include "OffsetDateTime.h"
#include "BasicZoneProcessor.h"
#include "ExtendedZoneProcessor.h"
#include "CompleteZoneProcessor.h"
 
namespace ace_time {
 
template <typename ZP>
class ZoneProcessorCacheBaseTemplate {
  public:
    ZoneProcessorCacheBaseTemplate(ZP* zoneProcessors, uint8_t size) :
      mSize(size),
      mZoneProcessors(zoneProcessors)
    {}
 
    uint8_t size() const { return mSize; }
 
    ZP* getZoneProcessorAtIndex(uint8_t i) { return &mZoneProcessors[i]; }
 
    ZP* getZoneProcessor(uintptr_t zoneKey) {
      ZP* zoneProcessor = findUsingZoneKey(zoneKey);
      if (zoneProcessor) return zoneProcessor;
 
      // Allocate the next ZoneProcessor in the cache using round-robin.
      zoneProcessor = &mZoneProcessors[mCurrentIndex];
      mCurrentIndex++;
      if (mCurrentIndex >= mSize) mCurrentIndex = 0;
      zoneProcessor->setZoneKey(zoneKey);
      return zoneProcessor;
    }
 
  private:
    // disable copy constructor and assignment operator
    ZoneProcessorCacheBaseTemplate(const ZoneProcessorCacheBaseTemplate&)
        = delete;
    ZoneProcessorCacheBaseTemplate& operator=(
        const ZoneProcessorCacheBaseTemplate&) = delete;
 
    ZP* findUsingZoneKey(uintptr_t zoneKey) {
      for (uint8_t i = 0; i < mSize; i++) {
        ZP* zoneProcessor = &mZoneProcessors[i];
        if (zoneProcessor->equalsZoneKey(zoneKey)) {
          return zoneProcessor;
        }
      }
      return nullptr;
    }
 
  private:
    uint8_t const mSize;
    uint8_t mCurrentIndex = 0;
    ZP* const mZoneProcessors;
};
 
using BasicZoneProcessorCacheBase =
    ZoneProcessorCacheBaseTemplate<BasicZoneProcessor>;
 
using ExtendedZoneProcessorCacheBase =
    ZoneProcessorCacheBaseTemplate<ExtendedZoneProcessor>;
 
using CompleteZoneProcessorCacheBase =
    ZoneProcessorCacheBaseTemplate<CompleteZoneProcessor>;
 
template <uint8_t SIZE>
class BasicZoneProcessorCache : public BasicZoneProcessorCacheBase {
  public:
    BasicZoneProcessorCache() :
      BasicZoneProcessorCacheBase(mZoneProcessors, SIZE)
    {}
 
  private:
    // disable copy constructor and assignment operator
    BasicZoneProcessorCache(const BasicZoneProcessorCache&) = delete;
    BasicZoneProcessorCache& operator=(const BasicZoneProcessorCache&) = delete;
 
  private:
    BasicZoneProcessor mZoneProcessors[SIZE];
};
 
template <uint8_t SIZE>
class ExtendedZoneProcessorCache: public ExtendedZoneProcessorCacheBase {
  public:
    ExtendedZoneProcessorCache() :
      ExtendedZoneProcessorCacheBase(mZoneProcessors, SIZE)
    {}
 
  private:
    // disable copy constructor and assignment operator
    ExtendedZoneProcessorCache(const ExtendedZoneProcessorCache&) = delete;
    ExtendedZoneProcessorCache& operator=(const ExtendedZoneProcessorCache&)
        = delete;
 
  private:
    ExtendedZoneProcessor mZoneProcessors[SIZE];
};
 
template <uint8_t SIZE>
class CompleteZoneProcessorCache: public CompleteZoneProcessorCacheBase {
  public:
    CompleteZoneProcessorCache() :
      CompleteZoneProcessorCacheBase(mZoneProcessors, SIZE)
    {}
 
  private:
    // disable copy constructor and assignment operator
    CompleteZoneProcessorCache(const CompleteZoneProcessorCache&) = delete;
    CompleteZoneProcessorCache& operator=(const CompleteZoneProcessorCache&)
        = delete;
 
  private:
    CompleteZoneProcessor mZoneProcessors[SIZE];
};
 
}
 
#endif