AceTime  2.1.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 
43 class __FlashStringHelper;
44 class Print;
45 
46 namespace ace_time {
47 namespace basic {
48 
51  public:
52  explicit ZoneRuleBroker(const ZoneRule* zoneRule = nullptr):
53  mZoneRule(zoneRule) {}
54 
55  // use the default copy constructor
56  ZoneRuleBroker(const ZoneRuleBroker&) = default;
57 
58  // use the default assignment operator
59  ZoneRuleBroker& operator=(const ZoneRuleBroker&) = default;
60 
61  bool isNull() const { return mZoneRule == nullptr; }
62 
63  #if ACE_TIME_USE_PROGMEM
64 
65  int16_t fromYear() const {
66  return pgm_read_word(&mZoneRule->fromYear);
67  }
68 
69  int16_t toYear() const {
70  return pgm_read_word(&mZoneRule->toYear);
71  }
72 
73  uint8_t inMonth() const {
74  return pgm_read_byte(&mZoneRule->inMonth);
75  }
76 
77  int8_t onDayOfWeek() const {
78  return pgm_read_byte(&mZoneRule->onDayOfWeek);
79  }
80 
81  int8_t onDayOfMonth() const {
82  return pgm_read_byte(&mZoneRule->onDayOfMonth);
83  }
84 
85  uint16_t atTimeMinutes() const {
86  return internal::timeCodeToMinutes(
87  pgm_read_byte(&mZoneRule->atTimeCode),
88  pgm_read_byte(&mZoneRule->atTimeModifier));
89  }
90 
91  uint8_t atTimeSuffix() const {
92  return internal::toSuffix(pgm_read_byte(&mZoneRule->atTimeModifier));
93  }
94 
95  int16_t deltaMinutes() const {
96  return 15 * (int8_t) pgm_read_byte(&mZoneRule->deltaCode);
97  }
98 
99  uint8_t letter() const {
100  return pgm_read_byte(&mZoneRule->letter);
101  }
102 
103  #else
104 
105  int16_t fromYear() const { return mZoneRule->fromYear; }
106 
107  int16_t toYear() const { return mZoneRule->toYear; }
108 
109  uint8_t inMonth() const { return mZoneRule->inMonth; }
110 
111  uint8_t onDayOfWeek() const { return mZoneRule->onDayOfWeek; }
112 
113  int8_t onDayOfMonth() const { return mZoneRule->onDayOfMonth; }
114 
115  uint16_t atTimeMinutes() const {
116  return internal::timeCodeToMinutes(
117  mZoneRule->atTimeCode, mZoneRule->atTimeModifier);
118  }
119 
120  uint8_t atTimeSuffix() const {
121  return internal::toSuffix(mZoneRule->atTimeModifier);
122  }
123 
124  int16_t deltaMinutes() const { return 15 * mZoneRule->deltaCode; }
125 
126  uint8_t letter() const { return mZoneRule->letter; }
127 
128  #endif
129 
130  private:
131  const ZoneRule* mZoneRule;
132 };
133 
136  public:
137  explicit ZonePolicyBroker(const ZonePolicy* zonePolicy = nullptr):
138  mZonePolicy(zonePolicy) {}
139 
140  // use default copy constructor
141  ZonePolicyBroker(const ZonePolicyBroker&) = default;
142 
143  // use default assignment operator
144  ZonePolicyBroker& operator=(const ZonePolicyBroker&) = default;
145 
146  bool isNull() const { return mZonePolicy == nullptr; }
147 
148  #if ACE_TIME_USE_PROGMEM
149 
150  uint8_t numRules() const {
151  return pgm_read_byte(&mZonePolicy->numRules);
152  }
153 
154  const ZoneRuleBroker rule(uint8_t i) const {
155  const ZoneRule* rules =
156  (const ZoneRule*) pgm_read_ptr(&mZonePolicy->rules);
157  return ZoneRuleBroker(&rules[i]);
158  }
159 
160  uint8_t numLetters() const {
161  return pgm_read_byte(&mZonePolicy->numLetters);
162  }
163 
164  const char* letter(uint8_t i) const {
165  const char* const* letters = (const char* const*)
166  pgm_read_ptr(&mZonePolicy->letters);
167  return (const char*) pgm_read_ptr(&letters[i]);
168  }
169 
170  #else
171 
172  uint8_t numRules() const { return mZonePolicy->numRules; }
173 
174  const ZoneRuleBroker rule(uint8_t i) const {
175  return ZoneRuleBroker(&mZonePolicy->rules[i]);
176  }
177 
178  uint8_t numLetters() const { return mZonePolicy->numLetters; }
179 
180  const char* letter(uint8_t i) const {
181  return mZonePolicy->letters[i];
182  }
183 
184  #endif
185 
186  private:
187  const ZonePolicy* mZonePolicy;
188 };
189 
190 //-----------------------------------------------------------------------------
191 
194  public:
195  explicit ZoneEraBroker(const ZoneEra* zoneEra = nullptr):
196  mZoneEra(zoneEra) {}
197 
198  // use default copy constructor
199  ZoneEraBroker(const ZoneEraBroker&) = default;
200 
201  // use default assignment operator
202  ZoneEraBroker& operator=(const ZoneEraBroker&) = default;
203 
204  bool isNull() const { return mZoneEra == nullptr; }
205 
206  bool equals(const ZoneEraBroker& other) const {
207  return mZoneEra == other.mZoneEra;
208  }
209 
210  #if ACE_TIME_USE_PROGMEM
211 
212  const ZonePolicyBroker zonePolicy() const {
213  return ZonePolicyBroker(
214  (const ZonePolicy*) pgm_read_ptr(&mZoneEra->zonePolicy));
215  }
216 
217  int16_t offsetMinutes() const {
218  return 15 * (int8_t) pgm_read_byte(&mZoneEra->offsetCode);
219  }
220 
221  int16_t deltaMinutes() const {
222  return 15 * (int8_t) pgm_read_byte(&mZoneEra->deltaCode);
223  }
224 
225  const char* format() const {
226  return (const char*) pgm_read_ptr(&mZoneEra->format);
227  }
228 
229  int16_t untilYear() const {
230  return pgm_read_word(&mZoneEra->untilYear);
231  }
232 
233  uint8_t untilMonth() const {
234  return pgm_read_byte(&mZoneEra->untilMonth);
235  }
236 
237  uint8_t untilDay() const {
238  return pgm_read_byte(&mZoneEra->untilDay);
239  }
240 
241  uint16_t untilTimeMinutes() const {
242  return internal::timeCodeToMinutes(
243  pgm_read_byte(&mZoneEra->untilTimeCode),
244  pgm_read_byte(&mZoneEra->untilTimeModifier));
245  }
246 
247  uint8_t untilTimeSuffix() const {
248  return internal::toSuffix(pgm_read_byte(&mZoneEra->untilTimeModifier));
249  }
250 
251  #else
252 
253  int16_t offsetMinutes() const { return 15 * mZoneEra->offsetCode; }
254 
255  const ZonePolicyBroker zonePolicy() const {
256  return ZonePolicyBroker(mZoneEra->zonePolicy);
257  }
258 
259  int16_t deltaMinutes() const { return 15 * mZoneEra->deltaCode; }
260 
261  const char* format() const { return mZoneEra->format; }
262 
263  int16_t untilYear() const { return mZoneEra->untilYear; }
264 
265  uint8_t untilMonth() const { return mZoneEra->untilMonth; }
266 
267  uint8_t untilDay() const { return mZoneEra->untilDay; }
268 
269  uint16_t untilTimeMinutes() const {
270  return internal::timeCodeToMinutes(
271  mZoneEra->untilTimeCode, mZoneEra->untilTimeModifier);
272  }
273 
274  uint8_t untilTimeSuffix() const {
275  return internal::toSuffix(mZoneEra->untilTimeModifier);
276  }
277 
278  #endif
279 
280  private:
281  const ZoneEra* mZoneEra;
282 };
283 
286  public:
287  explicit ZoneInfoBroker(const ZoneInfo* zoneInfo = nullptr):
288  mZoneInfo(zoneInfo) {}
289 
290  // use default copy constructor
291  ZoneInfoBroker(const ZoneInfoBroker&) = default;
292 
293  // use default assignment operator
294  ZoneInfoBroker& operator=(const ZoneInfoBroker&) = default;
295 
300  bool equals(uintptr_t zoneKey) const {
301  return mZoneInfo == (const ZoneInfo*) zoneKey;
302  }
303 
304  bool equals(const ZoneInfoBroker& zoneInfoBroker) const {
305  return mZoneInfo == zoneInfoBroker.mZoneInfo;
306  }
307 
308  bool isNull() const { return mZoneInfo == nullptr; }
309 
310  #if ACE_TIME_USE_PROGMEM
311 
312  const internal::ZoneContext* zoneContext() const {
313  return (const internal::ZoneContext*)
314  pgm_read_ptr(&mZoneInfo->zoneContext);
315  }
316 
317  const __FlashStringHelper* name() const {
318  return FPSTR(pgm_read_ptr(&mZoneInfo->name));
319  }
320 
321  uint32_t zoneId() const {
322  return pgm_read_dword(&mZoneInfo->zoneId);
323  }
324 
325  uint8_t numEras() const {
326  return pgm_read_byte(&mZoneInfo->numEras);
327  }
328 
329  const ZoneEraBroker era(uint8_t i) const {
330  auto eras = (const ZoneEra*) pgm_read_ptr(&mZoneInfo->eras);
331  return ZoneEraBroker(&eras[i]);
332  }
333 
334  bool isLink() const {
335  return mZoneInfo->targetInfo != nullptr;
336  }
337 
338  const ZoneInfoBroker targetInfo() const {
339  return ZoneInfoBroker((const ZoneInfo*)
340  pgm_read_ptr(&mZoneInfo->targetInfo));
341  }
342 
343  #else
344 
345  const internal::ZoneContext* zoneContext() const {
346  return mZoneInfo->zoneContext;
347  }
348 
349  const char* name() const { return mZoneInfo->name; }
350 
351  uint32_t zoneId() const { return mZoneInfo->zoneId; }
352 
353  uint8_t numEras() const { return mZoneInfo->numEras; }
354 
355  const ZoneEraBroker era(uint8_t i) const {
356  return ZoneEraBroker(&mZoneInfo->eras[i]);
357  }
358 
359  const ZoneInfoBroker targetZoneInfo() const {
360  return ZoneInfoBroker(mZoneInfo->targetInfo);
361  }
362 
363  #endif
364 
366  void printNameTo(Print& printer) const;
367 
372  void printShortNameTo(Print& printer) const;
373 
374  private:
375  const ZoneInfo* mZoneInfo;
376 };
377 
383  public:
384  ZoneRegistryBroker(const ZoneInfo* const* zoneRegistry):
385  mZoneRegistry(zoneRegistry) {}
386 
387  // use default copy constructor
388  ZoneRegistryBroker(const ZoneRegistryBroker&) = default;
389 
390  // use default assignment operator
391  ZoneRegistryBroker& operator=(const ZoneRegistryBroker&) = default;
392 
393  #if ACE_TIME_USE_PROGMEM
394 
395  const ZoneInfo* zoneInfo(uint16_t i) const {
396  return (const ZoneInfo*) pgm_read_ptr(&mZoneRegistry[i]);
397  }
398 
399  #else
400 
401  const ZoneInfo* zoneInfo(uint16_t i) const {
402  return mZoneRegistry[i];
403  }
404 
405  #endif
406 
407  private:
408  const ZoneInfo* const* mZoneRegistry;
409 };
410 
411 //-----------------------------------------------------------------------------
412 
415  public:
420  ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const {
421  return ZoneInfoBroker((const ZoneInfo*) zoneKey);
422  }
423 };
424 
425 } // basic
426 } // ace_time
427 
428 #endif
Helper functions are used in both Basic brokers and Extended brokers.
A factory that creates a basic::ZoneInfoBroker.
Definition: BasicBrokers.h:414
ZoneInfoBroker createZoneInfoBroker(uintptr_t zoneKey) const
Definition: BasicBrokers.h:420
Data broker for accessing ZoneEra.
Definition: BasicBrokers.h:193
Data broker for accessing ZoneInfo.
Definition: BasicBrokers.h:285
void printShortNameTo(Print &printer) const
Print a short human-readable identifier (e.g.
void printNameTo(Print &printer) const
Print a human-readable identifier (e.g.
bool equals(uintptr_t zoneKey) const
Definition: BasicBrokers.h:300
Data broker for accessing ZonePolicy.
Definition: BasicBrokers.h:135
Data broker for accessing the ZoneRegistry.
Definition: BasicBrokers.h:382
Data broker for accessing ZoneRule.
Definition: BasicBrokers.h:50