AceTime  0.8
Date and time classes for Arduino that support timezones from the TZ Database, and a system clock that can synchronize from an NTP server or an RTC chip.
Brokers.h
Go to the documentation of this file.
1 /*
2  * MIT License
3  * Copyright (c) 2019 Brian T. Park
4  */
5 
6 #ifndef ACE_TIME_BROKERS_H
7 #define ACE_TIME_BROKERS_H
8 
39 #include "../common/compat.h"
40 #include "ZoneInfo.h"
41 
42 namespace ace_time {
43 
44 namespace internal {
45 
47 inline uint16_t timeCodeToMinutes(uint8_t code, uint8_t modifier) {
48  return code * (uint16_t) 15 + (modifier & 0x0f);
49 }
50 
55 inline uint8_t toSuffix(uint8_t modifier) {
56  return modifier & 0xf0;
57 }
58 
59 } // internal
60 
61 //------------------------------------------------------------------------
62 
63 namespace basic {
64 
67  public:
68  explicit ZoneRuleBroker(const ZoneRule* zoneRule):
69  mZoneRule(zoneRule) {}
70 
72  mZoneRule(nullptr) {}
73 
74  // use the default copy constructor
75  ZoneRuleBroker(const ZoneRuleBroker&) = default;
76 
77  // use the default assignment operator
78  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
79 
80  bool isNull() const { return mZoneRule == nullptr; }
81 
82  bool isNotNull() const { return mZoneRule != nullptr; }
83 
84  #if ACE_TIME_USE_PROGMEM
85 
86  int8_t fromYearTiny() const {
87  return pgm_read_byte(&mZoneRule->fromYearTiny);
88  }
89 
90  int8_t toYearTiny() const {
91  return pgm_read_byte(&mZoneRule->toYearTiny);
92  }
93 
94  uint8_t inMonth() const {
95  return pgm_read_byte(&mZoneRule->inMonth);
96  }
97 
98  int8_t onDayOfWeek() const {
99  return pgm_read_byte(&mZoneRule->onDayOfWeek);
100  }
101 
102  int8_t onDayOfMonth() const {
103  return pgm_read_byte(&mZoneRule->onDayOfMonth);
104  }
105 
106  uint16_t atTimeMinutes() const {
107  return internal::timeCodeToMinutes(
108  pgm_read_byte(&mZoneRule->atTimeCode),
109  pgm_read_byte(&mZoneRule->atTimeModifier));
110  }
111 
112  uint8_t atTimeSuffix() const {
113  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
114  }
115 
116  int16_t deltaMinutes() const {
117  return 15 * (int8_t) pgm_read_byte(&mZoneRule->deltaCode);
118  }
119 
120  uint8_t letter() const {
121  return pgm_read_byte(&mZoneRule->letter);
122  }
123 
124  #else
125 
126  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
127 
128  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
129 
130  uint8_t inMonth() const { return mZoneRule->inMonth; }
131 
132  uint8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
133 
134  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
135 
136  uint16_t atTimeMinutes() const {
137  return internal::timeCodeToMinutes(
138  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
139  }
140 
141  uint8_t atTimeSuffix() const {
142  return internal::toSuffix(mZoneRule->atTimeModifier);
143  }
144 
145  int16_t deltaMinutes() const { return 15 * mZoneRule->deltaCode; }
146 
147  uint8_t letter() const { return mZoneRule->letter; }
148 
149  #endif
150 
151  private:
152  const ZoneRule* mZoneRule;
153 };
154 
157  public:
158  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy):
159  mZonePolicy(zonePolicy) {}
160 
162  mZonePolicy(nullptr) {}
163 
164  // use default copy constructor
165  ZonePolicyBroker(const ZonePolicyBroker&) = default;
166 
167  // use default assignment operator
168  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
169 
170  bool isNull() const { return mZonePolicy == nullptr; }
171 
172  bool isNotNull() const { return mZonePolicy != nullptr; }
173 
174  #if ACE_TIME_USE_PROGMEM
175 
176  uint8_t numRules() const {
177  return pgm_read_byte(&mZonePolicy->numRules);
178  }
179 
180  const ZoneRuleBroker rule(uint8_t i) const {
181  const ZoneRule* rules =
182  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
183  return ZoneRuleBroker(&rules[i]);
184  }
185 
186  uint8_t numLetters() const {
187  return pgm_read_byte(&mZonePolicy->numLetters);
188  }
189 
190  const char* letter(uint8_t i) const {
191  const char* const* letters = (const char* const*)
192  pgm_read_ptr(&mZonePolicy->letters);
193  return (const char*) pgm_read_ptr(&letters[i]);
194  }
195 
196  #else
197 
198  uint8_t numRules() const { return mZonePolicy->numRules; }
199 
200  const ZoneRuleBroker rule(uint8_t i) const {
201  return ZoneRuleBroker(&mZonePolicy->rules[i]);
202  }
203 
204  uint8_t numLetters() const { return mZonePolicy->numLetters; }
205 
206  const char* letter(uint8_t i) const {
207  return mZonePolicy->letters[i];
208  }
209 
210  #endif
211 
212  private:
213  const ZonePolicy* mZonePolicy;
214 };
215 
218  public:
219  explicit ZoneEraBroker(const ZoneEra* zoneEra):
220  mZoneEra(zoneEra) {}
221 
222  ZoneEraBroker():
223  mZoneEra(nullptr) {}
224 
225  // use default copy constructor
226  ZoneEraBroker(const ZoneEraBroker&) = default;
227 
228  // use default assignment operator
229  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
230 
231  const ZoneEra* zoneEra() const { return mZoneEra; }
232 
233  bool isNull() const { return mZoneEra == nullptr; }
234 
235  bool isNotNull() const { return mZoneEra != nullptr; }
236 
237  #if ACE_TIME_USE_PROGMEM
238 
239  int16_t offsetMinutes() const {
240  return 15 * (int8_t) pgm_read_byte(&mZoneEra->offsetCode);
241  }
242 
243  const ZonePolicyBroker zonePolicy() const {
244  return ZonePolicyBroker(
245  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
246  }
247 
248  int16_t deltaMinutes() const {
249  return 15 * (int8_t) pgm_read_byte(&mZoneEra->deltaCode);
250  }
251 
252  const char* format() const {
253  return (const char*) pgm_read_ptr(&mZoneEra->format);
254  }
255 
256  int8_t untilYearTiny() const {
257  return pgm_read_byte(&mZoneEra->untilYearTiny);
258  }
259 
260  uint8_t untilMonth() const {
261  return pgm_read_byte(&mZoneEra->untilMonth);
262  }
263 
264  uint8_t untilDay() const {
265  return pgm_read_byte(&mZoneEra->untilDay);
266  }
267 
268  uint16_t untilTimeMinutes() const {
269  return internal::timeCodeToMinutes(
270  pgm_read_byte(&mZoneEra->untilTimeCode),
271  pgm_read_byte(&mZoneEra->untilTimeModifier));
272  }
273 
274  uint8_t untilTimeSuffix() const {
275  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
276  }
277 
278  #else
279 
280  int16_t offsetMinutes() const { return 15 * mZoneEra->offsetCode; }
281 
282  const ZonePolicyBroker zonePolicy() const {
283  return ZonePolicyBroker(mZoneEra->zonePolicy);
284  }
285 
286  int16_t deltaMinutes() const { return 15 * mZoneEra->deltaCode; }
287 
288  const char* format() const { return mZoneEra->format; }
289 
290  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
291 
292  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
293 
294  uint8_t untilDay() const { return mZoneEra->untilDay; }
295 
296  uint16_t untilTimeMinutes() const {
297  return internal::timeCodeToMinutes(
298  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
299  }
300 
301  uint8_t untilTimeSuffix() const {
302  return internal::toSuffix(mZoneEra->untilTimeModifier);
303  }
304 
305  #endif
306 
307  private:
308  const ZoneEra* mZoneEra;
309 };
310 
313  public:
314  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo):
315  mZoneInfo(zoneInfo) {}
316 
317  // use default copy constructor
318  ZoneInfoBroker(const ZoneInfoBroker&) = default;
319 
320  // use default assignment operator
321  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
322 
323  const ZoneInfo* zoneInfo() const { return mZoneInfo; }
324 
325  #if ACE_TIME_USE_PROGMEM
326 
327  const char* name() const {
328  return (const char*) pgm_read_ptr(&mZoneInfo->name);
329  }
330 
331  uint32_t zoneId() const {
332  return pgm_read_dword(&mZoneInfo->zoneId);
333  }
334 
335  int16_t startYear() const {
336  const ZoneContext* zoneContext =
337  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
338  return zoneContext->startYear;
339  }
340 
341  int16_t untilYear() const {
342  const ZoneContext* zoneContext =
343  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
344  return zoneContext->untilYear;
345  }
346 
347  uint8_t numEras() const {
348  return pgm_read_byte(&mZoneInfo->numEras);
349  }
350 
351  const ZoneEraBroker era(uint8_t i) const {
352  const ZoneEra* eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
353  return ZoneEraBroker(&eras[i]);
354  }
355 
356  #else
357 
358  const char* name() const { return mZoneInfo->name; }
359 
360  uint32_t zoneId() const { return mZoneInfo->zoneId; }
361 
362  int16_t startYear() const { return mZoneInfo->zoneContext->startYear; }
363 
364  int16_t untilYear() const { return mZoneInfo->zoneContext->untilYear; }
365 
366  uint8_t numEras() const { return mZoneInfo->numEras; }
367 
368  const ZoneEraBroker era(uint8_t i) const {
369  return ZoneEraBroker(&mZoneInfo->eras[i]);
370  }
371 
372  #endif
373 
374  private:
375  const ZoneInfo* mZoneInfo;
376 };
377 
383  public:
384  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
385  mZoneRegistry(zoneRegistry) {}
386 
387  // use default copy constructor
388  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
389 
390  // use default assignment operator
391  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
392 
393  #if ACE_TIME_USE_PROGMEM
394 
395  const ZoneInfo* zoneInfo(uint16_t i) const {
396  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
397  }
398 
399  #else
400 
401  const ZoneInfo* zoneInfo(uint16_t i) const {
402  return mZoneRegistry[i];
403  }
404 
405  #endif
406 
407  private:
408  const ZoneInfo* const* const mZoneRegistry;
409 };
410 
411 } // basic
412 
413 //------------------------------------------------------------------------
414 
415 namespace extended {
416 
417 // deltaMinutes = deltaCode * 15m - 1h, (4-bits can store -01:00 to 02:45).
418 inline int16_t toDeltaMinutes(int8_t deltaCode) {
419  return ((int8_t)((uint8_t)deltaCode & 0x0f) - 4) * 15;
420 }
421 
422 // offsetCode holds the upper 15-minute multiples, as a signed 8-bit integer.
423 // The upper 4-bits of deltaCode holds the one-minute resolution, as an
424 // unsigned offset.
425 inline int16_t toOffsetMinutes(int8_t offsetCode, int8_t deltaCode) {
426  return (offsetCode * 15) + (((uint8_t)deltaCode & 0xf0) >> 4);
427 }
428 
431  public:
432  explicit ZoneRuleBroker(const ZoneRule* zoneRule):
433  mZoneRule(zoneRule) {}
434 
435  ZoneRuleBroker():
436  mZoneRule(nullptr) {}
437 
438  // use the default copy constructor
439  ZoneRuleBroker(const ZoneRuleBroker&) = default;
440 
441  // use the default assignment operator
442  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
443 
444  bool isNull() const { return mZoneRule == nullptr; }
445 
446  bool isNotNull() const { return mZoneRule != nullptr; }
447 
448  #if ACE_TIME_USE_PROGMEM
449 
450  int8_t fromYearTiny() const {
451  return pgm_read_byte(&mZoneRule->fromYearTiny);
452  }
453 
454  int8_t toYearTiny() const {
455  return pgm_read_byte(&mZoneRule->toYearTiny);
456  }
457 
458  uint8_t inMonth() const {
459  return pgm_read_byte(&mZoneRule->inMonth);
460  }
461 
462  uint8_t onDayOfWeek() const {
463  return pgm_read_byte(&mZoneRule->onDayOfWeek);
464  }
465 
466  int8_t onDayOfMonth() const {
467  return pgm_read_byte(&mZoneRule->onDayOfMonth);
468  }
469 
470  uint16_t atTimeMinutes() const {
471  return internal::timeCodeToMinutes(
472  pgm_read_byte(&mZoneRule->atTimeCode),
473  pgm_read_byte(&mZoneRule->atTimeModifier));
474  }
475 
476  uint8_t atTimeSuffix() const {
477  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
478  }
479 
480  int16_t deltaMinutes() const {
481  return toDeltaMinutes(pgm_read_byte(&mZoneRule->deltaCode));
482  }
483 
484  uint8_t letter() const {
485  return pgm_read_byte(&mZoneRule->letter);
486  }
487 
488  #else
489 
490  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
491 
492  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
493 
494  uint8_t inMonth() const { return mZoneRule->inMonth; }
495 
496  int8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
497 
498  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
499 
500  uint16_t atTimeMinutes() const {
501  return internal::timeCodeToMinutes(
502  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
503  }
504 
505  uint8_t atTimeSuffix() const {
506  return internal::toSuffix(mZoneRule->atTimeModifier);
507  }
508 
509  int16_t deltaMinutes() const {
510  return toDeltaMinutes(mZoneRule->deltaCode);
511  }
512 
513  uint8_t letter() const { return mZoneRule->letter; }
514 
515  #endif
516 
517  private:
518  const ZoneRule* mZoneRule;
519 };
520 
523  public:
524  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy):
525  mZonePolicy(zonePolicy) {}
526 
527  // use default copy constructor
528  ZonePolicyBroker(const ZonePolicyBroker&) = default;
529 
530  // use default assignment operator
531  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
532 
533  bool isNull() const { return mZonePolicy == nullptr; }
534 
535  bool isNotNull() const { return mZonePolicy != nullptr; }
536 
537  #if ACE_TIME_USE_PROGMEM
538 
539  uint8_t numRules() const {
540  return pgm_read_byte(&mZonePolicy->numRules);
541  }
542 
543  const ZoneRuleBroker rule(uint8_t i) const {
544  const ZoneRule* rules =
545  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
546  return ZoneRuleBroker(&rules[i]);
547  }
548 
549  uint8_t numLetters() const {
550  return pgm_read_byte(&mZonePolicy->numLetters);
551  }
552 
553  const char* letter(uint8_t i) const {
554  const char* const* letters = (const char* const*)
555  pgm_read_ptr(&mZonePolicy->letters);
556  return (const char*) pgm_read_ptr(&letters[i]);
557  }
558 
559  #else
560 
561  uint8_t numRules() const { return mZonePolicy->numRules; }
562 
563  const ZoneRuleBroker rule(uint8_t i) const {
564  return ZoneRuleBroker(&mZonePolicy->rules[i]);
565  }
566 
567  uint8_t numLetters() const { return mZonePolicy->numLetters; }
568 
569  const char* letter(uint8_t i) const {
570  return mZonePolicy->letters[i];
571  }
572 
573  #endif
574 
575  private:
576  const ZonePolicy* const mZonePolicy;
577 };
578 
581  public:
582  explicit ZoneEraBroker(const ZoneEra* zoneEra):
583  mZoneEra(zoneEra) {}
584 
585  ZoneEraBroker():
586  mZoneEra(nullptr) {}
587 
588  // use default copy constructor
589  ZoneEraBroker(const ZoneEraBroker&) = default;
590 
591  // use default assignment operator
592  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
593 
594  const ZoneEra* zoneEra() const { return mZoneEra; }
595 
596  bool isNull() const { return mZoneEra == nullptr; }
597 
598  bool isNotNull() const { return mZoneEra != nullptr; }
599 
600  #if ACE_TIME_USE_PROGMEM
601 
602  const ZonePolicyBroker zonePolicy() const {
603  return ZonePolicyBroker(
604  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
605  }
606 
607  int16_t offsetMinutes() const {
608  return toOffsetMinutes(
609  pgm_read_byte(&mZoneEra->offsetCode),
610  pgm_read_byte(&mZoneEra->deltaCode));
611  }
612 
613  int16_t deltaMinutes() const {
614  return toDeltaMinutes(pgm_read_byte(&mZoneEra->deltaCode));
615  }
616 
617  const char* format() const {
618  return (const char*) pgm_read_ptr(&mZoneEra->format);
619  }
620 
621  int8_t untilYearTiny() const {
622  return pgm_read_byte(&mZoneEra->untilYearTiny);
623  }
624 
625  uint8_t untilMonth() const {
626  return pgm_read_byte(&mZoneEra->untilMonth);
627  }
628 
629  uint8_t untilDay() const {
630  return pgm_read_byte(&mZoneEra->untilDay);
631  }
632 
633  uint16_t untilTimeMinutes() const {
634  return internal::timeCodeToMinutes(
635  pgm_read_byte(&mZoneEra->untilTimeCode),
636  pgm_read_byte(&mZoneEra->untilTimeModifier));
637  }
638 
639  uint8_t untilTimeSuffix() const {
640  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
641  }
642 
643  #else
644 
645  const ZonePolicyBroker zonePolicy() const {
646  return ZonePolicyBroker(mZoneEra->zonePolicy);
647  }
648 
649  int16_t offsetMinutes() const {
650  return toOffsetMinutes(mZoneEra->offsetCode, mZoneEra->deltaCode);
651  }
652 
653  int16_t deltaMinutes() const {
654  return toDeltaMinutes(mZoneEra->deltaCode);
655  }
656 
657  const char* format() const { return mZoneEra->format; }
658 
659  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
660 
661  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
662 
663  uint8_t untilDay() const { return mZoneEra->untilDay; }
664 
665  uint16_t untilTimeMinutes() const {
666  return internal::timeCodeToMinutes(
667  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
668  }
669 
670  uint8_t untilTimeSuffix() const {
671  return internal::toSuffix(mZoneEra->untilTimeModifier);
672  }
673 
674  #endif
675 
676  private:
677  const ZoneEra* mZoneEra;
678 
679 };
680 
683  public:
684  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo):
685  mZoneInfo(zoneInfo) {}
686 
687  // use default copy constructor
688  ZoneInfoBroker(const ZoneInfoBroker&) = default;
689 
690  // use default assignment operator
691  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
692 
693  const ZoneInfo* zoneInfo() const { return mZoneInfo; }
694 
695  #if ACE_TIME_USE_PROGMEM
696 
697  const char* name() const {
698  return (const char*) pgm_read_ptr(&mZoneInfo->name);
699  }
700 
701  uint32_t zoneId() const {
702  return pgm_read_dword(&mZoneInfo->zoneId);
703  }
704 
705  int16_t startYear() const {
706  const ZoneContext* zoneContext =
707  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
708  return zoneContext->startYear;
709  }
710 
711  int16_t untilYear() const {
712  const ZoneContext* zoneContext =
713  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
714  return zoneContext->untilYear;
715  }
716 
717  uint8_t numEras() const {
718  return pgm_read_byte(&mZoneInfo->numEras);
719  }
720 
721  const ZoneEraBroker era(uint8_t i) const {
722  const ZoneEra* eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
723  return ZoneEraBroker(&eras[i]);
724  }
725 
726  #else
727 
728  const char* name() const { return mZoneInfo->name; }
729 
730  uint32_t zoneId() const { return mZoneInfo->zoneId; }
731 
732  int16_t startYear() const { return mZoneInfo->zoneContext->startYear; }
733 
734  int16_t untilYear() const { return mZoneInfo->zoneContext->untilYear; }
735 
736  uint8_t numEras() const { return mZoneInfo->numEras; }
737 
738  const ZoneEraBroker era(uint8_t i) const {
739  return ZoneEraBroker(&mZoneInfo->eras[i]);
740  }
741 
742  #endif
743 
744  private:
745  const ZoneInfo* mZoneInfo;
746 };
747 
753  public:
754  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
755  mZoneRegistry(zoneRegistry) {}
756 
757  // use default copy constructor
758  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
759 
760  // use default assignment operator
761  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
762 
763  #if ACE_TIME_USE_PROGMEM
764 
765  const ZoneInfo* zoneInfo(uint16_t i) const {
766  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
767  }
768 
769  #else
770 
771  const ZoneInfo* zoneInfo(uint16_t i) const {
772  return mZoneRegistry[i];
773  }
774 
775  #endif
776 
777  private:
778  const ZoneInfo* const* const mZoneRegistry;
779 };
780 
781 } // extended
782 
783 }
784 
785 #endif
An entry in ZoneInfo which describes which ZonePolicy was being followed during a particular time per...
Definition: ZoneInfo.h:20
const int16_t startYear
Start year of the zone files.
Definition: ZoneContext.h:30
Data broker for accessing the ZoneRegistry.
Definition: Brokers.h:382
Data broker for accessing ZoneRule.
Definition: Brokers.h:430
A collection of transition rules which describe the DST rules of a given administrative region...
Definition: ZonePolicy.h:107
Representation of a given time zone, implemented as an array of ZoneEra records.
Definition: ZoneInfo.h:100
A collection of transition rules which describe the DST rules of a given administrative region...
Definition: ZonePolicy.h:107
const int16_t startYear
Start year of the zone files.
Definition: ZoneContext.h:30
Representation of a given time zone, implemented as an array of ZoneEra records.
Definition: ZoneInfo.h:100
uint8_t toSuffix(uint8_t modifier)
Extract the 'w', 's' 'u' suffix from the 'modifier' field, so that they can be compared against kSuff...
Definition: Brokers.h:55
Data broker for accessing ZonePolicy.
Definition: Brokers.h:156
An entry in ZoneInfo which describes which ZonePolicy was being followed during a particular time per...
Definition: ZoneInfo.h:20
Data broker for accessing ZonePolicy.
Definition: Brokers.h:522
A time zone transition rule.
Definition: ZonePolicy.h:12
Metadata about the zone database.
Definition: ZoneContext.h:11
Metadata about the zone database.
Definition: ZoneContext.h:11
Data broker for accessing ZoneInfo.
Definition: Brokers.h:682
A time zone transition rule.
Definition: ZonePolicy.h:12
uint16_t timeCodeToMinutes(uint8_t code, uint8_t modifier)
Convert (timeCode, timeModifier) fields in zoneinfo to minutes.
Definition: Brokers.h:47
Data broker for accessing the ZoneRegistry.
Definition: Brokers.h:752
Data broker for accessing ZoneEra.
Definition: Brokers.h:580
const int16_t untilYear
Until year of the zone files.
Definition: ZoneContext.h:33
Data broker for accessing ZoneEra.
Definition: Brokers.h:217
Data broker for accessing ZoneRule.
Definition: Brokers.h:66
Data broker for accessing ZoneInfo.
Definition: Brokers.h:312
const int16_t untilYear
Until year of the zone files.
Definition: ZoneContext.h:33