AceTime  2.1.0
Date and time classes for Arduino that support timezones from the TZ Database.
ExtendedBrokers.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_EXTENDED_BROKERS_H
7 #define ACE_TIME_EXTENDED_BROKERS_H
8 
38 #include <stdint.h> // uintptr_t
39 #include "../common/compat.h"
40 #include "BrokerCommon.h"
41 #include "ZoneInfo.h"
42 
43 class __FlashStringHelper;
44 
45 namespace ace_time {
46 namespace extended {
47 
56 inline int16_t toDeltaMinutes(int8_t deltaCode) {
57  return ((int8_t)((uint8_t)deltaCode & 0x0f) - 4) * 15;
58 }
59 
65 inline int16_t toOffsetMinutes(int8_t offsetCode, int8_t deltaCode) {
66  return (offsetCode * 15) + (((uint8_t)deltaCode & 0xf0) >> 4);
67 }
68 
69 //-----------------------------------------------------------------------------
70 
73  public:
74  explicit ZoneRuleBroker(const ZoneRule* zoneRule = nullptr):
75  mZoneRule(zoneRule) {}
76 
77  // use the default copy constructor
78  ZoneRuleBroker(const ZoneRuleBroker&) = default;
79 
80  // use the default assignment operator
81  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
82 
83  bool isNull() const { return mZoneRule == nullptr; }
84 
85  #if ACE_TIME_USE_PROGMEM
86 
87  int16_t fromYear() const {
88  return pgm_read_word(&mZoneRule->fromYear);
89  }
90 
91  int16_t toYear() const {
92  return pgm_read_word(&mZoneRule->toYear);
93  }
94 
95  uint8_t inMonth() const {
96  return pgm_read_byte(&mZoneRule->inMonth);
97  }
98 
99  uint8_t onDayOfWeek() const {
100  return pgm_read_byte(&mZoneRule->onDayOfWeek);
101  }
102 
103  int8_t onDayOfMonth() const {
104  return pgm_read_byte(&mZoneRule->onDayOfMonth);
105  }
106 
107  uint16_t atTimeMinutes() const {
108  return internal::timeCodeToMinutes(
109  pgm_read_byte(&mZoneRule->atTimeCode),
110  pgm_read_byte(&mZoneRule->atTimeModifier));
111  }
112 
113  uint8_t atTimeSuffix() const {
114  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
115  }
116 
117  int16_t deltaMinutes() const {
118  return toDeltaMinutes(pgm_read_byte(&mZoneRule->deltaCode));
119  }
120 
121  uint8_t letter() const {
122  return pgm_read_byte(&mZoneRule->letter);
123  }
124 
125  #else
126 
127  int16_t fromYear() const { return mZoneRule->fromYear; }
128 
129  int16_t toYear() const { return mZoneRule->toYear; }
130 
131  uint8_t inMonth() const { return mZoneRule->inMonth; }
132 
133  int8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
134 
135  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
136 
137  uint16_t atTimeMinutes() const {
138  return internal::timeCodeToMinutes(
139  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
140  }
141 
142  uint8_t atTimeSuffix() const {
143  return internal::toSuffix(mZoneRule->atTimeModifier);
144  }
145 
146  int16_t deltaMinutes() const {
147  return toDeltaMinutes(mZoneRule->deltaCode);
148  }
149 
150  uint8_t letter() const { return mZoneRule->letter; }
151 
152  #endif
153 
154  private:
155  const ZoneRule* mZoneRule;
156 };
157 
160  public:
161  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy):
162  mZonePolicy(zonePolicy) {}
163 
164  // use default copy constructor
165  ZonePolicyBroker(const ZonePolicyBroker&) = default;
166 
167  // use default assignment operator
168  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
169 
170  bool isNull() const { return mZonePolicy == nullptr; }
171 
172  #if ACE_TIME_USE_PROGMEM
173 
174  uint8_t numRules() const {
175  return pgm_read_byte(&mZonePolicy->numRules);
176  }
177 
178  const ZoneRuleBroker rule(uint8_t i) const {
179  const ZoneRule* rules =
180  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
181  return ZoneRuleBroker(&rules[i]);
182  }
183 
184  uint8_t numLetters() const {
185  return pgm_read_byte(&mZonePolicy->numLetters);
186  }
187 
188  const char* letter(uint8_t i) const {
189  const char* const* letters = (const char* const*)
190  pgm_read_ptr(&mZonePolicy->letters);
191  return (const char*) pgm_read_ptr(&letters[i]);
192  }
193 
194  #else
195 
196  uint8_t numRules() const { return mZonePolicy->numRules; }
197 
198  const ZoneRuleBroker rule(uint8_t i) const {
199  return ZoneRuleBroker(&mZonePolicy->rules[i]);
200  }
201 
202  uint8_t numLetters() const { return mZonePolicy->numLetters; }
203 
204  const char* letter(uint8_t i) const {
205  return mZonePolicy->letters[i];
206  }
207 
208  #endif
209 
210  private:
211  const ZonePolicy* mZonePolicy;
212 };
213 
214 //-----------------------------------------------------------------------------
215 
218  public:
219  explicit ZoneEraBroker(const ZoneEra* zoneEra = nullptr):
220  mZoneEra(zoneEra) {}
221 
222  // use default copy constructor
223  ZoneEraBroker(const ZoneEraBroker&) = default;
224 
225  // use default assignment operator
226  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
227 
228  bool isNull() const { return mZoneEra == nullptr; }
229 
230  // Does not seem to be used, but defined here for symmetry with
231  // basic::ZoneEraBroker::equals().
232  bool equals(const ZoneEraBroker& other) const {
233  return mZoneEra == other.mZoneEra;
234  }
235 
236  #if ACE_TIME_USE_PROGMEM
237 
238  const ZonePolicyBroker zonePolicy() const {
239  return ZonePolicyBroker(
240  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
241  }
242 
243  int16_t offsetMinutes() const {
244  return toOffsetMinutes(
245  pgm_read_byte(&mZoneEra->offsetCode),
246  pgm_read_byte(&mZoneEra->deltaCode));
247  }
248 
249  int16_t deltaMinutes() const {
250  return toDeltaMinutes(pgm_read_byte(&mZoneEra->deltaCode));
251  }
252 
253  const char* format() const {
254  return (const char*) pgm_read_ptr(&mZoneEra->format);
255  }
256 
257  int16_t untilYear() const {
258  return pgm_read_word(&mZoneEra->untilYear);
259  }
260 
261  uint8_t untilMonth() const {
262  return pgm_read_byte(&mZoneEra->untilMonth);
263  }
264 
265  uint8_t untilDay() const {
266  return pgm_read_byte(&mZoneEra->untilDay);
267  }
268 
269  uint16_t untilTimeMinutes() const {
270  return internal::timeCodeToMinutes(
271  pgm_read_byte(&mZoneEra->untilTimeCode),
272  pgm_read_byte(&mZoneEra->untilTimeModifier));
273  }
274 
275  uint8_t untilTimeSuffix() const {
276  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
277  }
278 
279  #else
280 
281  const ZonePolicyBroker zonePolicy() const {
282  return ZonePolicyBroker(mZoneEra->zonePolicy);
283  }
284 
285  int16_t offsetMinutes() const {
286  return toOffsetMinutes(mZoneEra->offsetCode, mZoneEra->deltaCode);
287  }
288 
289  int16_t deltaMinutes() const {
290  return toDeltaMinutes(mZoneEra->deltaCode);
291  }
292 
293  const char* format() const { return mZoneEra->format; }
294 
295  int16_t untilYear() const { return mZoneEra->untilYear; }
296 
297  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
298 
299  uint8_t untilDay() const { return mZoneEra->untilDay; }
300 
301  uint16_t untilTimeMinutes() const {
302  return internal::timeCodeToMinutes(
303  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
304  }
305 
306  uint8_t untilTimeSuffix() const {
307  return internal::toSuffix(mZoneEra->untilTimeModifier);
308  }
309 
310  #endif
311 
312  private:
313  const ZoneEra* mZoneEra;
314 };
315 
318  public:
319  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo = nullptr):
320  mZoneInfo(zoneInfo) {}
321 
322  // use default copy constructor
323  ZoneInfoBroker(const ZoneInfoBroker&) = default;
324 
325  // use default assignment operator
326  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
327 
332  bool equals(uintptr_t zoneKey) const {
333  return mZoneInfo == (const ZoneInfo*) zoneKey;
334  }
335 
336  bool equals(const ZoneInfoBroker& zoneInfoBroker) const {
337  return mZoneInfo == zoneInfoBroker.mZoneInfo;
338  }
339 
340  bool isNull() const { return mZoneInfo == nullptr; }
341 
342  #if ACE_TIME_USE_PROGMEM
343 
344  const internal::ZoneContext* zoneContext() const {
345  return (const internal::ZoneContext*)
346  pgm_read_ptr(&mZoneInfo->zoneContext);
347  }
348 
349  const __FlashStringHelper* name() const {
350  return FPSTR(pgm_read_ptr(&mZoneInfo->name));
351  }
352 
353  uint32_t zoneId() const {
354  return pgm_read_dword(&mZoneInfo->zoneId);
355  }
356 
357  uint8_t numEras() const { return pgm_read_byte(&mZoneInfo->numEras); }
358 
359  const ZoneEraBroker era(uint8_t i) const {
360  auto eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
361  return ZoneEraBroker(&eras[i]);
362  }
363 
364  bool isLink() const {
365  return mZoneInfo->targetInfo != nullptr;
366  }
367 
368  ZoneInfoBroker targetInfo() const {
369  return ZoneInfoBroker((const ZoneInfo*)
370  pgm_read_ptr(&mZoneInfo->targetInfo));
371  }
372 
373  #else
374 
375  const internal::ZoneContext* zoneContext() const {
376  return mZoneInfo->zoneContext;
377  }
378 
379  const char* name() const { return mZoneInfo->name; }
380 
381  uint32_t zoneId() const { return mZoneInfo->zoneId; }
382 
383  uint8_t numEras() const { return mZoneInfo->numEras; }
384 
385  const ZoneEraBroker era(uint8_t i) const {
386  return ZoneEraBroker(&mZoneInfo->eras[i]);
387  }
388 
389  const ZoneInfoBroker targetInfo() const {
390  return ZoneInfoBroker(mZoneInfo->targetInfo);
391  }
392 
393  #endif
394 
396  void printNameTo(Print& printer) const;
397 
402  void printShortNameTo(Print& printer) const;
403 
404  private:
405  const ZoneInfo* mZoneInfo;
406 };
407 
413  public:
414  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
415  mZoneRegistry(zoneRegistry) {}
416 
417  // use default copy constructor
418  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
419 
420  // use default assignment operator
421  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
422 
423  #if ACE_TIME_USE_PROGMEM
424 
425  const ZoneInfo* zoneInfo(uint16_t i) const {
426  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
427  }
428 
429  #else
430 
431  const ZoneInfo* zoneInfo(uint16_t i) const {
432  return mZoneRegistry[i];
433  }
434 
435  #endif
436 
437  private:
438  const ZoneInfo* const* mZoneRegistry;
439 };
440 
441 //-----------------------------------------------------------------------------
442 
445  public:
450  ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const {
451  return ZoneInfoBroker((const ZoneInfo*) zoneKey);
452  }
453 };
454 
455 } // extended
456 } // ace_time
457 
458 #endif
Helper functions are used in both Basic brokers and Extended brokers.
int16_t toOffsetMinutes(int8_t offsetCode, int8_t deltaCode)
Convert the offsetCode and deltaCode into a signed 8-bit integer.
int16_t toDeltaMinutes(int8_t deltaCode)
Convert the deltaCode in the ZoneInfo struct to the actual deltaMinutes.
A factory that creates a basic::ZoneInfoBroker.
ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const
Data broker for accessing ZoneEra.
Data broker for accessing ZoneInfo.
void printNameTo(Print &printer) const
Print a human-readable identifier (e.g.
bool equals(uintptr_t zoneKey) const
void printShortNameTo(Print &printer) const
Print a short human-readable identifier (e.g.
Data broker for accessing ZonePolicy.
Data broker for accessing the ZoneRegistry.
Data broker for accessing ZoneRule.