AceTime  1.11.2
Date and time classes for Arduino that support timezones from the TZ Database.
BasicBrokers.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_BASIC_BROKERS_H
7 #define ACE_TIME_BASIC_BROKERS_H
8 
38 #include <stdint.h> // uintptr_t, uint32_t, etc
39 #include "../common/compat.h" // ACE_TIME_USE_PROGMEM
40 #include "BrokerCommon.h"
41 #include "ZoneInfo.h"
42 #include "LinkEntry.h"
43 
44 class __FlashStringHelper;
45 class Print;
46 
47 namespace ace_time {
48 namespace basic {
49 
52  public:
53  explicit ZoneRuleBroker(const ZoneRule* zoneRule = nullptr):
54  mZoneRule(zoneRule) {}
55 
56  // use the default copy constructor
57  ZoneRuleBroker(const ZoneRuleBroker&) = default;
58 
59  // use the default assignment operator
60  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
61 
62  bool isNull() const { return mZoneRule == nullptr; }
63 
64  #if ACE_TIME_USE_PROGMEM
65 
66  int8_t fromYearTiny() const {
67  return pgm_read_byte(&mZoneRule->fromYearTiny);
68  }
69 
70  int8_t toYearTiny() const {
71  return pgm_read_byte(&mZoneRule->toYearTiny);
72  }
73 
74  uint8_t inMonth() const {
75  return pgm_read_byte(&mZoneRule->inMonth);
76  }
77 
78  int8_t onDayOfWeek() const {
79  return pgm_read_byte(&mZoneRule->onDayOfWeek);
80  }
81 
82  int8_t onDayOfMonth() const {
83  return pgm_read_byte(&mZoneRule->onDayOfMonth);
84  }
85 
86  uint16_t atTimeMinutes() const {
87  return internal::timeCodeToMinutes(
88  pgm_read_byte(&mZoneRule->atTimeCode),
89  pgm_read_byte(&mZoneRule->atTimeModifier));
90  }
91 
92  uint8_t atTimeSuffix() const {
93  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
94  }
95 
96  int16_t deltaMinutes() const {
97  return 15 * (int8_t) pgm_read_byte(&mZoneRule->deltaCode);
98  }
99 
100  uint8_t letter() const {
101  return pgm_read_byte(&mZoneRule->letter);
102  }
103 
104  #else
105 
106  int8_t fromYearTiny() const { return mZoneRule->fromYearTiny; }
107 
108  int8_t toYearTiny() const { return mZoneRule->toYearTiny; }
109 
110  uint8_t inMonth() const { return mZoneRule->inMonth; }
111 
112  uint8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
113 
114  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
115 
116  uint16_t atTimeMinutes() const {
117  return internal::timeCodeToMinutes(
118  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
119  }
120 
121  uint8_t atTimeSuffix() const {
122  return internal::toSuffix(mZoneRule->atTimeModifier);
123  }
124 
125  int16_t deltaMinutes() const { return 15 * mZoneRule->deltaCode; }
126 
127  uint8_t letter() const { return mZoneRule->letter; }
128 
129  #endif
130 
131  private:
132  const ZoneRule* mZoneRule;
133 };
134 
137  public:
138  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy = nullptr):
139  mZonePolicy(zonePolicy) {}
140 
141  // use default copy constructor
142  ZonePolicyBroker(const ZonePolicyBroker&) = default;
143 
144  // use default assignment operator
145  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
146 
147  bool isNull() const { return mZonePolicy == nullptr; }
148 
149  #if ACE_TIME_USE_PROGMEM
150 
151  uint8_t numRules() const {
152  return pgm_read_byte(&mZonePolicy->numRules);
153  }
154 
155  const ZoneRuleBroker rule(uint8_t i) const {
156  const ZoneRule* rules =
157  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
158  return ZoneRuleBroker(&rules[i]);
159  }
160 
161  uint8_t numLetters() const {
162  return pgm_read_byte(&mZonePolicy->numLetters);
163  }
164 
165  const char* letter(uint8_t i) const {
166  const char* const* letters = (const char* const*)
167  pgm_read_ptr(&mZonePolicy->letters);
168  return (const char*) pgm_read_ptr(&letters[i]);
169  }
170 
171  #else
172 
173  uint8_t numRules() const { return mZonePolicy->numRules; }
174 
175  const ZoneRuleBroker rule(uint8_t i) const {
176  return ZoneRuleBroker(&mZonePolicy->rules[i]);
177  }
178 
179  uint8_t numLetters() const { return mZonePolicy->numLetters; }
180 
181  const char* letter(uint8_t i) const {
182  return mZonePolicy->letters[i];
183  }
184 
185  #endif
186 
187  private:
188  const ZonePolicy* mZonePolicy;
189 };
190 
191 //-----------------------------------------------------------------------------
192 
195  public:
196  explicit ZoneEraBroker(const ZoneEra* zoneEra = nullptr):
197  mZoneEra(zoneEra) {}
198 
199  // use default copy constructor
200  ZoneEraBroker(const ZoneEraBroker&) = default;
201 
202  // use default assignment operator
203  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
204 
205  bool isNull() const { return mZoneEra == nullptr; }
206 
207  bool equals(const ZoneEraBroker& other) const {
208  return mZoneEra == other.mZoneEra;
209  }
210 
211  #if ACE_TIME_USE_PROGMEM
212 
213  const ZonePolicyBroker zonePolicy() const {
214  return ZonePolicyBroker(
215  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
216  }
217 
218  int16_t offsetMinutes() const {
219  return 15 * (int8_t) pgm_read_byte(&mZoneEra->offsetCode);
220  }
221 
222  int16_t deltaMinutes() const {
223  return 15 * (int8_t) pgm_read_byte(&mZoneEra->deltaCode);
224  }
225 
226  const char* format() const {
227  return (const char*) pgm_read_ptr(&mZoneEra->format);
228  }
229 
230  int8_t untilYearTiny() const {
231  return pgm_read_byte(&mZoneEra->untilYearTiny);
232  }
233 
234  uint8_t untilMonth() const {
235  return pgm_read_byte(&mZoneEra->untilMonth);
236  }
237 
238  uint8_t untilDay() const {
239  return pgm_read_byte(&mZoneEra->untilDay);
240  }
241 
242  uint16_t untilTimeMinutes() const {
243  return internal::timeCodeToMinutes(
244  pgm_read_byte(&mZoneEra->untilTimeCode),
245  pgm_read_byte(&mZoneEra->untilTimeModifier));
246  }
247 
248  uint8_t untilTimeSuffix() const {
249  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
250  }
251 
252  #else
253 
254  int16_t offsetMinutes() const { return 15 * mZoneEra->offsetCode; }
255 
256  const ZonePolicyBroker zonePolicy() const {
257  return ZonePolicyBroker(mZoneEra->zonePolicy);
258  }
259 
260  int16_t deltaMinutes() const { return 15 * mZoneEra->deltaCode; }
261 
262  const char* format() const { return mZoneEra->format; }
263 
264  int8_t untilYearTiny() const { return mZoneEra->untilYearTiny; }
265 
266  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
267 
268  uint8_t untilDay() const { return mZoneEra->untilDay; }
269 
270  uint16_t untilTimeMinutes() const {
271  return internal::timeCodeToMinutes(
272  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
273  }
274 
275  uint8_t untilTimeSuffix() const {
276  return internal::toSuffix(mZoneEra->untilTimeModifier);
277  }
278 
279  #endif
280 
281  private:
282  const ZoneEra* mZoneEra;
283 };
284 
287  public:
288  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo = nullptr):
289  mZoneInfo(zoneInfo) {}
290 
291  // use default copy constructor
292  ZoneInfoBroker(const ZoneInfoBroker&) = default;
293 
294  // use default assignment operator
295  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
296 
297  bool equals(uintptr_t zoneKey) const {
298  return mZoneInfo == (const ZoneInfo*) zoneKey;
299  }
300 
301  bool equals(const ZoneInfoBroker& zoneInfoBroker) const {
302  return mZoneInfo == zoneInfoBroker.mZoneInfo;
303  }
304 
305  bool isNull() const { return mZoneInfo == nullptr; }
306 
307  bool isLink() const { return pgm_read_byte(&mZoneInfo->numEras) == 0; }
308 
314  return ZoneInfoBroker((const ZoneInfo*) pgm_read_ptr(&mZoneInfo->eras));
315  }
316 
317  #if ACE_TIME_USE_PROGMEM
318 
319  const internal::ZoneContext* zoneContext() const {
320  return (const internal::ZoneContext*)
321  pgm_read_ptr(&mZoneInfo->zoneContext);
322  }
323 
324  const __FlashStringHelper* name() const {
325  return FPSTR(pgm_read_ptr(&mZoneInfo->name));
326  }
327 
328  uint32_t zoneId() const {
329  return pgm_read_dword(&mZoneInfo->zoneId);
330  }
331 
332  uint8_t numEras() const {
333  if (isLink()) {
334  return targetZoneInfo().numEras();
335  } else {
336  return pgm_read_byte(&mZoneInfo->numEras);
337  }
338  }
339 
340  const ZoneEraBroker era(uint8_t i) const {
341  if (isLink()) {
342  return targetZoneInfo().era(i);
343  } else {
344  auto eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
345  return ZoneEraBroker(&eras[i]);
346  }
347  }
348 
349  #else
350 
351  const internal::ZoneContext* zoneContext() const {
352  return mZoneInfo->zoneContext;
353  }
354 
355  const char* name() const { return mZoneInfo->name; }
356 
357  uint32_t zoneId() const { return mZoneInfo->zoneId; }
358 
359  uint8_t numEras() const { return mZoneInfo->numEras; }
360 
361  const ZoneEraBroker era(uint8_t i) const {
362  return ZoneEraBroker(&mZoneInfo->eras[i]);
363  }
364 
365  #endif
366 
368  void printNameTo(Print& printer) const;
369 
374  void printShortNameTo(Print& printer) const;
375 
376  private:
377  const ZoneInfo* mZoneInfo;
378 };
379 
385  public:
386  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
387  mZoneRegistry(zoneRegistry) {}
388 
389  // use default copy constructor
390  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
391 
392  // use default assignment operator
393  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
394 
395  #if ACE_TIME_USE_PROGMEM
396 
397  const ZoneInfo* zoneInfo(uint16_t i) const {
398  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
399  }
400 
401  #else
402 
403  const ZoneInfo* zoneInfo(uint16_t i) const {
404  return mZoneRegistry[i];
405  }
406 
407  #endif
408 
409  private:
410  const ZoneInfo* const* mZoneRegistry;
411 };
412 
413 //-----------------------------------------------------------------------------
414 
417  public:
418  explicit LinkEntryBroker(const LinkEntry* linkEntry = nullptr):
419  mLinkEntry(linkEntry) {}
420 
421  // use default copy constructor
422  LinkEntryBroker(const LinkEntryBroker&) = default;
423 
424  // use default assignment operator
425  LinkEntryBroker& operator=(const LinkEntryBroker&) = default;
426 
427  #if ACE_TIME_USE_PROGMEM
428  uint32_t zoneId() const { return pgm_read_dword(&mLinkEntry->zoneId); }
429  uint32_t linkId() const { return pgm_read_dword(&mLinkEntry->linkId); }
430 
431  #else
432  uint32_t zoneId() const { return mLinkEntry->zoneId; }
433  uint32_t linkId() const { return mLinkEntry->linkId; }
434 
435  #endif
436 
437  private:
438  const LinkEntry* mLinkEntry;
439 };
440 
445  public:
446  LinkRegistryBroker(const LinkEntry zoneRegistry[]):
447  mLinkRegistry(zoneRegistry) {}
448 
449  // use default copy constructor
450  LinkRegistryBroker(const LinkRegistryBroker&) = default;
451 
452  // use default assignment operator
453  LinkRegistryBroker& operator=(const LinkRegistryBroker&) = default;
454 
455  // Same code whether or not ACE_TIME_USE_PROGMEM is active.
456  const LinkEntry* linkEntry(uint16_t i) const {
457  return &mLinkRegistry[i];
458  }
459 
460  private:
461  const LinkEntry* mLinkRegistry;
462 };
463 
464 //-----------------------------------------------------------------------------
465 
468  public:
469  ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const {
470  return ZoneInfoBroker((const ZoneInfo*) zoneKey);
471  }
472 };
473 
474 } // basic
475 } // ace_time
476 
477 #endif
BrokerCommon.h
ace_time::basic::ZoneRuleBroker
Data broker for accessing ZoneRule.
Definition: BasicBrokers.h:51
ace_time::basic::ZoneInfoBroker::printNameTo
void printNameTo(Print &printer) const
Print a human-readable identifier (e.g.
Definition: BasicBrokers.cpp:19
ace_time::basic::ZoneEraBroker
Data broker for accessing ZoneEra.
Definition: BasicBrokers.h:194
ace_time::internal::ZoneContext
Metadata about the zone database.
Definition: ZoneContext.h:16
ace_time::basic::ZoneInfoBroker::printShortNameTo
void printShortNameTo(Print &printer) const
Print a short human-readable identifier (e.g.
Definition: BasicBrokers.cpp:25
ace_time::basic::BrokerFactory
A factory that creates a basic::ZoneInfoBroker.
Definition: BasicBrokers.h:467
ace_time::basic::ZoneInfoBroker
Data broker for accessing ZoneInfo.
Definition: BasicBrokers.h:286
ace_time::basic::ZoneRegistryBroker
Data broker for accessing the ZoneRegistry.
Definition: BasicBrokers.h:384
ace_time::basic::LinkRegistryBroker
Data broker for a LinkRegistry composed of LinkEntry records.
Definition: BasicBrokers.h:444
ace_time::basic::LinkEntryBroker
Data broker for accessing a LinkEntry.
Definition: BasicBrokers.h:416
ace_time::basic::ZonePolicyBroker
Data broker for accessing ZonePolicy.
Definition: BasicBrokers.h:136
ace_time::basic::ZoneInfoBroker::targetZoneInfo
ZoneInfoBroker targetZoneInfo() const
Return the ZoneInfoBroker of the target Zone, assuming that the current Zone is a Link.
Definition: BasicBrokers.h:313