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

Namespace for date and time types in the `bdl` package group.

== Types

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


== Type Aliases

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


== 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&`] 
| Return a set containing the intersection of the specified `lhs` and `rhs` sets (i.e., a set containing elements that are in both `lhs` and `rhs`).
| xref:BloombergLP/bdlt/operator_plus-0a.adoc[`operator+`] 
| Addition operators
| xref:BloombergLP/bdlt/operator_inc-01.adoc[`operator++`] 
| Increment operators
| xref:BloombergLP/bdlt/operator_minus-02.adoc[`operator‐`] 
| Unary minus operators
| xref:BloombergLP/bdlt/operator_dec-0a.adoc[`operator‐‐`] 
| Decrement operators
| xref:BloombergLP/bdlt/operator_xor.adoc[`operatorˆ`] 
| Return a set containing the exclusive‐or of the specified `lhs` and `rhs` sets (i.e., a set containing elements that are either in `lhs`, but not `rhs`, or in `rhs`, but not `lhs`).
| xref:BloombergLP/bdlt/operator_bitor.adoc[`operator|`] 
| Return a set containing the union of the specified `lhs` and `rhs` sets (i.e., a set containing elements that are in either `lhs` or `rhs` or both).
| xref:BloombergLP/bdlt/operator_bitnot.adoc[`operator~`] 
| Return a set containing the complement of the specified `set` (i.e., those members _not_ contained in `set`).
| xref:BloombergLP/bdlt/swap-04.adoc[`swap`] 
| Exchange the values of the specified `a` and `b` objects. This function provides the no‐throw exception‐safety guarantee if the two objects were created with the same allocator and the basic guarantee otherwise.
| xref:BloombergLP/bdlt/operator_lshift-0f.adoc[`operator<<`] 
| Stream insertion operators
| xref:BloombergLP/bdlt/operator_eq-07.adoc[`operator==`] 
| Equality operators
| xref:BloombergLP/bdlt/operator_not_eq-06c.adoc[`operator!=`] 
| Inequality operators
| xref:BloombergLP/bdlt/operator_lt-0c1.adoc[`operator<`] 
| Less‐than operators
| xref:BloombergLP/bdlt/operator_le-0c.adoc[`operator<=`] 
| Less‐than‐or‐equal operators
| xref:BloombergLP/bdlt/operator_gt-07.adoc[`operator>`] 
| Greater‐than operators
| xref:BloombergLP/bdlt/operator_ge-0e.adoc[`operator>=`] 
| Greater‐than‐or‐equal operators
|===



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