AceTime  0.5.1
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 common {
46 
47 //----------------------------------------------------------------------------
48 // Direct data brokers for reading from SRAM
49 //----------------------------------------------------------------------------
50 
52 template <typename ZR>
54  public:
55  explicit DirectZoneRuleBroker(const ZR* zoneRule):
56  mZoneRule(zoneRule) {}
57 
59  mZoneRule(nullptr) {}
60 
61  // use the default copy constructor
63 
64  // use the default assignment operator
65  DirectZoneRuleBroker& operator=(const DirectZoneRuleBroker&) = default;
66 
67  bool isNull() const { return mZoneRule == nullptr; }
68 
69  bool isNotNull() const { return mZoneRule != nullptr; }
70 
71  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
72 
73  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
74 
75  int8_t inMonth() const { return mZoneRule->inMonth; }
76 
77  int8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
78 
79  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
80 
81  uint8_t atTimeCode() const { return mZoneRule->atTimeCode; }
82 
83  uint8_t atTimeModifier() const { return mZoneRule->atTimeModifier; }
84 
85  int8_t deltaCode() const { return mZoneRule->deltaCode; }
86 
87  uint8_t letter() const { return mZoneRule->letter; }
88 
89  private:
90  const ZR* mZoneRule;
91 };
92 
94 template <typename ZP, typename ZR>
96  public:
97  explicit DirectZonePolicyBroker(const ZP* zonePolicy):
98  mZonePolicy(zonePolicy) {}
99 
100  // use default copy constructor
102 
103  // use default assignment operator
104  DirectZonePolicyBroker& operator=(const DirectZonePolicyBroker&) = delete;
105 
106  bool isNull() const { return mZonePolicy == nullptr; }
107 
108  bool isNotNull() const { return mZonePolicy != nullptr; }
109 
110  uint8_t numRules() const { return mZonePolicy->numRules; }
111 
112  const DirectZoneRuleBroker<ZR> rule(uint8_t i) const {
113  return DirectZoneRuleBroker<ZR>(&mZonePolicy->rules[i]);
114  }
115 
116  uint8_t numLetters() const { return mZonePolicy->numLetters; }
117 
118  const char* letter(uint8_t i) const {
119  return mZonePolicy->letters[i];
120  }
121 
122  private:
123  const ZP* const mZonePolicy;
124 };
125 
127 template <typename ZE, typename ZP, typename ZR>
129  public:
130  explicit DirectZoneEraBroker(const ZE* zoneEra):
131  mZoneEra(zoneEra) {}
132 
134  mZoneEra(nullptr) {}
135 
136  // use default copy constructor
137  DirectZoneEraBroker(const DirectZoneEraBroker&) = default;
138 
139  // use default assignment operator
140  DirectZoneEraBroker& operator=(const DirectZoneEraBroker&) = default;
141 
142  const ZE* zoneEra() const { return mZoneEra; }
143 
144  bool isNull() const { return mZoneEra == nullptr; }
145 
146  bool isNotNull() const { return mZoneEra != nullptr; }
147 
148  int8_t offsetCode() const { return mZoneEra->offsetCode; }
149 
150  const DirectZonePolicyBroker<ZP, ZR> zonePolicy() const {
151  return DirectZonePolicyBroker<ZP, ZR>(mZoneEra->zonePolicy);
152  }
153 
154  int8_t deltaCode() const { return mZoneEra->deltaCode; }
155 
156  const char* format() const { return mZoneEra->format; }
157 
158  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
159 
160  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
161 
162  uint8_t untilDay() const { return mZoneEra->untilDay; }
163 
164  uint8_t untilTimeCode() const { return mZoneEra->untilTimeCode; }
165 
166  uint8_t untilTimeModifier() const { return mZoneEra->untilTimeModifier; }
167 
168  private:
169  const ZE* mZoneEra;
170 
171 };
172 
174 template <typename ZI, typename ZE, typename ZP, typename ZR, typename ZC>
176  public:
177  explicit DirectZoneInfoBroker(const ZI* zoneInfo):
178  mZoneInfo(zoneInfo) {}
179 
180  // use default copy constructor
181  DirectZoneInfoBroker(const DirectZoneInfoBroker&) = default;
182 
183  // use default assignment operator
184  DirectZoneInfoBroker& operator=(const DirectZoneInfoBroker&) = default;
185 
186  const ZI* zoneInfo() const { return mZoneInfo; }
187 
188  uint32_t zoneId() const { return mZoneInfo->zoneId; }
189 
190  const char* name() const { return mZoneInfo->name; }
191 
192  int16_t startYear() const { return mZoneInfo->zoneContext->startYear; }
193 
194  int16_t untilYear() const { return mZoneInfo->zoneContext->untilYear; }
195 
196  uint8_t numEras() const { return mZoneInfo->numEras; }
197 
198  const DirectZoneEraBroker<ZE, ZP, ZR> era(uint8_t i) const {
199  return DirectZoneEraBroker<ZE, ZP, ZR>(&mZoneInfo->eras[i]);
200  }
201 
202  private:
203  const ZI* mZoneInfo;
204 };
205 
210 template <typename ZI>
212  public:
213  DirectZoneRegistryBroker(const ZI* const* zoneRegistry):
214  mZoneRegistry(zoneRegistry) {}
215 
216  // delete default copy constructor
218 
219  // delete default assignment operator
221  delete;
222 
223  const ZI* zoneInfo(uint16_t i) const {
224  return mZoneRegistry[i];
225  }
226 
227  private:
228  const ZI* const* const mZoneRegistry;
229 };
230 
231 //----------------------------------------------------------------------------
232 // Data brokers for reading from PROGMEM.
233 //----------------------------------------------------------------------------
234 
236 template <typename ZR>
238  public:
239  explicit FlashZoneRuleBroker(const ZR* zoneRule):
240  mZoneRule(zoneRule) {}
241 
243  mZoneRule(nullptr) {}
244 
245  // use the default copy constructor
246  FlashZoneRuleBroker(const FlashZoneRuleBroker&) = default;
247 
248  // use the default assignment operator
249  FlashZoneRuleBroker& operator=(const FlashZoneRuleBroker&) = default;
250 
251  bool isNull() const { return mZoneRule == nullptr; }
252 
253  bool isNotNull() const { return mZoneRule != nullptr; }
254 
255  int8_t fromYearTiny() const {
256  return pgm_read_byte(&mZoneRule->fromYearTiny);
257  }
258 
259  int8_t toYearTiny() const {
260  return pgm_read_byte(&mZoneRule->toYearTiny);
261  }
262 
263  int8_t inMonth() const {
264  return pgm_read_byte(&mZoneRule->inMonth);
265  }
266 
267  int8_t onDayOfWeek() const {
268  return pgm_read_byte(&mZoneRule->onDayOfWeek);
269  }
270 
271  int8_t onDayOfMonth() const {
272  return pgm_read_byte(&mZoneRule->onDayOfMonth);
273  }
274 
275  uint8_t atTimeCode() const {
276  return pgm_read_byte(&mZoneRule->atTimeCode);
277  }
278 
279  uint8_t atTimeModifier() const {
280  return pgm_read_byte(&mZoneRule->atTimeModifier);
281  }
282 
283  int8_t deltaCode() const {
284  return pgm_read_byte(&mZoneRule->deltaCode);
285  }
286 
287  uint8_t letter() const {
288  return pgm_read_byte(&mZoneRule->letter);
289  }
290 
291  private:
292  const ZR* mZoneRule;
293 };
294 
296 template <typename ZP, typename ZR>
298  public:
299  explicit FlashZonePolicyBroker(const ZP* zonePolicy):
300  mZonePolicy(zonePolicy) {}
301 
302  // use default copy constructor
304 
305  // use default assignment operator
306  FlashZonePolicyBroker& operator=(const FlashZonePolicyBroker&) = default;
307 
308  bool isNull() const { return mZonePolicy == nullptr; }
309 
310  bool isNotNull() const { return mZonePolicy != nullptr; }
311 
312  uint8_t numRules() const {
313  return pgm_read_byte(&mZonePolicy->numRules);
314  }
315 
316  const FlashZoneRuleBroker<ZR> rule(uint8_t i) const {
317  const ZR* rules = (const ZR*) pgm_read_ptr(&mZonePolicy->rules);
318  return FlashZoneRuleBroker<ZR>(&rules[i]);
319  }
320 
321  uint8_t numLetters() const {
322  return pgm_read_byte(&mZonePolicy->numLetters);
323  }
324 
325  const char* letter(uint8_t i) const {
326  const char* const* letters = (const char* const*)
327  pgm_read_ptr(&mZonePolicy->letters);
328  return (const char*) pgm_read_ptr(&letters[i]);
329  }
330 
331  private:
332  const ZP* const mZonePolicy;
333 };
334 
336 template <typename ZE, typename ZP, typename ZR>
338  public:
339  explicit FlashZoneEraBroker(const ZE* zoneEra):
340  mZoneEra(zoneEra) {}
341 
343  mZoneEra(nullptr) {}
344 
345  // use default copy constructor
346  FlashZoneEraBroker(const FlashZoneEraBroker&) = default;
347 
348  // use default assignment operator
349  FlashZoneEraBroker& operator=(const FlashZoneEraBroker&) = default;
350 
351  const ZE* zoneEra() const { return mZoneEra; }
352 
353  bool isNull() const { return mZoneEra == nullptr; }
354 
355  bool isNotNull() const { return mZoneEra != nullptr; }
356 
357  int8_t offsetCode() const {
358  return pgm_read_byte(&mZoneEra->offsetCode);
359  }
360 
361  const FlashZonePolicyBroker<ZP, ZR> zonePolicy() const {
363  (const ZP*) pgm_read_ptr(&mZoneEra->zonePolicy));
364  }
365 
366  int8_t deltaCode() const {
367  return pgm_read_byte(&mZoneEra->deltaCode);
368  }
369 
370  const char* format() const {
371  return (const char*) pgm_read_ptr(&mZoneEra->format);
372  }
373 
374  int8_t untilYearTiny() const {
375  return pgm_read_byte(&mZoneEra->untilYearTiny);
376  }
377 
378  uint8_t untilMonth() const {
379  return pgm_read_byte(&mZoneEra->untilMonth);
380  }
381 
382  uint8_t untilDay() const {
383  return pgm_read_byte(&mZoneEra->untilDay);
384  }
385 
386  uint8_t untilTimeCode() const {
387  return pgm_read_byte(&mZoneEra->untilTimeCode);
388  }
389 
390  uint8_t untilTimeModifier() const {
391  return pgm_read_byte(&mZoneEra->untilTimeModifier);
392  }
393 
394  private:
395  const ZE* mZoneEra;
396 
397 };
398 
400 template <typename ZI, typename ZE, typename ZP, typename ZR, typename ZC>
402  public:
403  explicit FlashZoneInfoBroker(const ZI* zoneInfo):
404  mZoneInfo(zoneInfo) {}
405 
406  // use default copy constructor
407  FlashZoneInfoBroker(const FlashZoneInfoBroker&) = default;
408 
409  // use default assignment operator
410  FlashZoneInfoBroker& operator=(const FlashZoneInfoBroker&) = default;
411 
412  const ZI* zoneInfo() const { return mZoneInfo; }
413 
414  const char* name() const {
415  return (const char*) pgm_read_ptr(&mZoneInfo->name);
416  }
417 
418  uint32_t zoneId() const {
419  return pgm_read_dword(&mZoneInfo->zoneId);
420  }
421 
422  int16_t startYear() const {
423  const ZC* zoneContext = (const ZC*) pgm_read_ptr(&mZoneInfo->zoneContext);
424  return zoneContext->startYear;
425  }
426 
427  int16_t untilYear() const {
428  const ZC* zoneContext = (const ZC*) pgm_read_ptr(&mZoneInfo->zoneContext);
429  return zoneContext->untilYear;
430  }
431 
432  uint8_t numEras() const {
433  return pgm_read_byte(&mZoneInfo->numEras);
434  }
435 
436  const FlashZoneEraBroker<ZE, ZP, ZR> era(uint8_t i) const {
437  const ZE* eras = (const ZE*) pgm_read_ptr(&mZoneInfo->eras);
438  return FlashZoneEraBroker<ZE, ZP, ZR>(&eras[i]);
439  }
440 
441  private:
442  const ZI* mZoneInfo;
443 };
444 
449 template <typename ZI>
451  public:
452  explicit FlashZoneRegistryBroker(const ZI* const* zoneRegistry):
453  mZoneRegistry(zoneRegistry) {}
454 
455  // use default copy constructor
457 
458  // use default assignment operator
460  default;
461 
462  const ZI* zoneInfo(uint16_t i) const {
463  return (const ZI*) pgm_read_ptr(&mZoneRegistry[i]);
464  }
465 
466  private:
467  const ZI* const* mZoneRegistry;
468 };
469 
470 }
471 
472 //----------------------------------------------------------------------------
473 
474 namespace basic {
475 
476 #if ACE_TIME_USE_PROGMEM
477 typedef common::FlashZoneRuleBroker<ZoneRule> ZoneRuleBroker;
480 typedef common::FlashZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
481  ZoneContext> ZoneInfoBroker;
482 typedef common::FlashZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
483 #else
484 typedef common::DirectZoneRuleBroker<ZoneRule> ZoneRuleBroker;
487  ZoneEraBroker;
488 typedef common::DirectZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
489  ZoneContext> ZoneInfoBroker;
490 typedef common::DirectZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
491 #endif
492 
493 }
494 
495 namespace extended {
496 
497 #if ACE_TIME_USE_PROGMEM
498 typedef common::FlashZoneRuleBroker<ZoneRule> ZoneRuleBroker;
501 typedef common::FlashZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
502  ZoneContext> ZoneInfoBroker;
503 typedef common::FlashZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
504 #else
505 typedef common::DirectZoneRuleBroker<ZoneRule> ZoneRuleBroker;
508  ZoneEraBroker;
509 typedef common::DirectZoneInfoBroker<ZoneInfo, ZoneEra, ZonePolicy, ZoneRule,
510  ZoneContext> ZoneInfoBroker;
511 typedef common::DirectZoneRegistryBroker<ZoneInfo> ZoneRegistryBroker;
512 #endif
513 
514 }
515 
516 }
517 
518 #endif
Data broker for accessing ZoneEra in SRAM.
Definition: Brokers.h:128
Data broker for accessing the ZoneRegistry in PROGMEM.
Definition: Brokers.h:450
Data broker for accessing ZoneInfo in SRAM.
Definition: Brokers.h:175
Data broker for accessing ZoneRule in PROGMEM.
Definition: Brokers.h:237
Data broker for accessing ZoneRule in SRAM.
Definition: Brokers.h:53
Data broker for accessing ZonePolicy in SRAM.
Definition: Brokers.h:95
Data broker for accessing ZoneEra in PROGMEM.
Definition: Brokers.h:337
Data broker for accessing ZonePolicy in PROGMEM.
Definition: Brokers.h:297
Data broker for accessing the ZoneRegistry in SRAM.
Definition: Brokers.h:211
Data broker for accessing ZoneInfo in PROGMEM.
Definition: Brokers.h:401