AceTime  1.9.0
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  #if ACE_TIME_USE_PROGMEM
308 
309  const internal::ZoneContext* zoneContext() const {
310  return (const internal::ZoneContext*)
311  pgm_read_ptr(&mZoneInfo->zoneContext);
312  }
313 
314  const __FlashStringHelper* name() const {
315  return FPSTR(pgm_read_ptr(&mZoneInfo->name));
316  }
317 
318  uint32_t zoneId() const {
319  return pgm_read_dword(&mZoneInfo->zoneId);
320  }
321 
322  uint8_t numEras() const {
323  return pgm_read_byte(&mZoneInfo->numEras);
324  }
325 
326  const ZoneEraBroker era(uint8_t i) const {
327  const ZoneEra* eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
328  return ZoneEraBroker(&eras[i]);
329  }
330 
331  #else
332 
333  const internal::ZoneContext* zoneContext() const {
334  return mZoneInfo->zoneContext;
335  }
336 
337  const char* name() const { return mZoneInfo->name; }
338 
339  uint32_t zoneId() const { return mZoneInfo->zoneId; }
340 
341  uint8_t numEras() const { return mZoneInfo->numEras; }
342 
343  const ZoneEraBroker era(uint8_t i) const {
344  return ZoneEraBroker(&mZoneInfo->eras[i]);
345  }
346 
347  #endif
348 
350  void printNameTo(Print& printer) const;
351 
353  void printShortNameTo(Print& printer) const;
354 
355  private:
356  const ZoneInfo* mZoneInfo;
357 };
358 
364  public:
365  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
366  mZoneRegistry(zoneRegistry) {}
367 
368  // use default copy constructor
369  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
370 
371  // use default assignment operator
372  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
373 
374  #if ACE_TIME_USE_PROGMEM
375 
376  const ZoneInfo* zoneInfo(uint16_t i) const {
377  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
378  }
379 
380  #else
381 
382  const ZoneInfo* zoneInfo(uint16_t i) const {
383  return mZoneRegistry[i];
384  }
385 
386  #endif
387 
388  private:
389  const ZoneInfo* const* mZoneRegistry;
390 };
391 
392 //-----------------------------------------------------------------------------
393 
396  public:
397  explicit LinkEntryBroker(const LinkEntry* linkEntry = nullptr):
398  mLinkEntry(linkEntry) {}
399 
400  // use default copy constructor
401  LinkEntryBroker(const LinkEntryBroker&) = default;
402 
403  // use default assignment operator
404  LinkEntryBroker& operator=(const LinkEntryBroker&) = default;
405 
406  #if ACE_TIME_USE_PROGMEM
407  uint32_t zoneId() const { return pgm_read_dword(&mLinkEntry->zoneId); }
408  uint32_t linkId() const { return pgm_read_dword(&mLinkEntry->linkId); }
409 
410  #else
411  uint32_t zoneId() const { return mLinkEntry->zoneId; }
412  uint32_t linkId() const { return mLinkEntry->linkId; }
413 
414  #endif
415 
416  private:
417  const LinkEntry* mLinkEntry;
418 };
419 
424  public:
425  LinkRegistryBroker(const LinkEntry zoneRegistry[]):
426  mLinkRegistry(zoneRegistry) {}
427 
428  // use default copy constructor
429  LinkRegistryBroker(const LinkRegistryBroker&) = default;
430 
431  // use default assignment operator
432  LinkRegistryBroker& operator=(const LinkRegistryBroker&) = default;
433 
434  // Same code whether or not ACE_TIME_USE_PROGMEM is active.
435  const LinkEntry* linkEntry(uint16_t i) const {
436  return &mLinkRegistry[i];
437  }
438 
439  private:
440  const LinkEntry* mLinkRegistry;
441 };
442 
443 //-----------------------------------------------------------------------------
444 
447  public:
448  ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const {
449  return ZoneInfoBroker((const ZoneInfo*) zoneKey);
450  }
451 };
452 
453 } // basic
454 } // ace_time
455 
456 #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:446
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:363
ace_time::basic::LinkRegistryBroker
Data broker for a LinkRegistry composed of LinkEntry records.
Definition: BasicBrokers.h:423
ace_time::basic::LinkEntryBroker
Data broker for accessing a LinkEntry.
Definition: BasicBrokers.h:395
ace_time::basic::ZonePolicyBroker
Data broker for accessing ZonePolicy.
Definition: BasicBrokers.h:136