6 #ifndef ACE_TIME_BROKERS_LOW_H
7 #define ACE_TIME_BROKERS_LOW_H
26 #include <AceCommon.h>
29 #include "ZoneInfoLow.h"
31 class __FlashStringHelper;
35 namespace zoneinfolow {
50 return ((int16_t)(deltaCode & 0x0f) - 4) * 15;
60 return ((int8_t)offsetCode * 15) + ((deltaCode & 0xf0) >> 4);
71 return code * (uint16_t) 15 + (modifier & 0x0f);
79 inline uint8_t toSuffix(uint8_t modifier) {
80 return modifier & 0xf0;
90 template <
typename ZC>
94 : mZoneContext(zoneContext)
103 bool isNull()
const {
return mZoneContext ==
nullptr; }
105 const ZC* raw()
const {
return mZoneContext; }
107 int16_t startYear()
const {
108 return (int16_t) pgm_read_word(&mZoneContext->startYear);
111 int16_t untilYear()
const {
112 return (int16_t) pgm_read_word(&mZoneContext->untilYear);
115 int16_t startYearAccurate()
const {
116 return (int16_t) pgm_read_word(&mZoneContext->startYearAccurate);
119 int16_t untilYearAccurate()
const {
120 return (int16_t) pgm_read_word(&mZoneContext->untilYearAccurate);
123 int16_t baseYear()
const {
124 return (int16_t) pgm_read_word(&mZoneContext->baseYear);
127 int16_t maxTransitions()
const {
128 return (int16_t) pgm_read_word(&mZoneContext->maxTransitions);
131 const __FlashStringHelper* tzVersion()
const {
132 return (
const __FlashStringHelper*)
133 pgm_read_ptr(&mZoneContext->tzVersion);
136 uint8_t numFragments()
const {
137 return (uint8_t) pgm_read_byte(&mZoneContext->numFragments);
140 uint8_t numLetters()
const {
141 return (uint8_t) pgm_read_byte(&mZoneContext->numLetters);
144 const __FlashStringHelper*
const* fragments()
const {
145 return (
const __FlashStringHelper*
const*)
146 pgm_read_ptr(&mZoneContext->fragments);
149 const __FlashStringHelper* letter(uint8_t i)
const {
150 const char *
const* letters = (
const char*
const*)
151 pgm_read_ptr(&mZoneContext->letters);
152 const char* letter = (
const char*) pgm_read_ptr(letters + i);
153 return (
const __FlashStringHelper*) letter;
157 const ZC* mZoneContext;
168 template <
typename ZC,
typename ZR>
172 const ZC* zoneContext =
nullptr,
173 const ZR* zoneRule =
nullptr)
174 : mZoneContext(zoneContext)
175 , mZoneRule(zoneRule)
184 bool isNull()
const {
return mZoneRule ==
nullptr; }
186 int16_t fromYear()
const {
187 int8_t yearTiny = (int8_t) pgm_read_byte(&mZoneRule->fromYear);
189 return toYearFromTiny(yearTiny, baseYear);
192 int16_t toYear()
const {
193 int8_t yearTiny = (int8_t) pgm_read_byte(&mZoneRule->toYear);
195 return toYearFromTiny(yearTiny, baseYear);
198 static int16_t toYearFromTiny(int8_t yearTiny, int16_t baseYear) {
199 if (yearTiny == ZC::kInvalidYearTiny)
return ZC::kInvalidYear;
200 if (yearTiny == ZC::kMinYearTiny)
return ZC::kMinYear;
206 if (yearTiny >= ZC::kMaxYearTiny)
return ZC::kMaxYear;
208 return baseYear + yearTiny;
211 uint8_t inMonth()
const {
212 return pgm_read_byte(&mZoneRule->inMonth);
215 uint8_t onDayOfWeek()
const {
216 return pgm_read_byte(&mZoneRule->onDayOfWeek);
219 int8_t onDayOfMonth()
const {
220 return pgm_read_byte(&mZoneRule->onDayOfMonth);
223 uint32_t atTimeSeconds()
const {
225 pgm_read_byte(&mZoneRule->atTimeCode),
226 pgm_read_byte(&mZoneRule->atTimeModifier));
229 uint8_t atTimeSuffix()
const {
230 return toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
233 int32_t deltaSeconds()
const {
237 const __FlashStringHelper* letter()
const {
238 uint8_t index = pgm_read_byte(&mZoneRule->letterIndex);
243 const ZC* mZoneContext;
254 template <
typename ZC,
typename ZP,
typename ZR>
258 const ZC* zoneContext,
259 const ZP* zonePolicy)
260 : mZoneContext(zoneContext)
261 , mZonePolicy(zonePolicy)
270 bool isNull()
const {
return mZonePolicy ==
nullptr; }
272 uint8_t numRules()
const {
273 return pgm_read_byte(&mZonePolicy->numRules);
277 const ZR* rules = (
const ZR*) pgm_read_ptr(&mZonePolicy->rules);
282 const ZC* mZoneContext;
283 const ZP* mZonePolicy;
296 template <
typename ZC,
typename ZE,
typename ZP,
typename ZR>
300 const ZC* zoneContext =
nullptr,
301 const ZE* zoneEra =
nullptr)
302 : mZoneContext(zoneContext)
312 bool isNull()
const {
return mZoneEra ==
nullptr; }
315 return mZoneEra == other.mZoneEra;
321 (
const ZP*) pgm_read_ptr(&mZoneEra->zonePolicy));
324 int32_t offsetSeconds()
const {
326 pgm_read_byte(&mZoneEra->offsetCode),
327 pgm_read_byte(&mZoneEra->deltaCode));
330 int32_t deltaSeconds()
const {
334 const char* format()
const {
335 return (
const char*) pgm_read_ptr(&mZoneEra->format);
338 int16_t untilYear()
const {
339 int8_t yearTiny = (int8_t) pgm_read_byte(&mZoneEra->untilYear);
341 return toUntilYearFromTiny(yearTiny, baseYear);
344 static int16_t toUntilYearFromTiny(int8_t yearTiny, int16_t baseYear) {
345 if (yearTiny == ZC::kInvalidYearTiny)
return ZC::kInvalidYear;
346 if (yearTiny == ZC::kMinYearTiny)
return ZC::kMinYear;
347 if (yearTiny == ZC::kMaxUntilYearTiny)
return ZC::kMaxUntilYear;
348 return baseYear + yearTiny;
351 uint8_t untilMonth()
const {
352 return pgm_read_byte(&mZoneEra->untilMonth);
355 uint8_t untilDay()
const {
356 return pgm_read_byte(&mZoneEra->untilDay);
359 uint32_t untilTimeSeconds()
const {
361 pgm_read_byte(&mZoneEra->untilTimeCode),
362 pgm_read_byte(&mZoneEra->untilTimeModifier));
365 uint8_t untilTimeSuffix()
const {
366 return toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
370 const ZC* mZoneContext;
383 template <
typename ZC,
typename ZI,
typename ZE,
typename ZP,
typename ZR>
387 mZoneInfo(zoneInfo) {}
400 return mZoneInfo == (
const ZI*) zoneKey;
404 return mZoneInfo == zoneInfoBroker.mZoneInfo;
407 bool isNull()
const {
return mZoneInfo ==
nullptr; }
409 const ZoneContextBroker<ZC> zoneContext()
const {
410 const ZC* context = (
const ZC*) pgm_read_ptr(&mZoneInfo->zoneContext);
411 return ZoneContextBroker<ZC>(context);
414 const __FlashStringHelper* name()
const {
415 return FPSTR(pgm_read_ptr(&mZoneInfo->name));
418 uint32_t zoneId()
const {
419 return pgm_read_dword(&mZoneInfo->zoneId);
422 uint8_t numEras()
const {
423 return pgm_read_byte(&mZoneInfo->numEras);
426 const ZoneEraBroker<ZC, ZE, ZP, ZR> era(uint8_t i)
const {
427 auto eras = (
const ZE*) pgm_read_ptr(&mZoneInfo->eras);
428 return ZoneEraBroker<ZC, ZE, ZP, ZR>(zoneContext().raw(), &eras[i]);
431 bool isLink()
const {
432 return mZoneInfo->targetInfo !=
nullptr;
435 ZoneInfoBroker targetInfo()
const {
436 return ZoneInfoBroker(
437 (
const ZI*) pgm_read_ptr(&mZoneInfo->targetInfo));
454 template <
typename ZC,
typename ZI,
typename ZE,
typename ZP,
typename ZR>
457 ace_common::KString kname(name(), zc.fragments(), zc.numFragments());
458 kname.printTo(printer);
461 template <
typename ZC,
typename ZI,
typename ZE,
typename ZP,
typename ZR>
464 ace_common::printReplaceCharTo(
465 printer, zoneinfo::findShortName(name()),
'_',
' ');
476 template <
typename ZI>
480 mZoneRegistry(zoneRegistry) {}
488 const ZI* zoneInfo(uint16_t i)
const {
489 return (
const ZI*) pgm_read_ptr(&mZoneRegistry[i]);
493 const ZI*
const* mZoneRegistry;
509 template <
typename ZC,
typename ZI,
typename ZE,
typename ZP,
typename ZR>
Helper functions are used in both Basic brokers and Extended brokers.
int16_t toOffsetMinutes(uint8_t offsetCode, uint8_t deltaCode)
Convert the offsetCode and deltaCode holding the STDOFF field of the ZoneEra into minutes.
uint16_t timeCodeToMinutes(uint8_t code, uint8_t modifier)
Convert (code, modifier) fields representing the UNTIL time in ZoneInfo or AT time in ZoneRule in one...
int16_t toDeltaMinutes(uint8_t deltaCode)
Convert the deltaCode holding the RULES/DSTOFF field in ZoneEra or the SAVE field in ZoneRule to the ...
Data broker for accessing a ZoneContext.
Data broker for accessing ZoneEra.
Data broker for accessing ZoneInfo.
bool equals(uintptr_t zoneKey) const
void printNameTo(Print &printer) const
Print a human-readable identifier (e.g.
void printShortNameTo(Print &printer) const
Print a short human-readable identifier (e.g.
A storage object that creates an ZoneInfoBroker from a key that identifies the ZoneInfo.
ZoneInfoBroker< ZC, ZI, ZE, ZP, ZR > createZoneInfoBroker(uintptr_t zoneKey) const
Data broker for accessing ZonePolicy.
Data broker for accessing the ZoneRegistry.
Data broker for accessing ZoneRule.
Macros and definitions that provide a consistency layer among the various Arduino boards for compatib...