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