AceTime  1.2
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 
419 inline int16_t toDeltaMinutes(int8_t deltaCode) {
420  return ((int8_t)((uint8_t)deltaCode & 0x0f) - 4) * 15;
421 }
422 
428 inline int16_t toOffsetMinutes(int8_t offsetCode, int8_t deltaCode) {
429  return (offsetCode * 15) + (((uint8_t)deltaCode & 0xf0) >> 4);
430 }
431 
434  public:
435  explicit ZoneRuleBroker(const ZoneRule* zoneRule):
436  mZoneRule(zoneRule) {}
437 
438  ZoneRuleBroker():
439  mZoneRule(nullptr) {}
440 
441  // use the default copy constructor
442  ZoneRuleBroker(const ZoneRuleBroker&) = default;
443 
444  // use the default assignment operator
445  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
446 
447  bool isNull() const { return mZoneRule == nullptr; }
448 
449  #if ACE_TIME_USE_PROGMEM
450 
451  int8_t fromYearTiny() const {
452  return pgm_read_byte(&mZoneRule->fromYearTiny);
453  }
454 
455  int8_t toYearTiny() const {
456  return pgm_read_byte(&mZoneRule->toYearTiny);
457  }
458 
459  uint8_t inMonth() const {
460  return pgm_read_byte(&mZoneRule->inMonth);
461  }
462 
463  uint8_t onDayOfWeek() const {
464  return pgm_read_byte(&mZoneRule->onDayOfWeek);
465  }
466 
467  int8_t onDayOfMonth() const {
468  return pgm_read_byte(&mZoneRule->onDayOfMonth);
469  }
470 
471  uint16_t atTimeMinutes() const {
472  return internal::timeCodeToMinutes(
473  pgm_read_byte(&mZoneRule->atTimeCode),
474  pgm_read_byte(&mZoneRule->atTimeModifier));
475  }
476 
477  uint8_t atTimeSuffix() const {
478  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
479  }
480 
481  int16_t deltaMinutes() const {
482  return toDeltaMinutes(pgm_read_byte(&mZoneRule->deltaCode));
483  }
484 
485  uint8_t letter() const {
486  return pgm_read_byte(&mZoneRule->letter);
487  }
488 
489  #else
490 
491  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
492 
493  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
494 
495  uint8_t inMonth() const { return mZoneRule->inMonth; }
496 
497  int8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
498 
499  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
500 
501  uint16_t atTimeMinutes() const {
502  return internal::timeCodeToMinutes(
503  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
504  }
505 
506  uint8_t atTimeSuffix() const {
507  return internal::toSuffix(mZoneRule->atTimeModifier);
508  }
509 
510  int16_t deltaMinutes() const {
511  return toDeltaMinutes(mZoneRule->deltaCode);
512  }
513 
514  uint8_t letter() const { return mZoneRule->letter; }
515 
516  #endif
517 
518  private:
519  const ZoneRule* mZoneRule;
520 };
521 
524  public:
525  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy):
526  mZonePolicy(zonePolicy) {}
527 
528  // use default copy constructor
529  ZonePolicyBroker(const ZonePolicyBroker&) = default;
530 
531  // use default assignment operator
532  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
533 
534  bool isNull() const { return mZonePolicy == nullptr; }
535 
536  #if ACE_TIME_USE_PROGMEM
537 
538  uint8_t numRules() const {
539  return pgm_read_byte(&mZonePolicy->numRules);
540  }
541 
542  const ZoneRuleBroker rule(uint8_t i) const {
543  const ZoneRule* rules =
544  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
545  return ZoneRuleBroker(&rules[i]);
546  }
547 
548  uint8_t numLetters() const {
549  return pgm_read_byte(&mZonePolicy->numLetters);
550  }
551 
552  const char* letter(uint8_t i) const {
553  const char* const* letters = (const char* const*)
554  pgm_read_ptr(&mZonePolicy->letters);
555  return (const char*) pgm_read_ptr(&letters[i]);
556  }
557 
558  #else
559 
560  uint8_t numRules() const { return mZonePolicy->numRules; }
561 
562  const ZoneRuleBroker rule(uint8_t i) const {
563  return ZoneRuleBroker(&mZonePolicy->rules[i]);
564  }
565 
566  uint8_t numLetters() const { return mZonePolicy->numLetters; }
567 
568  const char* letter(uint8_t i) const {
569  return mZonePolicy->letters[i];
570  }
571 
572  #endif
573 
574  private:
575  const ZonePolicy* const mZonePolicy;
576 };
577 
580  public:
581  explicit ZoneEraBroker(const ZoneEra* zoneEra):
582  mZoneEra(zoneEra) {}
583 
584  ZoneEraBroker():
585  mZoneEra(nullptr) {}
586 
587  // use default copy constructor
588  ZoneEraBroker(const ZoneEraBroker&) = default;
589 
590  // use default assignment operator
591  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
592 
593  const ZoneEra* zoneEra() const { return mZoneEra; }
594 
595  bool isNull() const { return mZoneEra == nullptr; }
596 
597  #if ACE_TIME_USE_PROGMEM
598 
599  const ZonePolicyBroker zonePolicy() const {
600  return ZonePolicyBroker(
601  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
602  }
603 
604  int16_t offsetMinutes() const {
605  return toOffsetMinutes(
606  pgm_read_byte(&mZoneEra->offsetCode),
607  pgm_read_byte(&mZoneEra->deltaCode));
608  }
609 
610  int16_t deltaMinutes() const {
611  return toDeltaMinutes(pgm_read_byte(&mZoneEra->deltaCode));
612  }
613 
614  const char* format() const {
615  return (const char*) pgm_read_ptr(&mZoneEra->format);
616  }
617 
618  int8_t untilYearTiny() const {
619  return pgm_read_byte(&mZoneEra->untilYearTiny);
620  }
621 
622  uint8_t untilMonth() const {
623  return pgm_read_byte(&mZoneEra->untilMonth);
624  }
625 
626  uint8_t untilDay() const {
627  return pgm_read_byte(&mZoneEra->untilDay);
628  }
629 
630  uint16_t untilTimeMinutes() const {
631  return internal::timeCodeToMinutes(
632  pgm_read_byte(&mZoneEra->untilTimeCode),
633  pgm_read_byte(&mZoneEra->untilTimeModifier));
634  }
635 
636  uint8_t untilTimeSuffix() const {
637  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
638  }
639 
640  #else
641 
642  const ZonePolicyBroker zonePolicy() const {
643  return ZonePolicyBroker(mZoneEra->zonePolicy);
644  }
645 
646  int16_t offsetMinutes() const {
647  return toOffsetMinutes(mZoneEra->offsetCode, mZoneEra->deltaCode);
648  }
649 
650  int16_t deltaMinutes() const {
651  return toDeltaMinutes(mZoneEra->deltaCode);
652  }
653 
654  const char* format() const { return mZoneEra->format; }
655 
656  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
657 
658  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
659 
660  uint8_t untilDay() const { return mZoneEra->untilDay; }
661 
662  uint16_t untilTimeMinutes() const {
663  return internal::timeCodeToMinutes(
664  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
665  }
666 
667  uint8_t untilTimeSuffix() const {
668  return internal::toSuffix(mZoneEra->untilTimeModifier);
669  }
670 
671  #endif
672 
673  private:
674  const ZoneEra* mZoneEra;
675 
676 };
677 
680  public:
681  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo):
682  mZoneInfo(zoneInfo) {}
683 
684  // use default copy constructor
685  ZoneInfoBroker(const ZoneInfoBroker&) = default;
686 
687  // use default assignment operator
688  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
689 
690  const ZoneInfo* zoneInfo() const { return mZoneInfo; }
691 
692  #if ACE_TIME_USE_PROGMEM
693 
694  const char* name() const {
695  return (const char*) pgm_read_ptr(&mZoneInfo->name);
696  }
697 
698  uint32_t zoneId() const {
699  return pgm_read_dword(&mZoneInfo->zoneId);
700  }
701 
702  int16_t startYear() const {
703  const ZoneContext* zoneContext =
704  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
705  return zoneContext->startYear;
706  }
707 
708  int16_t untilYear() const {
709  const ZoneContext* zoneContext =
710  (const ZoneContext*) pgm_read_ptr(&mZoneInfo->zoneContext);
711  return zoneContext->untilYear;
712  }
713 
714  uint8_t numEras() const {
715  return pgm_read_byte(&mZoneInfo->numEras);
716  }
717 
718  const ZoneEraBroker era(uint8_t i) const {
719  const ZoneEra* eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
720  return ZoneEraBroker(&eras[i]);
721  }
722 
723  #else
724 
725  const char* name() const { return mZoneInfo->name; }
726 
727  uint32_t zoneId() const { return mZoneInfo->zoneId; }
728 
729  int16_t startYear() const { return mZoneInfo->zoneContext->startYear; }
730 
731  int16_t untilYear() const { return mZoneInfo->zoneContext->untilYear; }
732 
733  uint8_t numEras() const { return mZoneInfo->numEras; }
734 
735  const ZoneEraBroker era(uint8_t i) const {
736  return ZoneEraBroker(&mZoneInfo->eras[i]);
737  }
738 
739  #endif
740 
741  private:
742  const ZoneInfo* mZoneInfo;
743 };
744 
750  public:
751  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
752  mZoneRegistry(zoneRegistry) {}
753 
754  // use default copy constructor
755  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
756 
757  // use default assignment operator
758  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
759 
760  #if ACE_TIME_USE_PROGMEM
761 
762  const ZoneInfo* zoneInfo(uint16_t i) const {
763  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
764  }
765 
766  #else
767 
768  const ZoneInfo* zoneInfo(uint16_t i) const {
769  return mZoneRegistry[i];
770  }
771 
772  #endif
773 
774  private:
775  const ZoneInfo* const* const mZoneRegistry;
776 };
777 
778 } // extended
779 
780 }
781 
782 #endif
ace_time::extended::toDeltaMinutes
int16_t toDeltaMinutes(int8_t deltaCode)
Convert the deltaCode in the ZoneInfo struct to the actual deltaMinutes.
Definition: Brokers.h:419
ace_time::basic::ZoneRuleBroker
Data broker for accessing ZoneRule.
Definition: Brokers.h:66
ace_time::extended::ZoneRuleBroker
Data broker for accessing ZoneRule.
Definition: Brokers.h:433
ace_time::basic::ZoneEraBroker
Data broker for accessing ZoneEra.
Definition: Brokers.h:213
ace_time::internal::toSuffix
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
ace_time::basic::ZoneInfoBroker
Data broker for accessing ZoneInfo.
Definition: Brokers.h:306
ace_time::extended::ZoneRegistryBroker
Data broker for accessing the ZoneRegistry.
Definition: Brokers.h:749
ace_time::extended::ZonePolicyBroker
Data broker for accessing ZonePolicy.
Definition: Brokers.h:523
ace_time::extended::ZoneInfoBroker
Data broker for accessing ZoneInfo.
Definition: Brokers.h:679
ace_time::basic::ZoneRegistryBroker
Data broker for accessing the ZoneRegistry.
Definition: Brokers.h:376
ace_time::extended::ZoneEraBroker
Data broker for accessing ZoneEra.
Definition: Brokers.h:579
ace_time::internal::timeCodeToMinutes
uint16_t timeCodeToMinutes(uint8_t code, uint8_t modifier)
Convert (timeCode, timeModifier) fields in zoneinfo to minutes.
Definition: Brokers.h:47
ace_time::basic::ZonePolicyBroker
Data broker for accessing ZonePolicy.
Definition: Brokers.h:154
ace_time::extended::toOffsetMinutes
int16_t toOffsetMinutes(int8_t offsetCode, int8_t deltaCode)
Convert the offsetCode and deltaCode into a signed 8-bit integer.
Definition: Brokers.h:428