[#BloombergLP-bdlt]
= xref:BloombergLP.adoc[BloombergLP]::bdlt
:relfileprefix: ../
:mrdocs:

Namespace for date and time types in the `bdl` package group&period;

== Types

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlt/Calendar.adoc[`Calendar`] 
| This class implements a runtime&hyphen;efficient, value&hyphen;semantic repository of weekend and holiday information over a _valid_ _range_ of dates&period; This valid range, `&lsqb;firstDate() &period;&period; lastDate()&rsqb;`, spans the first and last dates of a calendar&apos;s accessible contents&period; A calendar can be &quot;populated&quot; with weekend and holiday information via a suite of &quot;add&quot; methods&period; Any subset of days of the week may be specified as weekend (i&period;e&period;, recurring non&hyphen;business) days starting from a specified date by adding a weekend&hyphen;days transition&semi; holidays within the valid range are specified individually&period; When adding a holiday, an arbitrary integer &quot;holiday code&quot; may be associated with that date&period; Additional holiday codes for that date may subsequently be added&period; Both the holidays and the set of unique holiday codes associated with each holiday date are maintained (internally) in order of increasing value&period; Note that the behavior of requesting _any_ calendar information for a supplied date whose value is outside the current _valid_ _range_ for that calendar (unless otherwise noted, e&period;g&period;, `isWeekendDay`) is undefined&period;
| xref:BloombergLP/bdlt/CalendarCache.adoc[`CalendarCache`] 
| This class implements an efficient cache of _read&hyphen;only_ `bdlt&colon;&colon;Calendar` objects that are loaded into the cache, using a calendar loader supplied at construction, as a side&hyphen;effect of the `getCalendar` manipulator&period; Calendars in the cache can be invalidated, and removed from the cache via the `invalidate` and `invalidateAll` methods&period; In addition, calendars in the cache can be made to expire based on a timeout that may be optionally supplied at construction&period; The `bsl&colon;&colon;shared&lowbar;ptr&lt;const bdlt&colon;&colon;Calendar&gt;` objects returned from the `getCalendar` and `lookupCalendar` methods allow for the safe removal of calendars from the cache that may still have outstanding references to them&period;
| xref:BloombergLP/bdlt/CalendarCache_Entry.adoc[`CalendarCache&lowbar;Entry`] 
| This class defines the type of objects that are inserted into the calendar cache&period; Each entry contains a shared pointer to a read&hyphen;only calendar and the time at which that calendar was loaded&period; Note that an explicit allocator is _required_ to create an entry object&period;
| xref:BloombergLP/bdlt/CalendarLoader.adoc[`CalendarLoader`] 
| This class defines a protocol used to load calendars from a specific source&period; Each repository of calendar information can be supported by a distinct implementation of this protocol&period;
| xref:BloombergLP/bdlt/CalendarReverseIteratorAdapter.adoc[`CalendarReverseIteratorAdapter`] 
| This reverse iterator adapter provides a subset of the `bsl&colon;&colon;reverse&lowbar;iterator` interface that can be used with the calendar iterators defined in `bdlt`&period; Specifically, the types `value&lowbar;type`, `difference&lowbar;type`, `pointer`, and `reference` are defined but `iterator&lowbar;category` is not defined (since this is not a fully&hyphen;compliant iterator)&period; Furthermore, the methods appropriate for random&hyphen;access iterators are not included (e&period;g&period;, `operator&plus;&equals;`)&period;
| xref:BloombergLP/bdlt/CalendarUtil.adoc[`CalendarUtil`] 
| This `struct` provides a namespace for utility functions that operate on dates in the context of supplied calendars&period;
| xref:BloombergLP/bdlt/Calendar_BusinessDayConstIter.adoc[`Calendar&lowbar;BusinessDayConstIter`] 
| Provide read&hyphen;only, sequential access in increasing (chronological) order to the business days in a `Calendar` object&period;
| xref:BloombergLP/bdlt/CurrentTime.adoc[`CurrentTime`] 
| This `struct` provides a namespace for current&hyphen;time&hyphen;retrieval procedures including a configurable global callback mechanism&period; The use of a _subset_ of these procedures is thread&hyphen;safe (see `Thread Safety`)&period;
| xref:BloombergLP/bdlt/Date.adoc[`Date`] 
| This class implements a complex&hyphen;constrained, value&hyphen;semantic type for representing dates according to the Unix (POSIX) calendar&period; Each object of this class _always_ represents a _valid_ date value in the range `&lsqb;0001JAN01 &period;&period; 9999DEC31&rsqb;` inclusive&period; The interface of this class supports `Date` values expressed in terms of either year&sol;month&sol;day (the canonical representation) or year&sol;day&hyphen;of&hyphen;year (an alternate representation)&period; See &lsqb;&rsqb;Date Values and Their Representations) for details&period;
| xref:BloombergLP/bdlt/DateFormatter.adoc[`DateFormatter`] 
| This `class` provides a specifier formatter for printing `Date` objects&period;
| xref:BloombergLP/bdlt/DateFormatter_Cache.adoc[`DateFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `Date` object during printing by batching access to several fields in a single call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/DateTz.adoc[`DateTz`] 
| This value&hyphen;semantic class describes a date value in a particular time zone, which is indicated using an offset from UTC (in minutes)&period;
| xref:BloombergLP/bdlt/DateTzFormatter.adoc[`DateTzFormatter`] 
| This `class` provides a specifier formatter for printing `DateTz` objects&period;
| xref:BloombergLP/bdlt/DateTzFormatter_Cache.adoc[`DateTzFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `DateTz` object during printing by batching access to several fields in a single call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/DateUtil.adoc[`DateUtil`] 
| This `struct` provides a namespace for utility functions that provide non&hyphen;primitive operations on dates&period;
| xref:BloombergLP/bdlt/Datetime.adoc[`Datetime`] 
| This class implements a simply&hyphen;constrained value&hyphen;semantic type representing the composition of date and time values&period; Valid date values for the &quot;date&quot; part of a `Datetime` object are the same as those defined for `Date` objects&semi; similarly, valid time values for the &quot;time&quot; part of a `Datetime` object are similar to those defined for `Time` objects (but with additional precision)&period; Relational operators are disallowed on `Datetime` objects whose &quot;time&quot; part has the same value as that of a default constructed `Time` object&period;
| xref:BloombergLP/bdlt/DatetimeFormatter.adoc[`DatetimeFormatter`] 
| This `class` provides a specifier formatter for printing `Datetime` objects&period;
| xref:BloombergLP/bdlt/DatetimeFormatter_Cache.adoc[`DatetimeFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `Datetime` object during printing by batching access to several fields per call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/DatetimeImpUtil.adoc[`DatetimeImpUtil`] 
| This `struct` provides a namespace for datetime encoding constants&period;
| xref:BloombergLP/bdlt/DatetimeInterval.adoc[`DatetimeInterval`] 
| Each object of this class represents a (signed) time interval with microsecond resolution&period; See &lcub;The Representation of a Time Interval&rcub; for details&period;
| xref:BloombergLP/bdlt/DatetimeIntervalUtil.adoc[`DatetimeIntervalUtil`] 
| This utility `struct` provides a namespace for a suite of functions operating on objects of type `DatetimeInterval`&period;
| xref:BloombergLP/bdlt/DatetimeTz.adoc[`DatetimeTz`] 
| This value&hyphen;semantic class describes a datetime value in a particular time zone, which is indicated using an offset from UTC (in minutes)&period;
| xref:BloombergLP/bdlt/DatetimeTzFormatter.adoc[`DatetimeTzFormatter`] 
| This `class` provides a specifier formatter for printing `DatetimeTz` objects&period;
| xref:BloombergLP/bdlt/DatetimeTzFormatter_Cache.adoc[`DatetimeTzFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `DatetimeTz` object during printing by batching access to several fields per call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/DatetimeUtil.adoc[`DatetimeUtil`] 
| This utility `struct` provides a namespace for a suite of functions operating on objects of type `Datetime`&period;
| xref:BloombergLP/bdlt/DayOfWeek.adoc[`DayOfWeek`] 
| This `struct` provides a namespace for enumerating day&hyphen;of&hyphen;week values&period; See `Enum` in the TYPES sub&hyphen;section for details&period;
| xref:BloombergLP/bdlt/DayOfWeekSet.adoc[`DayOfWeekSet`] 
| This class implements an efficient value&hyphen;semantic, ordered set of `DayOfWeek` values&period; This set requires a fixed capacity, and all operations operate in constant time, and provide the no&hyphen;throw guarantee&period;
| xref:BloombergLP/bdlt/DayOfWeekSet_Iter.adoc[`DayOfWeekSet&lowbar;Iter`] 
| Implementation of standard bidirectional iterator for `DayOfWeekSet`&period; Any modification of a `DayOfWeekSet` will invalidate any iterators referring to that `DayOfWeekSet`&period;
| xref:BloombergLP/bdlt/DayOfWeekUtil.adoc[`DayOfWeekUtil`] 
| This `struct` provides a namespace for common non&hyphen;primitive procedures that operate on `bdlt&colon;&colon;DayOfWeek&colon;&colon;Enum` values&period;
| xref:BloombergLP/bdlt/DefaultCalendarCache.adoc[`DefaultCalendarCache`] 
| This `struct` provides a namespace for functions that manage the lifetime of, and access to, a process&hyphen;wide default `bdlt&colon;&colon;CalendarCache` object&period; The default cache is initialized by an explicit call to the `initialize` class method, and destroyed by the `destroy` class method&period; The default cache may be initialized and destroyed multiple times during the lifetime of a process&period; The lifetimes of the calendar loader and memory allocator supplied to `initialize` must extend beyond the following (matching) call to `destroy`&period;
| xref:BloombergLP/bdlt/DefaultTimetableCache.adoc[`DefaultTimetableCache`] 
| This `struct` provides a namespace for functions that manage the lifetime of, and access to, a process&hyphen;wide default `bdlt&colon;&colon;TimetableCache` object&period; The default cache is initialized by an explicit call to the `initialize` class method, and destroyed by the `destroy` class method&period; The default cache may be initialized and destroyed multiple times during the lifetime of a process&period; The lifetimes of the timetable loader and memory allocator supplied to `initialize` must extend beyond the following (matching) call to `destroy`&period;
| xref:BloombergLP/bdlt/EpochUtil.adoc[`EpochUtil`] 
| This `struct` provides a namespace for a suite of non&hyphen;primitive functions providing conversions between absolute `Datetime` values and corresponding relative time intervals with respect to the Unix standard epoch time, returned by the `epoch` method&period; These methods are alias&hyphen;safe, thread&hyphen;safe, and exception&hyphen;neutral&period; Functions are provided for returning converted values by value or through a result pointer&period;
| xref:BloombergLP/bdlt/FixUtil.adoc[`FixUtil`] 
| This `struct` provides a namespace for a suite of pure functions that perform conversions between objects of `bdlt` vocabulary type and their FIX representations&period; Each `generate` and `generateRaw` method takes a `bdlt` object (of type `Date`, `DateTz`, `Time`, `TimeTz`, `Datetime`, or `DatetimeTz`) and outputs its corresponding FIX representation to a user&hyphen;supplied character buffer or `bsl&colon;&colon;ostream`&period; The `parse` methods effect the opposite conversion in that they populate a `bdlt` object from the result of parsing a FIX representation&period;
| xref:BloombergLP/bdlt/FixUtilConfiguration.adoc[`FixUtilConfiguration`] 
| This unconstrained (value&hyphen;semantic) attribute class characterizes how to configure certain behavior in `FixUtil` functions&period; Currently, only the `generate` and `generateRaw` methods of that utility are affected by `FixUtilConfiguration` settings&period; See the  section for information on the class attributes&period;
| xref:BloombergLP/bdlt/FormatTestUtil.adoc[`FormatTestUtil`] 
| This `struct` serves as a namespace for static functions to facilitate testing of formatting of `bdlt` value types &hyphen;&hyphen; used in the implementation of the above macros, and for conversion between `bsl&colon;&colon;string` and `bsl&colon;&colon;wstring`&period;
| xref:BloombergLP/bdlt/FormatUtil.adoc[`FormatUtil`] 
| This `class` serves as a namespace for some static functions that are useful in creating specializations of `bsl&colon;&colon;formatter` to support `bsl&colon;&colon;format`&period;
| xref:BloombergLP/bdlt/Formatter.adoc[`Formatter`] 
| 
| xref:BloombergLP/bdlt/FuzzUtil.adoc[`FuzzUtil`] 
| This utility `struct` provides a namespace for a suite of functions that produce objects of date and time values from fuzz data&period;
| xref:BloombergLP/bdlt/IntervalConversionUtil.adoc[`IntervalConversionUtil`] 
| This utility `struct`, `IntervalConversionUtil`, defines functions to convert between `bsls&colon;&colon;TimeInterval` and `bdlt&colon;&colon;DatetimeInterval` representations of time intervals&period;
| xref:BloombergLP/bdlt/Iso8601Util.adoc[`Iso8601Util`] 
| This `struct` provides a namespace for a suite of pure functions that perform conversions between objects of `bdlt` vocabulary type and their ISO 8601 representations&period; Each `generate` and `generateRaw` method takes a `bdlt` object (of type `Date`, `DateTz`, `Time`, `TimeTz`, `Datetime`, or `DatetimeTz`) and outputs its corresponding ISO 8601 representation to a user&hyphen;supplied character buffer or `bsl&colon;&colon;ostream`&period; The `parse` methods effect the opposite conversion in that they populate a `bdlt` object from the result of parsing an ISO 8601 representation&period;
| xref:BloombergLP/bdlt/Iso8601UtilConfiguration.adoc[`Iso8601UtilConfiguration`] 
| This unconstrained (value&hyphen;semantic) attribute class characterizes how to configure certain behavior in `Iso8601Util` functions&period; Currently, only the `generate` and `generateRaw` methods of that utility are affected by `Iso8601UtilConfiguration` settings&period; See the  section for information on the class attributes&period;
| xref:BloombergLP/bdlt/Iso8601UtilParseConfiguration.adoc[`Iso8601UtilParseConfiguration`] 
| This unconstrained (value&hyphen;semantic) attribute class characterizes how to configure certain behavior in `Iso8601Util` functions&period; See the  section for information on the class attributes&period;
| xref:BloombergLP/bdlt/Literal_SpecifierFormatter.adoc[`Literal&lowbar;SpecifierFormatter`] 
| This `class` does parsing and output of sequences whose corresponding output is independent of the type and value of the object being formatted&period;
| xref:BloombergLP/bdlt/LocalTimeOffset.adoc[`LocalTimeOffset`] 
| This `struct` provides a namespace for local&hyphen;time&hyphen;offset procedures including a configurable global callback mechanism&period; The use of these procedures is thread&hyphen;safe (see `Thread Safety`)&period;
| xref:BloombergLP/bdlt/MonthOfYear.adoc[`MonthOfYear`] 
| This `struct` provides a namespace for enumerating month&hyphen;of&hyphen;year values&period; See `Enum` in the TYPES sub&hyphen;section for details&period;
| xref:BloombergLP/bdlt/PackedCalendar.adoc[`PackedCalendar`] 
| This class implements a space&hyphen;efficient, value&hyphen;semantic repository of weekend and holiday information over a _valid_ _range_ of dates&period; This valid range, `&lsqb;firstDate() &period;&period; lastDate()&rsqb;`, spans the first and last dates of a calendar&apos;s accessible contents&period; A calendar can be &quot;populated&quot; with weekend and holiday information via a suite of &quot;add&quot; methods&period; Any subset of days of the week may be specified as weekend (i&period;e&period;, recurring non&hyphen;business) days starting from a specified date by adding a weekend&hyphen;days transition&semi; holidays within the valid range are specified individually&period; When adding a holiday, an arbitrary integer &quot;holiday code&quot; may be associated with that date&period; Additional holiday codes for that date may subsequently be added&period; Both the holidays and the set of unique holiday codes associated with each holiday date are maintained (internally) in order of increasing value&period; Note that the behavior of requesting _any_ calendar information for a supplied date whose value is outside the current _valid_ _range_ for that calendar (unless otherwise noted, e&period;g&period;, `isWeekendDay`) is undefined&period;
| xref:BloombergLP/bdlt/PackedCalendar_BusinessDayConstIterator.adoc[`PackedCalendar&lowbar;BusinessDayConstIterator`] 
| Provide read&hyphen;only, sequential access in increasing (chronological) order to the business days in a `PackedCalendar` object&period;
| xref:BloombergLP/bdlt/PackedCalendar_DateProxy.adoc[`PackedCalendar&lowbar;DateProxy`] 
| This class serves as a proxy for `Date` for use by the arrow operator of calendar iterators (e&period;g&period;, `PackedCalendar&lowbar;HolidayConstIterator`)&period; An object of this class behaves as the `Date` object with which it was constructed&period;
| xref:BloombergLP/bdlt/PackedCalendar_DateRef.adoc[`PackedCalendar&lowbar;DateRef`] 
| This private class is used by the arrow operator of the holiday iterator and business day iterator classes&period; The objects instantiated from this class serve as references to `Date` objects&period;
| xref:BloombergLP/bdlt/PackedCalendar_HolidayCodeConstIterator.adoc[`PackedCalendar&lowbar;HolidayCodeConstIterator`] 
| Provide read&hyphen;only, sequential access in increasing (numerical) order to the holiday codes in a `PackedCalendar` object&period;
| xref:BloombergLP/bdlt/PackedCalendar_HolidayConstIterator.adoc[`PackedCalendar&lowbar;HolidayConstIterator`] 
| Provide read&hyphen;only, sequential access in increasing (chronological) order to the holidays in a `PackedCalendar` object&period; This class owns an iterator into the `bdlc&colon;&colon;PackedIntArray` storing the holiday offsets of the referenced `bdlt&colon;&colon;PackedCalendar` and a date, `d&lowbar;firstDate`, to convert the offsets into dates corresponding to holidays&period;
| xref:BloombergLP/bdlt/PosixDateImpUtil.adoc[`PosixDateImpUtil`] 
| This `struct` provides a namespace for a suite of pure functions that perform low&hyphen;level operations on date values in a variety of formats&period; Note that all of these functions, whether or not implemented in terms of a static cache, are stateless, and, as such, are inherently thread&hyphen;safe&period;
| xref:BloombergLP/bdlt/ProlepticDateImpUtil.adoc[`ProlepticDateImpUtil`] 
| This `struct` provides a namespace for a suite of pure functions that perform low&hyphen;level operations on date values in a variety of formats&colon; year&sol;month&sol;day, year&sol;day&hyphen;of&hyphen;year, and serial date&period; Dates in the range `&lsqb;0001&sol;01&sol;01 &period;&period; 9999&sol;12&sol;31&rsqb;` that are valid per the proleptic Gregorian calendar are supported, with serial date 1 (3652059) corresponding to `0001&sol;01&sol;01` (`9999&sol;12&sol;31`)&period; Note that all of the functions, whether or not implemented in terms of a static cache, are stateless, and, as such, are inherently thread&hyphen;safe&period;
| xref:BloombergLP/bdlt/Time.adoc[`Time`] 
| This `class` implements a value&hyphen;semantic type that represents the time of day to a resolution of one microsecond&period; Each object of this (almost) simply constrained attribute class _always_ represents a valid time value to a resolution of one microsecond&period; The valid range for times is 00&colon;00&colon;00&period;000000 through 23&colon;59&colon;59&period;999999, except that 24&colon;00&colon;00&period;000000 represents the default&hyphen;constructed value&period; The value 24&colon;00&colon;00&period;000000 behaves, in most cases, as if it were the value 00&colon;00&colon;00&period;000000&semi; however, for all relational comparison operators, 24&colon;00&colon;00&period;000000 is not a valid argument and, therefore, would result in undefined behavior&period; Each add operation on a `Time` object returns the (signed) number of times that the 23&colon;59&colon;59&period;999999 &hyphen; 00&colon;00&colon;00&period;000000 boundary was crossed while performing the operation&period; Attempting to construct a `Time` with any attribute outside its valid range (or with an hour attribute value of 24 and any other attribute non&hyphen;zero) has undefined behavior&period;
| xref:BloombergLP/bdlt/TimeFormatter.adoc[`TimeFormatter`] 
| This `class` provides a specifier formatter for printing `Time` objects&period;
| xref:BloombergLP/bdlt/TimeFormatter_Cache.adoc[`TimeFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `Time` object during printing by batching access to several fields in a single call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/TimeTz.adoc[`TimeTz`] 
| This value&hyphen;semantic class describes a time value in a particular time zone, which is indicated using an offset from UTC (in minutes)&period; The offset is available via the `offset` method, and is defined by the relationship&colon; `localTime() &hyphen; offset() &equals;&equals; utcTime`&period; The time and offset values are logically assumed to correspond to geographically valid values, however, this constraint is not enforced&period;
| xref:BloombergLP/bdlt/TimeTzFormatter.adoc[`TimeTzFormatter`] 
| This `class` provides a specifier formatter for printing `TimeTz` objects&period;
| xref:BloombergLP/bdlt/TimeTzFormatter_Cache.adoc[`TimeTzFormatter&lowbar;Cache`] 
| This `class` facilitates faster access to a `TimeTz` object during printing by batching access to several fields in a single call during construction and caching them for quick access later&period;
| xref:BloombergLP/bdlt/TimeUnitRatio.adoc[`TimeUnitRatio`] 
| This `struct` provides a namespace for constants characterizing ratios between commonly&hyphen;used time units&period;
| xref:BloombergLP/bdlt/TimeUtil.adoc[`TimeUtil`] 
| This `struct` provides a namespace for common non&hyphen;primitive procedures that operate on `Time` objects&period; These methods are alias&hyphen;safe and exception&hyphen;neutral&period;
| xref:BloombergLP/bdlt/TimeZoneFormatter.adoc[`TimeZoneFormatter`] 
| This `class` provides a specifier formatter for printing time zones&period;
| xref:BloombergLP/bdlt/Timetable.adoc[`Timetable`] 
| This class implements a value&hyphen;semantic repository of datetime&hyphen;indexed state transitions over a _valid_ _range_ of dates&period; This valid range, `&lsqb;firstDate() &period;&period; lastDate()&rsqb;`, spans the first and last dates of a timetable&apos;s accessible contents&period; A timetable can be &quot;populated&quot; with state transitions via a suite of &quot;add&quot; methods&period; Note that the behavior of requesting _any_ timetable information for a supplied date whose value is outside the current _valid_ _range_ for that timetable is undefined&period;
| xref:BloombergLP/bdlt/TimetableCache.adoc[`TimetableCache`] 
| This class implements an efficient cache of _read&hyphen;only_ `bdlt&colon;&colon;Timetable` objects that are loaded into the cache, using a timetable loader supplied at construction, as a side&hyphen;effect of the `getTimetable` manipulator&period; Timetables in the cache can be invalidated, and removed from the cache via the `invalidate` and `invalidateAll` methods&period; In addition, timetables in the cache can be made to expire based on a timeout that may be optionally supplied at construction&period; The `bsl&colon;&colon;shared&lowbar;ptr&lt;const bdlt&colon;&colon;Timetable&gt;` objects returned from the `getTimetable` and `lookupTimetable` methods allow for the safe removal of timetables from the cache that may still have outstanding references to them&period;
| xref:BloombergLP/bdlt/TimetableCache_Entry.adoc[`TimetableCache&lowbar;Entry`] 
| This class defines the type of objects that are inserted into the timetable cache&period; Each entry contains a shared pointer to a read&hyphen;only timetable and the time at which that timetable was loaded&period; Note that an explicit allocator is _required_ to create an entry object&period;
| xref:BloombergLP/bdlt/TimetableLoader.adoc[`TimetableLoader`] 
| This class defines a protocol used to load timetables from a specific source&period; Each repository of timetable information can be supported by a distinct implementation of this protocol&period;
| xref:BloombergLP/bdlt/TimetableTransition.adoc[`TimetableTransition`] 
| This simply&hyphen;constrained attribute class represents a state transition, implemented as a datetime for when the transition occurs, and a code to indicate the new state&period;
| xref:BloombergLP/bdlt/TimetableTransition_Ref.adoc[`TimetableTransition&lowbar;Ref`] 
| This private class is used by the arrow operator of the timetable iterator class&period; The objects instantiated from this class serve as references to `TimetableTransition` objects&period;
| xref:BloombergLP/bdlt/Timetable_CompactableTransition.adoc[`Timetable&lowbar;CompactableTransition`] 
| This simply&hyphen;constrained attribute class represents a state transition, implemented as a time for when the transition occurs, and a code to indicate the new state&period;
| xref:BloombergLP/bdlt/Timetable_ConstIterator.adoc[`Timetable&lowbar;ConstIterator`] 
| Provide read&hyphen;only, sequential access in increasing (chronological) order to the transitions in a `Timetable` object&period;
| xref:BloombergLP/bdlt/Timetable_Day.adoc[`Timetable&lowbar;Day`] 
| This class implements a value&hyphen;semantic repository of time&hyphen;indexed state transitions over one date (this class implements one day of a timetable)&period; A `Timetable&lowbar;Day` can be &quot;populated&quot; with state transitions via the `addTransition` method, and queried for the transition code in effect at a specified time via the `transitionCodeInEffect` method&period; Note that, as an optimization for the `transitionCodeInEffect` method, the transition code in effect before the first possible transition is stored in `d&lowbar;initialTransitionCode`&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlt/SerialDateImpUtil.adoc[`SerialDateImpUtil`] 
| Alias for `PosixDateImpUtil` when proleptic dates are not enabled&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlt/bdexStreamIn-05.adoc[`bdexStreamIn`] 
| `bdexStreamIn` overloads
| xref:BloombergLP/bdlt/bdexStreamOut-05.adoc[`bdexStreamOut`] 
| `bdexStreamOut` overloads
| xref:BloombergLP/bdlt/hashAppend-07b.adoc[`hashAppend`] 
| `hashAppend` overloads
| xref:BloombergLP/bdlt/maxSupportedBdexVersion-0b.adoc[`maxSupportedBdexVersion`] 
| `maxSupportedBdexVersion` overloads
| xref:BloombergLP/bdlt/operator_bitand.adoc[`operator&amp;`] 
| Return a set containing the intersection of the specified `lhs` and `rhs` sets (i&period;e&period;, a set containing elements that are in both `lhs` and `rhs`)&period;
| xref:BloombergLP/bdlt/operator_plus-0a.adoc[`operator&plus;`] 
| Addition operators
| xref:BloombergLP/bdlt/operator_inc-01.adoc[`operator&plus;&plus;`] 
| Increment operators
| xref:BloombergLP/bdlt/operator_minus-02.adoc[`operator&hyphen;`] 
| Unary minus operators
| xref:BloombergLP/bdlt/operator_dec-0a.adoc[`operator&hyphen;&hyphen;`] 
| Decrement operators
| xref:BloombergLP/bdlt/operator_xor.adoc[`operator&circ;`] 
| Return a set containing the exclusive&hyphen;or of the specified `lhs` and `rhs` sets (i&period;e&period;, a set containing elements that are either in `lhs`, but not `rhs`, or in `rhs`, but not `lhs`)&period;
| xref:BloombergLP/bdlt/operator_bitor.adoc[`operator&verbar;`] 
| Return a set containing the union of the specified `lhs` and `rhs` sets (i&period;e&period;, a set containing elements that are in either `lhs` or `rhs` or both)&period;
| xref:BloombergLP/bdlt/operator_bitnot.adoc[`operator&#126;`] 
| Return a set containing the complement of the specified `set` (i&period;e&period;, those members _not_ contained in `set`)&period;
| xref:BloombergLP/bdlt/swap-04.adoc[`swap`] 
| Exchange the values of the specified `a` and `b` objects&period; This function provides the no&hyphen;throw exception&hyphen;safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise&period;
| xref:BloombergLP/bdlt/operator_lshift-0f.adoc[`operator&lt;&lt;`] 
| Stream insertion operators
| xref:BloombergLP/bdlt/operator_eq-07.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:BloombergLP/bdlt/operator_not_eq-06c.adoc[`operator!&equals;`] 
| Inequality operators
| xref:BloombergLP/bdlt/operator_lt-0c1.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:BloombergLP/bdlt/operator_le-0c.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:BloombergLP/bdlt/operator_gt-07.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:BloombergLP/bdlt/operator_ge-0e.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
