ZoneSorterByOffsetAndName.h

/*
 * MIT License
 * Copyright (c) 2021 Brian T. Park
 */
 
#ifndef ACE_TIME_ZONE_SORTER_BY_OFFSET_AND_NAME_H
#define ACE_TIME_ZONE_SORTER_BY_OFFSET_AND_NAME_H
 
#include <AceSorting.h>
#include "ZoneManager.h"
 
namespace ace_time {
 
template <typename ZM>
class ZoneSorterByOffsetAndName {
  public:
    ZoneSorterByOffsetAndName(const ZM& zoneManager) :
      mZoneManager(zoneManager)
    {}
 
    void fillIndexes(uint16_t indexes[], uint16_t size) const {
      for (uint16_t i = 0; i < size; i++) {
        indexes[i] = i;
      }
    }
 
    void sortIndexes(uint16_t indexes[], uint16_t size) const {
      ace_sorting::shellSortKnuth(indexes, size,
        [this](uint16_t indexA, uint16_t indexB) -> bool {
          auto za = this->mZoneManager.getZoneForIndex(indexA);
          auto zb = this->mZoneManager.getZoneForIndex(indexB);
          return this->compareZone(za, zb) < 0;
        }
      );
    }
 
    void sortIds(uint32_t ids[], uint16_t size) const {
      ace_sorting::shellSortKnuth(ids, size,
        [this](uint32_t a, uint32_t b) -> bool {
          uint16_t indexA = this->mZoneManager.indexForZoneId(a);
          uint16_t indexB = this->mZoneManager.indexForZoneId(b);
          auto za = this->mZoneManager.getZoneForIndex(indexA);
          auto zb = this->mZoneManager.getZoneForIndex(indexB);
          return this->compareZone(za, zb) < 0;
        }
      );
    }
 
    void sortNames(const char* names[], uint16_t size) const {
      ace_sorting::shellSortKnuth(names, size,
        [this](const char* a, const char* b) -> bool {
          uint16_t indexA = this->mZoneManager.indexForZoneName(a);
          uint16_t indexB = this->mZoneManager.indexForZoneName(b);
          auto za = this->mZoneManager.getZoneForIndex(indexA);
          auto zb = this->mZoneManager.getZoneForIndex(indexB);
          return this->compareZone(za, zb) < 0;
        }
      );
    }
 
    template <typename Z>
    static int compareZone(const Z& a, const Z& b) {
      if (a.isNull()) {
        if (b.isNull()) {
          return 0;
        } else {
          return -1;
        }
      }
      if (b.isNull()) return 1;
 
      TimeOffset offsetA = a.stdOffset();
      TimeOffset offsetB = b.stdOffset();
      if (offsetA.toSeconds() < offsetB.toSeconds()) return -1;
      if (offsetA.toSeconds() > offsetB.toSeconds()) return 1;
      return a.kname().compareTo(b.kname());
    }
 
  private:
    // disable copy constructor and assignment operator
    ZoneSorterByOffsetAndName(const ZoneSorterByOffsetAndName&) = delete;
    ZoneSorterByOffsetAndName& operator=(const ZoneSorterByOffsetAndName&)
        = delete;
 
  private:
    const ZM& mZoneManager;
};
 
}
 
#endif