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