AceTime  0.7
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 
40 #include "../common/compat.h"
41 #include "ZoneInfo.h"
42 
43 namespace ace_time {
44 
45 namespace internal {
46 
48 inline uint16_t timeCodeToMinutes(uint8_t rawCode, uint8_t rawModifier) {
49  return rawCode * (uint16_t) 15 + (rawModifier & 0x0f);
50 }
51 
56 inline uint8_t toModifier(uint8_t rawModifier) {
57  return rawModifier & 0xf0;
58 }
59 
60 //----------------------------------------------------------------------------
61 // Direct data brokers for reading from SRAM
62 //----------------------------------------------------------------------------
63 
65 template <typename ZR>
67  public:
68  explicit DirectZoneRuleBroker(const ZR* zoneRule):
69  mZoneRule(zoneRule) {}
70 
72  mZoneRule(nullptr) {}
73 
74  // use the default copy constructor
76 
77  // use the default assignment operator
78  DirectZoneRuleBroker& operator=(const DirectZoneRuleBroker&) = default;
79 
80  bool isNull() const { return mZoneRule == nullptr; }
81 
82  bool isNotNull() const { return mZoneRule != nullptr; }
83 
84  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
85 
86  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
87 
88  int8_t inMonth() const { return mZoneRule->inMonth; }
89 
90  int8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
91 
92  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
93 
94  uint16_t atTimeMinutes() const {
95  return timeCodeToMinutes(
96  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
97  }
98 
99  uint8_t atTimeModifier() const {
100  return toModifier(mZoneRule->atTimeModifier);
101  }
102 
103  int8_t deltaCode() const { return mZoneRule->deltaCode; }
104 
105  uint8_t letter() const { return mZoneRule->letter; }
106 
107  private:
108  const ZR* mZoneRule;
109 };
110 
112 template <typename ZP, typename ZR>
114  public:
115  explicit DirectZonePolicyBroker(const ZP* zonePolicy):
116  mZonePolicy(zonePolicy) {}
117 
118  // use default copy constructor
120 
121  // use default assignment operator
122  DirectZonePolicyBroker& operator=(const DirectZonePolicyBroker&) = delete;
123 
124  bool isNull() const { return mZonePolicy == nullptr; }
125 
126  bool isNotNull() const { return mZonePolicy != nullptr; }
127 
128  uint8_t numRules() const { return mZonePolicy->numRules; }
129 
130  const DirectZoneRuleBroker<ZR> rule(uint8_t i) const {
131  return DirectZoneRuleBroker<ZR>(&mZonePolicy->rules[i]);
132  }
133 
134  uint8_t numLetters() const { return mZonePolicy->numLetters; }
135 
136  const char* letter(uint8_t i) const {
137  return mZonePolicy->letters[i];
138  }
139 
140  private:
141  const ZP* const mZonePolicy;
142 };
143 
145 template <typename ZE, typename ZP, typename ZR>
147  public:
148  explicit DirectZoneEraBroker(const ZE* zoneEra):
149  mZoneEra(zoneEra) {}
150 
152  mZoneEra(nullptr) {}
153 
154  // use default copy constructor
155  DirectZoneEraBroker(const DirectZoneEraBroker&) = default;
156 
157  // use default assignment operator
158  DirectZoneEraBroker& operator=(const DirectZoneEraBroker&) = default;
159 
160  const ZE* zoneEra() const { return mZoneEra; }
161 
162  bool isNull() const { return mZoneEra == nullptr; }
163 
164  bool isNotNull() const { return mZoneEra != nullptr; }
165 
166  int8_t offsetCode() const { return mZoneEra->offsetCode; }
167 
168  const DirectZonePolicyBroker<ZP, ZR> zonePolicy() const {
169  return DirectZonePolicyBroker<ZP, ZR>(mZoneEra->zonePolicy);
170  }
171 
172  int8_t deltaCode() const { return mZoneEra->deltaCode; }
173 
174  const char* format() const { return mZoneEra->format; }
175 
176  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
177 
178  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
179 
180  uint8_t untilDay() const { return mZoneEra->untilDay; }
181 
182  uint16_t untilTimeMinutes() const {
183  return timeCodeToMinutes(
184  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
185  }
186 
187  uint8_t untilTimeModifier() const {
188  return toModifier(mZoneEra->untilTimeModifier);
189  }
190 
191  private:
192  const ZE* mZoneEra;
193 
194 };
195 
197 template <typename ZI, typename ZE, typename ZP, typename ZR, typename ZC>
199  public:
200  explicit DirectZoneInfoBroker(const ZI* zoneInfo):
201  mZoneInfo(zoneInfo) {}
202 
203  // use default copy constructor
204  DirectZoneInfoBroker(const DirectZoneInfoBroker&) = default;
205 
206  // use default assignment operator
207  DirectZoneInfoBroker& operator=(const DirectZoneInfoBroker&) = default;
208 
209  const ZI* zoneInfo() const { return mZoneInfo; }
210 
211  uint32_t zoneId() const { return mZoneInfo->zoneId; }
212 
213  const char* name() const { return mZoneInfo->name; }
214 
215  int16_t startYear() const { return mZoneInfo->zoneContext->startYear; }
216 
217  int16_t untilYear() const { return mZoneInfo->zoneContext->untilYear; }
218 
219  uint8_t numEras() const { return mZoneInfo->numEras; }
220 
221  const DirectZoneEraBroker<ZE, ZP, ZR> era(uint8_t i) const {
222  return DirectZoneEraBroker<ZE, ZP, ZR>(&mZoneInfo->eras[i]);
223  }
224 
225  private:
226  const ZI* mZoneInfo;
227 };
228 
233 template <typename ZI>
235  public:
236  DirectZoneRegistryBroker(const ZI* const* zoneRegistry):
237  mZoneRegistry(zoneRegistry) {}
238 
239  // delete default copy constructor
241 
242  // delete default assignment operator
244  delete;
245 
246  const ZI* zoneInfo(uint16_t i) const {
247  return mZoneRegistry[i];
248  }
249 
250  private:
251  const ZI* const* const mZoneRegistry;
252 };
253 
254 //----------------------------------------------------------------------------
255 // Data brokers for reading from PROGMEM.
256 //----------------------------------------------------------------------------
257 
259 template <typename ZR>
261  public:
262  explicit FlashZoneRuleBroker(const ZR* zoneRule):
263  mZoneRule(zoneRule) {}
264 
266  mZoneRule(nullptr) {}
267 
268  // use the default copy constructor
269  FlashZoneRuleBroker(const FlashZoneRuleBroker&) = default;
270 
271  // use the default assignment operator
272  FlashZoneRuleBroker& operator=(const FlashZoneRuleBroker&) = default;
273 
274  bool isNull() const { return mZoneRule == nullptr; }
275 
276  bool isNotNull() const { return mZoneRule != nullptr; }
277 
278  int8_t fromYearTiny() const {
279  return pgm_read_byte(&mZoneRule->fromYearTiny);
280  }
281 
282  int8_t toYearTiny() const {
283  return pgm_read_byte(&mZoneRule->toYearTiny);
284  }
285 
286  int8_t inMonth() const {
287  return pgm_read_byte(&mZoneRule->inMonth);
288  }
289 
290  int8_t onDayOfWeek() const {
291  return pgm_read_byte(&mZoneRule->onDayOfWeek);
292  }
293 
294  int8_t onDayOfMonth() const {
295  return pgm_read_byte(&mZoneRule->onDayOfMonth);
296  }
297 
298  uint16_t atTimeMinutes() const {
299  return timeCodeToMinutes(
300  pgm_read_byte(&mZoneRule->atTimeCode),
301  pgm_read_byte(&mZoneRule->atTimeModifier));
302  }
303 
304  uint8_t atTimeModifier() const {
305  return toModifier(pgm_read_byte(&mZoneRule->atTimeModifier));
306  }
307 
308  int8_t deltaCode() const {
309  return pgm_read_byte(&mZoneRule->deltaCode);
310  }
311 
312  uint8_t letter() const {
313  return pgm_read_byte(&mZoneRule->letter);
314  }
315 
316  private:
317  const ZR* mZoneRule;
318 };
319 
321 template <typename ZP, typename ZR>
323  public:
324  explicit FlashZonePolicyBroker(const ZP* zonePolicy):
325  mZonePolicy(zonePolicy) {}
326 
327  // use default copy constructor
329 
330  // use default assignment operator
331  FlashZonePolicyBroker& operator=(const FlashZonePolicyBroker&) = default;
332 
333  bool isNull() const { return mZonePolicy == nullptr; }
334 
335  bool isNotNull() const { return mZonePolicy != nullptr; }
336 
337  uint8_t numRules() const {
338  return pgm_read_byte(&mZonePolicy->numRules);
339  }
340 
341  const FlashZoneRuleBroker<ZR> rule(uint8_t i) const {
342  const ZR* rules = (const ZR*) pgm_read_ptr(&mZonePolicy->rules);
343  return FlashZoneRuleBroker<ZR>(&rules[i]);
344  }
345 
346  uint8_t numLetters() const {
347  return pgm_read_byte(&mZonePolicy->numLetters);
348  }
349 
350  const char* letter(uint8_t i) const {
351  const char* const* letters = (const char* const*)
352  pgm_read_ptr(&mZonePolicy->letters);
353  return (const char*) pgm_read_ptr(&letters[i]);
354  }
355 
356  private:
357  const ZP* const mZonePolicy;
358 };
359 
361 template <typename ZE, typename ZP, typename ZR>
363  public:
364  explicit FlashZoneEraBroker(const ZE* zoneEra):
365  mZoneEra(zoneEra) {}
366 
368  mZoneEra(nullptr) {}
369 
370  // use default copy constructor
371  FlashZoneEraBroker(const FlashZoneEraBroker&) = default;
372 
373  // use default assignment operator
374  FlashZoneEraBroker& operator=(const FlashZoneEraBroker&) = default;
375 
376  const ZE* zoneEra() const { return mZoneEra; }
377 
378  bool isNull() const { return mZoneEra == nullptr; }
379 
380  bool isNotNull() const { return mZoneEra != nullptr; }
381 
382  int8_t offsetCode() const {
383  return pgm_read_byte(&mZoneEra->offsetCode);
384  }
385 
386  const FlashZonePolicyBroker<ZP, ZR> zonePolicy() const {
388  (const ZP*) pgm_read_ptr(&mZoneEra->zonePolicy));
389  }
390 
391  int8_t deltaCode() const {
392  return pgm_read_byte(&mZoneEra->deltaCode);
393  }
394 
395  const char* format() const {
396  return (const char*) pgm_read_ptr(&mZoneEra->format);
397  }
398 
399  int8_t untilYearTiny() const {
400  return pgm_read_byte(&mZoneEra->untilYearTiny);
401  }
402 
403  uint8_t untilMonth() const {
404  return pgm_read_byte(&mZoneEra->untilMonth);
405  }
406 
407  uint8_t untilDay() const {
408  return pgm_read_byte(&mZoneEra->untilDay);
409  }
410 
411  uint16_t untilTimeMinutes() const {
412  return timeCodeToMinutes(
413  pgm_read_byte(&mZoneEra->untilTimeCode),
414  pgm_read_byte(&mZoneEra->untilTimeModifier));
415  }
416 
417  uint8_t untilTimeModifier() const {
418  return toModifier(pgm_read_byte(&mZoneEra->untilTimeModifier));
419  }
420 
421  private:
422  const ZE* mZoneEra;
423 
424 };
425 
427 template <typename ZI, typename ZE, typename ZP, typename ZR, typename ZC>
429  public:
430  explicit FlashZoneInfoBroker(const ZI* zoneInfo):
431  mZoneInfo(zoneInfo) {}
432 
433  // use default copy constructor
434  FlashZoneInfoBroker(const FlashZoneInfoBroker&) = default;
435 
436  // use default assignment operator
437  FlashZoneInfoBroker& operator=(const FlashZoneInfoBroker&) = default;
438 
439  const ZI* zoneInfo() const { return mZoneInfo; }
440 
441  const char* name() const {
442  return (const char*) pgm_read_ptr(&mZoneInfo->name);
443  }
444 
445  uint32_t zoneId() const {
446  return pgm_read_dword(&mZoneInfo->zoneId);
447  }
448 
449  int16_t startYear() const {
450  const ZC* zoneContext = (const ZC*) pgm_read_ptr(&mZoneInfo->zoneContext);
451  return zoneContext->startYear;
452  }
453 
454  int16_t untilYear() const {
455  const ZC* zoneContext = (const ZC*) pgm_read_ptr(&mZoneInfo->zoneContext);
456  return zoneContext->untilYear;
457  }
458 
459  uint8_t numEras() const {
460  return pgm_read_byte(&mZoneInfo->numEras);
461  }
462 
463  const FlashZoneEraBroker<ZE, ZP, ZR> era(uint8_t i) const {
464  const ZE* eras = (const ZE*) pgm_read_ptr(&mZoneInfo->eras);
465  return FlashZoneEraBroker<ZE, ZP, ZR>(&eras[i]);
466  }
467 
468  private:
469  const ZI* mZoneInfo;
470 };
471 
476 template <typename ZI>
478  public:
479  explicit FlashZoneRegistryBroker(const ZI* const* zoneRegistry):
480  mZoneRegistry(zoneRegistry) {}
481 
482  // use default copy constructor
484 
485  // use default assignment operator
487  default;
488 
489  const ZI* zoneInfo(uint16_t i) const {
490  return (const ZI*) pgm_read_ptr(&mZoneRegistry[i]);
491  }
492 
493  private:
494  const ZI* const* mZoneRegistry;
495 };
496 
497 }
498 
499 //----------------------------------------------------------------------------
500 
501 namespace basic {
502 
503 #if ACE_TIME_USE_PROGMEM
504 typedef internal::FlashZoneRuleBroker<ZoneRule> ZoneRuleBroker;
507  ZoneEraBroker;
508 typedef internal::FlashZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
509  ZoneContext> ZoneInfoBroker;
510 typedef internal::FlashZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
511 #else
512 typedef internal::DirectZoneRuleBroker<ZoneRule> ZoneRuleBroker;
515  ZoneEraBroker;
516 typedef internal::DirectZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
517  ZoneContext> ZoneInfoBroker;
518 typedef internal::DirectZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
519 #endif
520 
521 }
522 
523 namespace extended {
524 
525 #if ACE_TIME_USE_PROGMEM
526 typedef internal::FlashZoneRuleBroker<ZoneRule> ZoneRuleBroker;
529  ZoneEraBroker;
530 typedef internal::FlashZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
531  ZoneContext> ZoneInfoBroker;
532 typedef internal::FlashZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
533 #else
534 typedef internal::DirectZoneRuleBroker<ZoneRule> ZoneRuleBroker;
537  ZoneEraBroker;
538 typedef internal::DirectZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
539  ZoneContext> ZoneInfoBroker;
540 typedef internal::DirectZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
541 #endif
542 
543 }
544 
545 }
546 
547 #endif
Data broker for accessing ZonePolicy in SRAM.
Definition: Brokers.h:113
Data broker for accessing ZoneRule in SRAM.
Definition: Brokers.h:66
Data broker for accessing ZonePolicy in PROGMEM.
Definition: Brokers.h:322
Data broker for accessing the ZoneRegistry in SRAM.
Definition: Brokers.h:234
Data broker for accessing ZoneInfo in PROGMEM.
Definition: Brokers.h:428
Data broker for accessing ZoneEra in SRAM.
Definition: Brokers.h:146
Data broker for accessing ZoneEra in PROGMEM.
Definition: Brokers.h:362
Data broker for accessing the ZoneRegistry in PROGMEM.
Definition: Brokers.h:477
Data broker for accessing ZoneInfo in SRAM.
Definition: Brokers.h:198
uint8_t toModifier(uint8_t rawModifier)
Extract the &#39;w&#39;, &#39;s&#39; &#39;u&#39; suffix from the &#39;modifier&#39; field, so that they can be compared against TIME_...
Definition: Brokers.h:56
uint16_t timeCodeToMinutes(uint8_t rawCode, uint8_t rawModifier)
Convert (timeCode, timeModifier) fields in zoneinfo to minutes.
Definition: Brokers.h:48
Data broker for accessing ZoneRule in PROGMEM.
Definition: Brokers.h:260