AceTime 3.0.0 Date and time classes for Arduino that support timezones from the TZ Database.

TimeZone.h
1 /*
2 * MIT License
3 * Copyright (c) 2018 Brian T. Park
4 */
5
6 #ifndef ACE_TIME_TIME_ZONE_H
7 #define ACE_TIME_TIME_ZONE_H
8
9 #include <stdint.h> // uintptr_t
10 #include "TimeOffset.h"
11 #include "ZoneProcessor.h"
12 #include "BasicZoneProcessor.h"
13 #include "ExtendedZoneProcessor.h"
14 #include "CompleteZoneProcessor.h"
15 #include "TimeZoneData.h"
16 #include "ZonedExtra.h"
17
18 class Print;
19
20 namespace ace_time {
21
86 class TimeZone {
87 public:
89 static const uint8_t kTypeError = 0;
90
92 static const uint8_t kTypeManual = 1;
93
95 static const uint8_t kTypeReserved = 2;
96
98 static TimeZone forUtc() {
99 return TimeZone();
100 }
101
115 static TimeZone forTimeOffset(
116 TimeOffset stdOffset,
117 TimeOffset dstOffset = TimeOffset()
118 ) {
119 return TimeZone(stdOffset, dstOffset);
120 }
121
128 static TimeZone forHours(int8_t stdHours, int8_t dstHours = 0) {
129 return TimeZone::forTimeOffset(
130 TimeOffset::forHours(stdHours),
131 TimeOffset::forHours(dstHours)
132 );
133 }
134
141 static TimeZone forMinutes(int16_t stdMinutes, int16_t dstMinutes = 0) {
142 return TimeZone::forTimeOffset(
143 TimeOffset::forMinutes(stdMinutes),
144 TimeOffset::forMinutes(dstMinutes)
145 );
146 }
147
154 static TimeZone forHourMinute(
155 int8_t stdHour,
156 int8_t stdMinute,
157 int8_t dstHour = 0,
158 int8_t dstMinute = 0
159 ) {
160 return TimeZone::forTimeOffset(
161 TimeOffset::forHourMinute(stdHour, stdMinute),
162 TimeOffset::forHourMinute(dstHour, dstMinute)
163 );
164 }
165
174 static TimeZone forZoneInfo(
175 const basic::Info::ZoneInfo* zoneInfo,
176 BasicZoneProcessor* zoneProcessor
177 ) {
178 return TimeZone(
179 zoneProcessor->getType(),
180 (uintptr_t) zoneInfo,
181 zoneProcessor
182 );
183 }
184
193 static TimeZone forZoneInfo(
194 const extended::Info::ZoneInfo* zoneInfo,
195 ExtendedZoneProcessor* zoneProcessor
196 ) {
197 return TimeZone(
198 zoneProcessor->getType(),
199 (uintptr_t) zoneInfo,
200 zoneProcessor
201 );
202 }
203
212 static TimeZone forZoneInfo(
213 const complete::Info::ZoneInfo* zoneInfo,
214 CompleteZoneProcessor* zoneProcessor
215 ) {
216 return TimeZone(
217 zoneProcessor->getType(),
218 (uintptr_t) zoneInfo,
219 zoneProcessor
220 );
221 }
222
233 static TimeZone forZoneKey(uintptr_t zoneKey, ZoneProcessor* processor) {
234 return TimeZone(processor->getType(), zoneKey, processor);
235 }
236
241 static TimeZone forError() {
242 return TimeZone(kTypeError);
243 }
244
246 TimeZone():
247 mType(kTypeManual),
248 mStdOffsetMinutes(0),
249 mDstOffsetMinutes(0) {}
250
258 uint8_t getType() const { return mType; }
259
261 TimeOffset getStdOffset() const {
262 return TimeOffset::forMinutes(mStdOffsetMinutes);
263 }
264
266 TimeOffset getDstOffset() const {
267 return TimeOffset::forMinutes(mDstOffsetMinutes);
268 }
269
271 bool isLink() const {
272 switch (mType) {
273 case kTypeError:
274 case kTypeReserved:
275 case kTypeManual:
276 return false;
277
278 default:
279 return getBoundZoneProcessor()->isLink();
280 }
281 }
282
288 uint32_t getZoneId() const {
289 switch (mType) {
290 case kTypeError:
291 case kTypeReserved:
292 case kTypeManual:
293 return 0;
294
295 default:
296 return getBoundZoneProcessor()->getZoneId();
297 }
298 }
299
301 bool isError() const { return mType == kTypeError; }
302
304 ZonedExtra getZonedExtra(const LocalDateTime& ldt) const {
305 switch (mType) {
306 case kTypeError:
307 case kTypeReserved:
308 return ZonedExtra::forError();
309
310 case kTypeManual:
311 const char* abbrev;
312 if (isUtc()) {
313 abbrev = "UTC";
314 } else {
315 abbrev = (mDstOffsetMinutes != 0) ? "DST" : "STD";
316 }
317 return ZonedExtra(
318 ZonedExtra::kTypeExact,
319 mStdOffsetMinutes * 60,
320 mDstOffsetMinutes * 60,
321 mStdOffsetMinutes * 60,
322 mDstOffsetMinutes * 60,
323 abbrev);
324
325 default: {
326 FindResult result = getBoundZoneProcessor()->findByLocalDateTime(ldt);
327 if (result.type == FindResult::kTypeNotFound) {
328 return ZonedExtra::forError();
329 }
330 return ZonedExtra(
331 result.type, // ZonedExtra::type is identical to FindResult::type
332 result.stdOffsetSeconds,
333 result.dstOffsetSeconds,
334 result.reqStdOffsetSeconds,
335 result.reqDstOffsetSeconds,
336 result.abbrev);
337 }
338 }
339 }
340
342 ZonedExtra getZonedExtra(acetime_t epochSeconds) const {
343 switch (mType) {
344 case kTypeError:
345 case kTypeReserved:
346 return ZonedExtra::forError();
347
348 case kTypeManual:
349 const char* abbrev;
350 if (isUtc()) {
351 abbrev = "UTC";
352 } else {
353 abbrev = (mDstOffsetMinutes != 0) ? "DST" : "STD";
354 }
355 return ZonedExtra(
356 ZonedExtra::kTypeExact,
357 mStdOffsetMinutes * 60,
358 mDstOffsetMinutes * 60,
359 mStdOffsetMinutes * 60,
360 mDstOffsetMinutes * 60,
361 abbrev);
362
363 default: {
364 FindResult result =
365 getBoundZoneProcessor()->findByEpochSeconds(epochSeconds);
366 if (result.type == FindResult::kTypeNotFound) {
367 return ZonedExtra::forError();
368 }
369 return ZonedExtra(
370 result.type, // ZonedExtra::type is identical to FindResult::type
371 result.stdOffsetSeconds,
372 result.dstOffsetSeconds,
373 result.reqStdOffsetSeconds,
374 result.reqDstOffsetSeconds,
375 result.abbrev);
376 }
377 }
378 }
379
386 OffsetDateTime getOffsetDateTime(const LocalDateTime& ldt) const {
387 OffsetDateTime odt = OffsetDateTime::forError();
388 switch (mType) {
389 case kTypeError:
390 case kTypeReserved:
391 break;
392
393 case kTypeManual:
394 odt = OffsetDateTime::forLocalDateTimeAndOffset(
395 ldt,
396 TimeOffset::forMinutes(mStdOffsetMinutes + mDstOffsetMinutes));
397 break;
398
399 default: {
400 FindResult result = getBoundZoneProcessor()->findByLocalDateTime(ldt);
401 if (result.type == FindResult::kTypeNotFound) {
402 break;
403 }
404
405 // Convert FindResult into OffsetDateTime using the requested offset.
406 TimeOffset reqOffset = TimeOffset::forSeconds(
407 result.reqStdOffsetSeconds + result.reqDstOffsetSeconds);
408 odt = OffsetDateTime::forLocalDateTimeAndOffset(ldt, reqOffset);
409 odt.fold(result.fold);
410
411 // Special processing for kTypeGap: Convert to epochSeconds using the
412 // reqStdOffsetMinutes and reqDstOffsetMinutes, then convert back to
413 // OffsetDateTime using the target stdOffsetMinutes and
414 // dstOffsetMinutes.
415 if (result.type == FindResult::kTypeGap) {
416 acetime_t epochSeconds = odt.toEpochSeconds();
417 TimeOffset targetOffset = TimeOffset::forSeconds(
418 result.stdOffsetSeconds + result.dstOffsetSeconds);
419 odt = OffsetDateTime::forEpochSeconds(epochSeconds, targetOffset);
420 }
421 break;
422 }
423 }
424 return odt;
425 }
426
432 OffsetDateTime getOffsetDateTime(acetime_t epochSeconds) const {
433 OffsetDateTime odt = OffsetDateTime::forError();
434 switch (mType) {
435 case kTypeError:
436 case kTypeReserved:
437 break;
438
439 case kTypeManual:
440 odt = OffsetDateTime::forEpochSeconds(
441 epochSeconds,
442 TimeOffset::forMinutes(mStdOffsetMinutes + mDstOffsetMinutes));
443 break;
444
445 default: {
446 FindResult result =
447 getBoundZoneProcessor()->findByEpochSeconds(epochSeconds);
448 if (result.type == FindResult::kTypeNotFound) {
449 break;
450 }
451
452 TimeOffset offset = TimeOffset::forSeconds(
453 result.reqStdOffsetSeconds + result.reqDstOffsetSeconds);
454 odt = OffsetDateTime::forEpochSeconds(
455 epochSeconds, offset, result.fold);
456 break;
457 }
458 }
459 return odt;
460 }
461
463 bool isUtc() const {
464 if (mType != kTypeManual) return false;
465 return mStdOffsetMinutes == 0 && mDstOffsetMinutes == 0;
466 }
467
475 bool isDst() const {
476 if (mType != kTypeManual) return false;
477 return mDstOffsetMinutes != 0;
478 }
479
486 TimeZoneData toTimeZoneData() const {
487 TimeZoneData d;
488 switch (mType) {
489 case kTypeError:
490 case kTypeReserved:
491 d.type = TimeZoneData::kTypeError;
492 break;
493
494 case TimeZone::kTypeManual:
495 d.stdOffsetMinutes = mStdOffsetMinutes;
496 d.dstOffsetMinutes = mDstOffsetMinutes;
497 d.type = TimeZoneData::kTypeManual;
498 break;
499
500 default:
501 d.zoneId = getZoneId();
502 d.type = TimeZoneData::kTypeZoneId;
503 break;
504 }
505 return d;
506 }
507
517 void printTo(Print& printer) const;
518
537 void printShortTo(Print& printer) const;
538
543 void printTargetNameTo(Print& printer) const;
544
545 // Use default copy constructor and assignment operator.
546 TimeZone(const TimeZone&) = default;
547 TimeZone& operator=(const TimeZone&) = default;
548
549 private:
550 friend bool operator==(const TimeZone& a, const TimeZone& b);
551
558 explicit TimeZone(TimeOffset stdOffset, TimeOffset dstOffset):
559 mType(kTypeManual),
560 mStdOffsetMinutes(stdOffset.toMinutes()),
561 mDstOffsetMinutes(dstOffset.toMinutes()) {}
562
564 explicit TimeZone(uint8_t type):
565 mType(type) {}
566
576 explicit TimeZone(
577 uint8_t type,
578 uintptr_t zoneKey,
579 ZoneProcessor* zoneProcessor
580 ):
581 mType(type),
582 mZoneKey(zoneKey),
583 mZoneProcessor(zoneProcessor)
584 {}
585
593 ZoneProcessor* getBoundZoneProcessor() const {
594 mZoneProcessor->setZoneKey(mZoneKey);
595 return mZoneProcessor;
596 }
597
598 private:
599 uint8_t mType;
600
601 // 3 combinations:
602 // (kTypeError)
603 // (kTypeManual, mStdOffsetMinutes, mDstOffsetMinutes)
604 // (type, mZoneKey, mZoneProcessor)
605 union {
607 struct {
608 int16_t mStdOffsetMinutes;
609 int16_t mDstOffsetMinutes;
610 };
611
613 struct {
625 uintptr_t mZoneKey;
626
631 ZoneProcessor* mZoneProcessor;
632 };
633 };
634 };
635
636 inline bool operator==(const TimeZone& a, const TimeZone& b) {
637 if (a.mType != b.mType) return false;
638 switch (a.mType) {
639 case TimeZone::kTypeError:
640 case TimeZone::kTypeReserved:
641 return true;
642
643 case TimeZone::kTypeManual:
644 return a.mStdOffsetMinutes == b.mStdOffsetMinutes
645 && a.mDstOffsetMinutes == b.mDstOffsetMinutes;
646
647 default:
648 return (a.mZoneKey == b.mZoneKey);
649 }
650 }
651
652 inline bool operator!=(const TimeZone& a, const TimeZone& b) {
653 return ! (a == b);
654 }
655
656 }
657
658 #endif
ace_time::BasicZoneProcessor
A specific implementation of BasicZoneProcessorTemplate that uses ZoneXxxBrokers which read from zone...
Definition: BasicZoneProcessor.h:932
ace_time::CompleteZoneProcessor
A specific implementation of ExtendedZoneProcessorTemplate that uses the complete::ZoneXxxBrokers cla...
Definition: CompleteZoneProcessor.h:20
ace_time::ExtendedZoneProcessor
A specific implementation of ExtendedZoneProcessorTemplate that uses the extended::Info::ZoneXxxBroke...
Definition: ExtendedZoneProcessor.h:1170
ace_time::FindResult
Result of a search for transition at a specific epochSeconds or a specific LocalDateTime.
Definition: ZoneProcessor.h:23
ace_time::FindResult::fold
uint8_t fold
For findByLocalDateTime(), when type==kTypeOverlap, this is a copy of the requested LocalDateTime::fo...
Definition: ZoneProcessor.h:76
ace_time::FindResult::stdOffsetSeconds
int32_t stdOffsetSeconds
STD offset of the resulting OffsetDateTime.
Definition: ZoneProcessor.h:79
ace_time::FindResult::dstOffsetSeconds
int32_t dstOffsetSeconds
DST offset of the resulting OffsetDateTime.
Definition: ZoneProcessor.h:82
ace_time::FindResult::reqDstOffsetSeconds
int32_t reqDstOffsetSeconds
DST offset of the Transition which matched the epochSeconds requested by findByEpochSeconds(),...
Definition: ZoneProcessor.h:108
ace_time::FindResult::abbrev
const char * abbrev
Pointer to the abbreviation stored in the transient Transition::abbrev variable.
Definition: ZoneProcessor.h:115
ace_time::FindResult::reqStdOffsetSeconds
int32_t reqStdOffsetSeconds
STD offset of the Transition which matched the epochSeconds requested by findByEpochSeconds(),...
Definition: ZoneProcessor.h:95
ace_time::FindResult::type
uint8_t type
Result of the findByEpochSeconds() or findByLocalDateTime() search methods.
Definition: ZoneProcessor.h:65
ace_time::LocalDateTime
Class that holds the date-time as the components (year, month, day, hour, minute, second) without reg...
Definition: LocalDateTime.h:30
ace_time::OffsetDateTime
The date (year, month, day), time (hour, minute, second) and fixed offset from UTC (timeOffset).
Definition: OffsetDateTime.h:37
ace_time::OffsetDateTime::forLocalDateTimeAndOffset
static OffsetDateTime forLocalDateTimeAndOffset(const LocalDateTime &localDateTime, TimeOffset timeOffset)
Factory method from LocalDateTime and TimeOffset.
Definition: OffsetDateTime.h:41
ace_time::OffsetDateTime::toEpochSeconds
acetime_t toEpochSeconds() const
Return seconds since AceTime epoch taking into account the UTC offset.
Definition: OffsetDateTime.h:259
ace_time::OffsetDateTime::forError
static OffsetDateTime forError()
Factory method that returns an instance whose isError() is true.
Definition: OffsetDateTime.h:142
ace_time::OffsetDateTime::fold
uint8_t fold() const
Return the fold.
Definition: OffsetDateTime.h:192
ace_time::OffsetDateTime::forEpochSeconds
static OffsetDateTime forEpochSeconds(acetime_t epochSeconds, TimeOffset timeOffset, uint8_t fold=0)
Factory method.
Definition: OffsetDateTime.h:79
ace_time::TimeOffset
A thin wrapper that represents a time offset from a reference point, usually 00:00 at UTC,...
Definition: TimeOffset.h:56
ace_time::TimeOffset::forSeconds
static TimeOffset forSeconds(int32_t seconds)
Create TimeOffset from seconds from 00:00.
Definition: TimeOffset.h:96
ace_time::TimeOffset::forHours
static TimeOffset forHours(int8_t hours)
Create TimeOffset with the corresponding hour offset.
Definition: TimeOffset.h:62
ace_time::TimeOffset::forHourMinute
static TimeOffset forHourMinute(int8_t hour, int8_t minute)
Create TimeOffset from (hour, minute) offset.
Definition: TimeOffset.h:74
ace_time::TimeOffset::forMinutes
static TimeOffset forMinutes(int16_t minutes)
Create TimeOffset from minutes from 00:00.
Definition: TimeOffset.h:91
ace_time::TimeZone
Class that describes a time zone.
Definition: TimeZone.h:86
ace_time::TimeZone::getZonedExtra
ZonedExtra getZonedExtra(acetime_t epochSeconds) const
Return the ZonedExtra information at epochSeconds.
Definition: TimeZone.h:342
ace_time::TimeZone::forZoneInfo
static TimeZone forZoneInfo(const complete::Info::ZoneInfo *zoneInfo, CompleteZoneProcessor *zoneProcessor)
Convenience factory method to create from a zoneInfo and an associated ExtendedZoneProcessor.
Definition: TimeZone.h:212
ace_time::TimeZone::printTo
void printTo(Print &printer) const
Print the text representation of the time zone using the full canonical time zone name or UTC offset ...
Definition: TimeZone.cpp:12
ace_time::TimeZone::getZoneId
uint32_t getZoneId() const
Return the zoneId for kTypeBasic, kTypeExtended.
Definition: TimeZone.h:288
ace_time::TimeZone::mZoneProcessor
ZoneProcessor * mZoneProcessor
An instance of a ZoneProcessor, for example, BasicZoneProcessor or ExtendedZoneProcessor.
Definition: TimeZone.h:631
ace_time::TimeZone::forZoneInfo
static TimeZone forZoneInfo(const basic::Info::ZoneInfo *zoneInfo, BasicZoneProcessor *zoneProcessor)
Convenience factory method to create from a zoneInfo and an associated BasicZoneProcessor.
Definition: TimeZone.h:174
ace_time::TimeZone::printTargetNameTo
void printTargetNameTo(Print &printer) const
Print the name of the target zone if the current time zone is a Link.
Definition: TimeZone.cpp:60
ace_time::TimeZone::forZoneInfo
static TimeZone forZoneInfo(const extended::Info::ZoneInfo *zoneInfo, ExtendedZoneProcessor *zoneProcessor)
Convenience factory method to create from a zoneInfo and an associated ExtendedZoneProcessor.
Definition: TimeZone.h:193
ace_time::TimeZone::getOffsetDateTime
OffsetDateTime getOffsetDateTime(const LocalDateTime &ldt) const
Return the best estimate of the OffsetDateTime at the given LocalDateTime for the current TimeZone.
Definition: TimeZone.h:386
ace_time::TimeZone::getOffsetDateTime
OffsetDateTime getOffsetDateTime(acetime_t epochSeconds) const
Return the best estimate of the OffsetDateTime at the given epochSeconds.
Definition: TimeZone.h:432
ace_time::TimeZone::isUtc
bool isUtc() const
Return true if UTC (+00:00+00:00).
Definition: TimeZone.h:463
ace_time::TimeZone::forUtc
static TimeZone forUtc()
Factory method to create a UTC TimeZone.
Definition: TimeZone.h:98
ace_time::TimeZone::forHours
static TimeZone forHours(int8_t stdHours, int8_t dstHours=0)
Factory method to create from UTC hour offset and optional DST hour offset.
Definition: TimeZone.h:128
ace_time::TimeZone::getType
uint8_t getType() const
Return the type of TimeZone, used to determine the behavior of certain methods at runtime.
Definition: TimeZone.h:258
ace_time::TimeZone::isLink
bool isLink() const
Return true if timezone is a Link entry pointing to a Zone entry.
Definition: TimeZone.h:271
ace_time::TimeZone::mZoneKey
uintptr_t mZoneKey
An opaque zone key.
Definition: TimeZone.h:625
ace_time::TimeZone::forMinutes
static TimeZone forMinutes(int16_t stdMinutes, int16_t dstMinutes=0)
Factory method to create from UTC minute offset and optional DST minute offset.
Definition: TimeZone.h:141
ace_time::TimeZone::printShortTo
void printShortTo(Print &printer) const
Print the short human readable representation of the time zone.
Definition: TimeZone.cpp:34
ace_time::TimeZone::kTypeError
static const uint8_t kTypeError
A TimeZone that represents an invalid condition.
Definition: TimeZone.h:89
ace_time::TimeZone::forError
static TimeZone forError()
Return a TimeZone representing an error condition.
Definition: TimeZone.h:241
ace_time::TimeZone::forZoneKey
static TimeZone forZoneKey(uintptr_t zoneKey, ZoneProcessor *processor)
Factory method to create from a generic zoneKey and a generic zoneProcessor.
Definition: TimeZone.h:233
ace_time::TimeZone::getDstOffset
TimeOffset getDstOffset() const
Return the DST TimeOffset.
Definition: TimeZone.h:266
ace_time::TimeZone::isError
bool isError() const
Return true if TimeZone is an error.
Definition: TimeZone.h:301
ace_time::TimeZone::isDst
bool isDst() const
Return if mDstOffsetMinutes is not zero.
Definition: TimeZone.h:475
ace_time::TimeZone::forTimeOffset
static TimeZone forTimeOffset(TimeOffset stdOffset, TimeOffset dstOffset=TimeOffset())
Factory method to create from a UTC offset and an optional DST offset.
Definition: TimeZone.h:115
ace_time::TimeZone::kTypeReserved
static const uint8_t kTypeReserved
Reserved for future use.
Definition: TimeZone.h:95
ace_time::TimeZone::getZonedExtra
ZonedExtra getZonedExtra(const LocalDateTime &ldt) const
Return the ZonedExtra information at epochSeconds.
Definition: TimeZone.h:304
ace_time::TimeZone::forHourMinute
static TimeZone forHourMinute(int8_t stdHour, int8_t stdMinute, int8_t dstHour=0, int8_t dstMinute=0)
Factory method to create from UTC (hour, minute) pair and optional DST (hour, minute) pair.
Definition: TimeZone.h:154
ace_time::TimeZone::toTimeZoneData
TimeZoneData toTimeZoneData() const
Convert to a TimeZoneData object, which can be fed back into ZoneManager::createForTimeZoneData() to ...
Definition: TimeZone.h:486
ace_time::TimeZone::getStdOffset
TimeOffset getStdOffset() const
Return the Standard TimeOffset.
Definition: TimeZone.h:261
ace_time::TimeZone::kTypeManual
static const uint8_t kTypeManual
Manual STD offset and DST offset.
Definition: TimeZone.h:92
ace_time::TimeZone::TimeZone
TimeZone()
Default constructor creates a UTC TimeZone.
Definition: TimeZone.h:246
ace_time::ZoneProcessor
Base interface for ZoneProcessor classes.
Definition: ZoneProcessor.h:140
ace_time::ZoneProcessor::getType
uint8_t getType() const
Return the kTypeXxx of the current instance.
Definition: ZoneProcessor.h:143
ace_time::ZoneProcessor::findByEpochSeconds
virtual FindResult findByEpochSeconds(acetime_t epochSeconds) const =0
Return the search results at given epochSeconds.
ace_time::ZoneProcessor::getZoneId
virtual uint32_t getZoneId() const =0
Return the unique stable zoneId.
ace_time::ZoneProcessor::findByLocalDateTime
virtual FindResult findByLocalDateTime(const LocalDateTime &ldt) const =0
Return the search results at given LocalDateTime.
ace_time::ZoneProcessor::isLink
virtual bool isLink() const =0
Return true if timezone is a Link entry pointing to a Zone entry.
ace_time::ZoneProcessor::setZoneKey
virtual void setZoneKey(uintptr_t zoneKey)=0
Set the opaque zoneKey of this object to a new value, reseting any internally cached information.
ace_time::ZonedExtra
Definition: ZonedExtra.h:19
ace_time::ZonedExtra::forError
static ZonedExtra forError()
Return an instance that indicates an error.
Definition: ZonedExtra.h:55
ace_time::ZonedExtra::kTypeExact
static const uint8_t kTypeExact
The given LocalDateTime matches a single epochSeconds.
Definition: ZonedExtra.h:35
ace_time::acetime_t
int32_t acetime_t
Type for the number of seconds from epoch.
Definition: common.h:24
ace_time::TimeZoneData
Data structure that captures the internal state of a TimeZone object with enough information so that ...
Definition: TimeZoneData.h:38
ace_time::TimeZoneData::zoneId
uint32_t zoneId
Both TimeZone::kTypeBasic and TimeZone::kTypeExtended are mapped to a TimeZoneData::kTypeZoneId.
Definition: TimeZoneData.h:85
ace_time::ZoneInfoHigh::ZoneInfo
Representation of a given time zone, implemented as an array of ZoneEra records.
Definition: ZoneInfoHigh.h:303
ace_time::ZoneInfoLow::ZoneInfo
Representation of a given time zone, implemented as an array of ZoneEra records.
Definition: ZoneInfoLow.h:324