|
Quick Links: |
| bool bdlt::operator== | ( | const Calendar & | lhs, | |
| const Calendar & | rhs | |||
| ) |
Return true if the specified lhs and rhs calendars have the same value, and false otherwise. Two calendars have the same value if they have the same valid range (or are both empty), the same weekend days, the same holidays, and each corresponding pair of holidays has the same (ordered) set of associated holiday codes.
| bool bdlt::operator!= | ( | const Calendar & | lhs, | |
| const Calendar & | rhs | |||
| ) |
Return true if the specified lhs and rhs calendars do not have the same value, and false otherwise. Two calendars do not have the same value if they do not have the same valid range (and are not both empty), do not have the same weekend days, do not have the same holidays, or, for at least one corresponding pair of holidays, do not have the same (ordered) set of associated holiday codes.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Calendar & | calendar | |||
| ) |
Write the value of the specified calendar to the specified output stream, and return a reference to the modifiable stream.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Calendar & | object | |||
| ) |
| void bdlt::swap | ( | Calendar & | a, | |
| Calendar & | b | |||
| ) |
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.
| bool bdlt::operator== | ( | const Calendar_BusinessDayConstIter & | lhs, | |
| const Calendar_BusinessDayConstIter & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| bool bdlt::operator!= | ( | const Calendar_BusinessDayConstIter & | lhs, | |
| const Calendar_BusinessDayConstIter & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| Calendar_BusinessDayConstIter bdlt::operator++ | ( | Calendar_BusinessDayConstIter & | iterator, | |
| int | ||||
| ) |
Advance the specified iterator to refer to the next business day in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid business day.
| Calendar_BusinessDayConstIter bdlt::operator-- | ( | Calendar_BusinessDayConstIter & | iterator, | |
| int | ||||
| ) |
Regress the specified iterator to refer to the previous business day in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid business day that is not the first business day for the associated calendar.
| bool bdlt::operator== | ( | const CalendarReverseIteratorAdapter< ITERATOR > & | lhs, | |
| const CalendarReverseIteratorAdapter< ITERATOR > & | rhs | |||
| ) |
Return true if the specified lhs reverse iterator has the same value as the specified rhs reverse iterator, and false otherwise. Two reverse iterators have the same value if they refer to the same element, or both have the past-the-end value for a reverse iterator over the underlying reverse iteration sequence. The behavior is undefined unless lhs and rhs refer to the same underlying sequence.
| bool bdlt::operator!= | ( | const CalendarReverseIteratorAdapter< ITERATOR > & | lhs, | |
| const CalendarReverseIteratorAdapter< ITERATOR > & | rhs | |||
| ) |
Return true if the specified lhs reverse iterator does not have the same value as the specified rhs reverse iterator, and false otherwise. Two reverse iterators do not have the same value if (1) they do not refer to the same element and (2) both do not have the past-the-end value for a reverse iterator over the underlying reverse iteration sequence. The behavior is undefined unless lhs and rhs refer to the same underlying sequence.
| CalendarReverseIteratorAdapter<ITERATOR> bdlt::operator++ | ( | CalendarReverseIteratorAdapter< ITERATOR > & | iterator, | |
| int | ||||
| ) |
Modify the specified iterator to refer to the next element in the reverse iteration sequence, and return a reverse iterator having the pre-increment value of iterator. The behavior is undefined unless, on entry, iterator does not have the past-the-end value for a reverse iterator over the underlying sequence.
| CalendarReverseIteratorAdapter<ITERATOR> bdlt::operator-- | ( | CalendarReverseIteratorAdapter< ITERATOR > & | iterator, | |
| int | ||||
| ) |
Modify the specified iterator to refer to the previous element in the reverse iteration sequence, and return a reverse iterator having the pre-decrement value of iterator. The behavior is undefined unless, on entry, iterator does not have the same value as a reverse iterator to the start of the underlying sequence.
| bool bdlt::operator== | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Date objects have the same value if each of their year, month, and day attributes (respectively) have the same value.
| bool bdlt::operator!= | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two Date objects do not have the same value if any of their year, month, and day attributes (respectively) do not have the same value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Date & | date | |||
| ) |
Write the value of the specified date object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:
print(stream, 0, -1);
| bool bdlt::operator< | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs date is earlier than the specified rhs date, and false otherwise.
| bool bdlt::operator<= | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs date is earlier than or the same as the specified rhs date, and false otherwise.
| bool bdlt::operator> | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs date is later than the specified rhs date, and false otherwise.
| bool bdlt::operator>= | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return true if the specified lhs date is later than or the same as the specified rhs date, and false otherwise.
| Date bdlt::operator++ | ( | Date & | date, | |
| int | ||||
| ) |
Set the specified date object to have the value that is one day later than its current value, and return the value of date on entry. The behavior is undefined if the value of date on entry is 9999/12/31.
| Date bdlt::operator-- | ( | Date & | date, | |
| int | ||||
| ) |
Set the specified date object to have the value that is one day earlier than its current value, and return the value of date on entry. The behavior is undefined if the value of date on entry is 0001/01/01.
| Date bdlt::operator+ | ( | const Date & | date, | |
| int | numDays | |||
| ) |
| Date bdlt::operator+ | ( | int | numDays, | |
| const Date & | date | |||
| ) |
Return the date value that is later by the specified (signed) numDays from the specified date. The behavior is undefined unless the resulting value falls within the range of dates supported by this class (see isValidYearMonthDay). Note that numDays may be negative.
| Date bdlt::operator- | ( | const Date & | date, | |
| int | numDays | |||
| ) |
Return the date value that is earlier by the specified (signed) numDays from the specified date. The behavior is undefined unless the resulting value falls within the range of dates supported by this class (see isValidYearMonthDay). Note that numDays may be negative.
| int bdlt::operator- | ( | const Date & | lhs, | |
| const Date & | rhs | |||
| ) |
Return the (signed) number of days between the specified lhs and rhs dates. Note that if lhs < rhs the result will be negative.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Date & | object | |||
| ) |
| Datetime bdlt::operator+ | ( | const Datetime & | lhs, | |
| const bsls::TimeInterval & | rhs | |||
| ) |
Return a Datetime object having a value that is the sum of the specified lhs (Datetime) and the specified rhs (bsls::TimeInterval). If 24 == lhs.hour(), the result is the same as if the hour attribute of lhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| Datetime bdlt::operator+ | ( | const bsls::TimeInterval & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return a Datetime object having a value that is the sum of the specified lhs (bsls::TimeInterval) and the specified rhs (Datetime). If 24 == rhs.hour(), the result is the same as if the hour attribute of rhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| Datetime bdlt::operator+ | ( | const Datetime & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a Datetime object having a value that is the sum of the specified lhs (Datetime) and the specified rhs (DatetimeInterval). If 24 == lhs.hour(), the result is the same as if the hour attribute of lhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| Datetime bdlt::operator+ | ( | const DatetimeInterval & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return a Datetime object having a value that is the sum of the specified lhs (DatetimeInterval) and the specified rhs (Datetime). If 24 == rhs.hour(), the result is the same as if the hour attribute of rhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| Datetime bdlt::operator- | ( | const Datetime & | lhs, | |
| const bsls::TimeInterval & | rhs | |||
| ) |
Return a Datetime object having a value that is the difference between the specified lhs (Datetime) and the specified rhs (bsls::TimeInterval). If 24 == lhs.hour(), the result is the same as if the hour attribute of lhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| Datetime bdlt::operator- | ( | const Datetime & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a Datetime object having a value that is the difference between the specified lhs (Datetime) and the specified rhs (DatetimeInterval). If 24 == lhs.hour(), the result is the same as if the hour attribute of lhs is 0. The behavior is undefined unless the resulting value is in the valid range for a Datetime object.
| DatetimeInterval bdlt::operator- | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return a DatetimeInterval object having a value that is the difference between the specified lhs (Datetime) and the specified rhs (Datetime). If the hour attribute of either operand is 24, the result is the same as if that hour attribute is 0. The behavior is undefined unless the resulting value is in the valid range for a DatetimeInterval object.
| bool bdlt::operator== | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Datetime objects have the same value if they have the same values for their "date" and "time" parts, respectively.
| bool bdlt::operator!= | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
| bool bdlt::operator< | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the value of the specified lhs object is less than the value of the specified rhs object, and false otherwise. A Datetime object a is less than a Datetime object b if a.date() < b.date(), or if a.date() == b.date() and the time portion of a is less than the time portion of b. The behavior is undefined unless 24 != lhs.hour() && 24 != rhs.hour().
| bool bdlt::operator<= | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the value of the specified lhs object is less than or equal to the value of the specified rhs object, and false otherwise. The behavior is undefined unless 24 != lhs.hour() && 24 != rhs.hour().
| bool bdlt::operator> | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the value of the specified lhs object is greater than the value of the specified rhs object, and false otherwise. A Datetime object a is greater than a Datetime object b if a.date() > b.date(), or if a.date() == b.date() and the time portion of a is greater than the time portion of b. The behavior is undefined unless 24 != lhs.hour() && 24 != rhs.hour().
| bool bdlt::operator>= | ( | const Datetime & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the value of the specified lhs object is greater than or equal to the value of the specified rhs object, and false otherwise. The behavior is undefined unless 24 != lhs.hour() && 24 != rhs.hour().
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Datetime & | object | |||
| ) |
Write the value of the specified object object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:
print(stream, 0, -1);
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Datetime & | object | |||
| ) |
| DatetimeInterval bdlt::operator+ | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a DatetimeInterval object whose value is the sum of the specified lhs and rhs time intervals. The behavior is undefined unless the resulting time interval value is valid (i.e., the days field must not overflow a 32-bit integer).
| DatetimeInterval bdlt::operator- | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a DatetimeInterval object whose value is the difference between the specified lhs and rhs time intervals. The behavior is undefined unless the resulting time interval value is valid (i.e., the days field must not overflow a 32-bit integer).
| DatetimeInterval bdlt::operator- | ( | const DatetimeInterval & | value | ) |
Return a DatetimeInterval object whose value is the negative of the specified time interval value. The behavior is undefined unless INT_MIN < value.days().
| bool bdlt::operator== | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return true if the specified lhs and rhs time intervals have the same value, and false otherwise. Two time intervals have the same value if all of the corresponding values of their days, hours, minutes, seconds, milliseconds, and microseconds fields are the same.
| bool bdlt::operator!= | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return true if the specified lhs and rhs time intervals do not have the same value, and false otherwise. Two time intervals do not have the same value if any of the corresponding values of their days, hours, minutes, seconds, milliseconds, or microseconds fields is not the same.
| bool bdlt::operator< | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
| bool bdlt::operator<= | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
| bool bdlt::operator> | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
| bool bdlt::operator>= | ( | const DatetimeInterval & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return true if the nominal relation between the specified lhs and rhs time interval values holds, and false otherwise. lhs is less than rhs if the following expression evaluates to true:
lhs.days() < rhs.days()
|| (lhs.days() == rhs.days() && lhs.fractionalDayInMicroseconds()
< rhs.fractionalDayInMicroseconds())
The other relationships are defined similarly.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const DatetimeInterval & | object | |||
| ) |
Write the value of the specified object to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1).
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const DatetimeInterval & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for DatetimeInterval.
| bool bdlt::operator== | ( | const DatetimeTz & | lhs, | |
| const DatetimeTz & | rhs | |||
| ) |
Return true if the specified lhs and rhs DatetimeTz objects have the same value, and false otherwise. Two DatetimeTz objects have the same value if they have the same local datetime value and the same time zone offset value.
| bool bdlt::operator!= | ( | const DatetimeTz & | lhs, | |
| const DatetimeTz & | rhs | |||
| ) |
Return true if the specified lhs and rhs DatetimeTz objects do not have the same value, and false otherwise. Two DatetimeTz objects do not have the same value if they do not have the same local datetime value or the same time zone offset value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const DatetimeTz & | rhs | |||
| ) |
Write the value of the specified rhs object to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const DatetimeTz & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for DatetimeTz. Note that two objects which represent the same UTC time but have different offsets will not (necessarily) hash to the same value.
| bool bdlt::operator== | ( | const DateTz & | lhs, | |
| const DateTz & | rhs | |||
| ) |
| bool bdlt::operator!= | ( | const DateTz & | lhs, | |
| const DateTz & | rhs | |||
| ) |
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const DateTz & | rhs | |||
| ) |
Write the value of the specified rhs object to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const DateTz & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for DateTz. Note that two objects which represent the same UTC time but have different offsets will not (necessarily) hash to the same value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| DayOfWeek::Enum | value | |||
| ) |
Write the string representation of the specified enumeration value to the specified output stream in a single-line format, and return a reference to stream. See toAscii for what constitutes the string representation of a bdlt::DayOfWeek::Enum value. Note that this method has the same behavior as
bdlt::DayOfWeek::print(stream, value, 0, -1);
| STREAM& bdlt::bdexStreamIn | ( | STREAM & | stream, | |
| DayOfWeek::Enum & | variable, | |||
| int | version | |||
| ) |
Load into the specified variable the DayOfWeek::Enum value read from the specified input stream using the specified version format, and return a reference to stream. If stream is initially invalid, this operation has no effect. If version is not supported by DayOfWeek, variable is unaltered and stream is invalidated, but otherwise unmodified. If version is supported by DayOfWeek but stream becomes invalid during this operation, variable has an undefined, but valid, state. The behavior is undefined unless STREAM is BDEX-compliant. Note that no version is read from stream. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| STREAM& bdlt::bdexStreamOut | ( | STREAM & | stream, | |
| const DayOfWeek::Enum & | value, | |||
| int | version | |||
| ) |
Write the specified value, using the specified version format, to the specified output stream, and return a reference to stream. If stream is initially invalid, this operation has no effect. If version is not supported by DayOfWeek, stream is invalidated, but otherwise unmodified. The behavior is undefined unless STREAM is BDEX-compliant. Note that version is not written to stream. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| int bdlt::maxSupportedBdexVersion | ( | const DayOfWeek::Enum * | , | |
| int | versionSelector | |||
| ) |
Return the maximum valid BDEX format version, as indicated by the specified versionSelector, to be passed to the bdexStreamOut method while streaming an object of the type DayOfWeek::Enum. Note that it is highly recommended that versionSelector be formatted as "YYYYMMDD", a date representation. Also note that versionSelector should be a compile-time-chosen value that selects a format version supported by both externalizer and unexternalizer. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| bool bdlt::operator== | ( | const DayOfWeekSet_Iter & | lhs, | |
| const DayOfWeekSet_Iter & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two iterators have the same value if they refer to data at the same index position. The behavior is undefined unless lhs and rhs both reference into the same set of data.
| bool bdlt::operator!= | ( | const DayOfWeekSet_Iter & | lhs, | |
| const DayOfWeekSet_Iter & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not have the same value, and false otherwise. Two iterators do not have the same value if they do not refer to data at the same index position. The behavior is undefined unless lhs and rhs both reference into the same set of data.
| DayOfWeekSet bdlt::operator~ | ( | const DayOfWeekSet & | set | ) |
Return a set containing the complement of the specified set (i.e., those members not contained in set).
| DayOfWeekSet bdlt::operator| | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
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).
| DayOfWeekSet bdlt::operator& | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
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).
| DayOfWeekSet bdlt::operator^ | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
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).
| DayOfWeekSet bdlt::operator- | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
Return a set containing the subtraction of the specified rhs set from the specified lhs set (i.e., a set containing elements that are in lhs, but not in rhs).
| bool bdlt::operator== | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
Return true if the specified lhs and rhs sets have the same value, and false otherwise. Two sets have the same value if they have the same length and all the elements of one set are members of the other set.
| bool bdlt::operator!= | ( | const DayOfWeekSet & | lhs, | |
| const DayOfWeekSet & | rhs | |||
| ) |
Return true if the specified lhs and rhs sets do not have the same value, and false otherwise. Two sets do not have the same value if they differ in length or there exists an element of one set that is not a member of the other set.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const DayOfWeekSet & | rhs | |||
| ) |
Write the specified rhs set to the specified output stream in some reasonable (single-line) format, and return a reference to stream.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const DayOfWeekSet & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for DayOfWeekSet.
| bool bdlt::operator== | ( | const FixUtilConfiguration & | lhs, | |
| const FixUtilConfiguration & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FixUtilConfiguration objects have the same value if each of their fractionalSecondPrecision and useZAbbreviationForUtc attributes (respectively) have the same value.
| bool bdlt::operator!= | ( | const FixUtilConfiguration & | lhs, | |
| const FixUtilConfiguration & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two FixUtilConfiguration objects do not have the same value if any of their fractionalSecondPrecision or useZAbbreviationForUtc attributes (respectively) do not have the same value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const FixUtilConfiguration & | object | |||
| ) |
Write the value of the specified object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.
| bool bdlt::operator== | ( | const Iso8601UtilConfiguration & | lhs, | |
| const Iso8601UtilConfiguration & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two Iso8601UtilConfiguration objects have the same value if each of their fractionalSecondPrecision, omitColonInZoneDesignator, useCommaForDecimalSign, and useZAbbreviationForUtc attributes (respectively) have the same value.
| bool bdlt::operator!= | ( | const Iso8601UtilConfiguration & | lhs, | |
| const Iso8601UtilConfiguration & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two Iso8601UtilConfiguration objects do not have the same value if any of their fractionalSecondPrecision, omitColonInZoneDesignator, useCommaForDecimalSign, or useZAbbreviationForUtc attributes (respectively) do not have the same value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Iso8601UtilConfiguration & | object | |||
| ) |
Write the value of the specified object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| MonthOfYear::Enum | value | |||
| ) |
Write the string representation of the specified enumeration value to the specified output stream in a single-line format, and return a reference to stream. See toAscii for what constitutes the string representation of a bdlt::MonthOfYear::Enum value. Note that this method has the same behavior as
bdlt::MonthOfYear::print(stream, value, 0, -1);
| STREAM& bdlt::bdexStreamIn | ( | STREAM & | stream, | |
| MonthOfYear::Enum & | variable, | |||
| int | version | |||
| ) |
Load into the specified variable the MonthOfYear::Enum value read from the specified input stream using the specified version format, and return a reference to stream. If stream is initially invalid, this operation has no effect. If version is not supported by MonthOfYear, variable is unaltered and stream is invalidated, but otherwise unmodified. If version is supported by MonthOfYear but stream becomes invalid during this operation, variable has an undefined, but valid, state. The behavior is undefined unless STREAM is BDEX-compliant. Note that no version is read from stream. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| STREAM& bdlt::bdexStreamOut | ( | STREAM & | stream, | |
| const MonthOfYear::Enum & | value, | |||
| int | version | |||
| ) |
Write the specified value, using the specified version format, to the specified output stream, and return a reference to stream. If stream is initially invalid, this operation has no effect. If version is not supported by MonthOfYear, stream is invalidated, but otherwise unmodified. The behavior is undefined unless STREAM is BDEX-compliant. Note that version is not written to stream. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| int bdlt::maxSupportedBdexVersion | ( | const MonthOfYear::Enum * | , | |
| int | versionSelector | |||
| ) |
Return the maximum valid BDEX format version, as indicated by the specified versionSelector, to be passed to the bdexStreamOut method while streaming an object of the type MonthOfYear::Enum. Note that it is highly recommended that versionSelector be formatted as "YYYYMMDD", a date representation. Also note that versionSelector should be a compile-time-chosen value that selects a format version supported by both externalizer and unexternalizer. See the bslx package-level documentation for more information on BDEX streaming of value-semantic types and containers.
| bool bdlt::operator== | ( | const PackedCalendar & | lhs, | |
| const PackedCalendar & | rhs | |||
| ) |
Return true if the specified lhs and rhs calendars have the same value, and false otherwise. Two calendars have the same value if they have the same valid range (or are both empty), the same weekend days, the same holidays, and each corresponding pair of holidays has the same (ordered) set of associated holiday codes.
| bool bdlt::operator!= | ( | const PackedCalendar & | lhs, | |
| const PackedCalendar & | rhs | |||
| ) |
Return true if the specified lhs and rhs calendars do not have the same value, and false otherwise. Two calendars do not have the same value if they do not have the same valid range (and are not both empty), do not have the same weekend days, do not have the same holidays, or, for at least one corresponding pair of holidays, do not have the same (ordered) set of associated holiday codes.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const PackedCalendar & | calendar | |||
| ) |
Write the value of the specified calendar to the specified output stream, and return a reference to the modifiable stream.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const PackedCalendar & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for PackedCalendar.
| void bdlt::swap | ( | PackedCalendar & | a, | |
| PackedCalendar & | b | |||
| ) |
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.
| bool bdlt::operator== | ( | const PackedCalendar_HolidayConstIterator & | lhs, | |
| const PackedCalendar_HolidayConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| bool bdlt::operator!= | ( | const PackedCalendar_HolidayConstIterator & | lhs, | |
| const PackedCalendar_HolidayConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| PackedCalendar_HolidayConstIterator bdlt::operator++ | ( | PackedCalendar_HolidayConstIterator & | iterator, | |
| int | ||||
| ) |
Advance the specified iterator to refer to the next holiday in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid holiday.
| PackedCalendar_HolidayConstIterator bdlt::operator-- | ( | PackedCalendar_HolidayConstIterator & | iterator, | |
| int | ||||
| ) |
Regress the specified iterator to refer to the previous holiday in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid holiday that is not the first holiday in the associated calendar.
| bool bdlt::operator== | ( | const PackedCalendar_HolidayCodeConstIterator & | lhs, | |
| const PackedCalendar_HolidayCodeConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators refers to the same element, and false otherwise. The behavior is undefined unless lhs and rhs both reference the same holiday in the same calendar.
| bool bdlt::operator!= | ( | const PackedCalendar_HolidayCodeConstIterator & | lhs, | |
| const PackedCalendar_HolidayCodeConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not refer to the same element, and false otherwise. The behavior is undefined unless lhs and rhs both reference the same holiday in the same calendar.
| PackedCalendar_HolidayCodeConstIterator bdlt::operator++ | ( | PackedCalendar_HolidayCodeConstIterator & | iterator, | |
| int | ||||
| ) |
Advance the specified iterator to refer to the next holiday code for the associated date in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid holiday code.
| PackedCalendar_HolidayCodeConstIterator bdlt::operator-- | ( | PackedCalendar_HolidayCodeConstIterator & | iterator, | |
| int | ||||
| ) |
Regress the specified iterator to refer to the previous holiday code for the associated date in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid holiday code that is not the first holiday code for the associated date in the calendar.
| bsl::ptrdiff_t bdlt::operator- | ( | const PackedCalendar_HolidayCodeConstIterator & | lhs, | |
| const PackedCalendar_HolidayCodeConstIterator & | rhs | |||
| ) |
Return the number of elements between specified lhs and rhs. The behavior is undefined unless lhs and rhs refer to codes associated with the same holiday in the same calendar.
| bool bdlt::operator== | ( | const PackedCalendar_BusinessDayConstIterator & | lhs, | |
| const PackedCalendar_BusinessDayConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| bool bdlt::operator!= | ( | const PackedCalendar_BusinessDayConstIterator & | lhs, | |
| const PackedCalendar_BusinessDayConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not refer to the same element in the same calendar, and false otherwise. The behavior is undefined unless lhs and rhs both iterate over the same calendar.
| PackedCalendar_BusinessDayConstIterator bdlt::operator++ | ( | PackedCalendar_BusinessDayConstIterator & | iterator, | |
| int | ||||
| ) |
Advance the specified iterator to refer to the next business day in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid business day.
| PackedCalendar_BusinessDayConstIterator bdlt::operator-- | ( | PackedCalendar_BusinessDayConstIterator & | iterator, | |
| int | ||||
| ) |
Regress the specified iterator to refer to the previous business day in the associated calendar, and return the previous value of iterator. The behavior is undefined unless, on entry, iterator references a valid business day that is not the first business day for the associated calendar.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Time & | object | |||
| ) |
| Time bdlt::operator+ | ( | const Time & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a Time value that is the sum of the specified lhs time and the specified rhs datetime interval.
| Time bdlt::operator+ | ( | const DatetimeInterval & | lhs, | |
| const Time & | rhs | |||
| ) |
Return a Time value that is the sum of the specified lhs datetime interval and the specified rhs time.
| Time bdlt::operator- | ( | const Time & | lhs, | |
| const DatetimeInterval & | rhs | |||
| ) |
Return a Time value that is the difference between the specified lhs time and the specified rhs datetime interval.
| DatetimeInterval bdlt::operator- | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return a DatetimeInterval object initialized with the difference between the specified lhs and rhs time values.
| bool bdlt::operator== | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs and rhs time objects have the same value, and false otherwise. Two time objects have the same value if each of their corresponding hour, minute, second, millisecond, and microsecond attributes respectively have the same value.
| bool bdlt::operator!= | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs and rhs time objects do not have the same value, and false otherwise. Two time objects do not have the same value if any of their corresponding hour, minute, second, millisecond, and microsecond attributes respectively do not have the same value.
| bool bdlt::operator< | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs time value is less than the specified rhs time value, and false otherwise. The behavior is undefined unless lhs != Time() and rhs != Time() (i.e., they do not have the, default, value 24:00:00.000000).
| bool bdlt::operator<= | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs time value is less than or equal to the specified rhs time value, and false otherwise. The behavior is undefined unless lhs != Time() and rhs != Time() (i.e., they do not have the, default, value 24:00:00.000000).
| bool bdlt::operator> | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs time value is greater than the specified rhs time value, and false otherwise. The behavior is undefined unless lhs != Time() and rhs != Time() (i.e., they do not have the, default, value 24:00:00.000000).
| bool bdlt::operator>= | ( | const Time & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs time value is greater than or equal to the specified rhs time value, and false otherwise. The behavior is undefined unless lhs != Time() and rhs != Time() (i.e., they do not have the, default, value 24:00:00.000000).
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Time & | time | |||
| ) |
Write the value of the specified time object to the specified output stream in a single-line format, and return a reference to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified, can change without notice, and is logically equivalent to:
print(stream, 0, -1);
| bool bdlt::operator== | ( | const TimetableTransition & | lhs, | |
| const TimetableTransition & | rhs | |||
| ) |
Return true if the specified lhs and rhs timetable transitions have the same value, and false otherwise. Two timetable transitions have the same value if they have the same datetime and code.
| bool bdlt::operator!= | ( | const TimetableTransition & | lhs, | |
| const TimetableTransition & | rhs | |||
| ) |
Return true if the specified lhs and rhs timetable transitions do not have the same value, and false otherwise. Two timetable transitions do not have the same value if they do not have the same datetime or the same code.
| bool bdlt::operator< | ( | const TimetableTransition & | lhs, | |
| const TimetableTransition & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Timetable transition lhs has a value less than timetable transition rhs if lhs.datetime() < rhs.datetime(), or lhs.datetime() == rhs.datetime() and lhs.code() < rhs.code().
| bool bdlt::operator< | ( | const TimetableTransition & | lhs, | |
| const Datetime & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Timetable transition lhs has a value less than datetime rhs if lhs.datetime() < rhs. The behavior is undefined unless 24 > rhs.hour().
| bool bdlt::operator< | ( | const Datetime & | lhs, | |
| const TimetableTransition & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Datetime lhs has a value less than timetable transition rhs if lhs < rhs.datetime(). The behavior is undefined unless 24 > lhs.hour().
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const TimetableTransition & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for TimetableTransition.
| bool bdlt::operator== | ( | const Timetable_CompactableTransition & | lhs, | |
| const Timetable_CompactableTransition & | rhs | |||
| ) |
Return true if the specified lhs and rhs compactable transitions have the same value, and false otherwise. Two compactable transitions have the same value if they have the same time and code.
| bool bdlt::operator!= | ( | const Timetable_CompactableTransition & | lhs, | |
| const Timetable_CompactableTransition & | rhs | |||
| ) |
Return true if the specified lhs and rhs compactable transitions do not have the same value, and false otherwise. Two compactable transitions do not have the same value if they do not have the same time or the same code.
| bool bdlt::operator< | ( | const Timetable_CompactableTransition & | lhs, | |
| const Timetable_CompactableTransition & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Compactable transition lhs has a value less than compactable transition rhs if lhs.time() < rhs.time(), or lhs.time() == rhs.time() and lhs.code() < rhs.code().
| bool bdlt::operator< | ( | const Timetable_CompactableTransition & | lhs, | |
| const Time & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Compactable transition lhs has a value less than time rhs if lhs.time() < rhs. The behavior is undefined unless 24 > rhs.hour().
| bool bdlt::operator< | ( | const Time & | lhs, | |
| const Timetable_CompactableTransition & | rhs | |||
| ) |
Return true if the specified lhs has a value less than the specified rhs, and false otherwise. Time lhs has a value less than compactable transition rhs if lhs < rhs.time(). The behavior is undefined unless 24 > lhs.hour().
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Timetable_CompactableTransition & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for Timetable_CompactableTransition.
| bool bdlt::operator== | ( | const Timetable_Day & | lhs, | |
| const Timetable_Day & | rhs | |||
| ) |
Return true if the specified lhs and rhs daily timetables have the same value, and false otherwise. Two daily timetables have the same value if they have the same initial transition code, the same number of transitions, and each corresponding pair of transitions has the same value.
| bool bdlt::operator!= | ( | const Timetable_Day & | lhs, | |
| const Timetable_Day & | rhs | |||
| ) |
Return true if the specified lhs and rhs daily timetables do not have the same value, and false otherwise. Two daily timetables do not have the same value if they do not have the same initial transition code, they do not have the same number of transitions, or there is a corresponding pair of transitions that do not have the same value.
| bool bdlt::operator< | ( | const Timetable_Day & | lhs, | |
| const Timetable_Day & | rhs | |||
| ) |
Return true if the specified lhs daily timetable is less than the specified rhs daily timetable, and false otherwise. The lhs daily timetable is less than the rhs daily timetable if lhs.initialTransitionCode() < rhs.initialTransitionCode(), or lhs.initialTransitionCode() == rhs.initialTransitionCode() and lhs.d_transitions < rhs.d_transitions.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Timetable_Day & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for Timetable_Day.
| bool bdlt::operator== | ( | const Timetable & | lhs, | |
| const Timetable & | rhs | |||
| ) |
Return true if the specified lhs and rhs timetables have the same value, and false otherwise. Two timetables have the same value if they have the same initial transition code, the same valid range (or are both empty), the same number of transitions, and each corresponding pair of transitions have the same value.
| bool bdlt::operator!= | ( | const Timetable & | lhs, | |
| const Timetable & | rhs | |||
| ) |
Return true if the specified lhs and rhs timetables do not have the same value, and false otherwise. Two timetables do not have the same value if they do not have the same initial transition code, do not have the same valid range (and are not both empty), do not have the same number of transitions, or, for at least one corresponding pair of transitions, do not have the same value.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const Timetable & | timetable | |||
| ) |
Write the value of the specified timetable to the specified output stream, and return a reference to the modifiable stream.
| void bdlt::swap | ( | Timetable & | a, | |
| Timetable & | b | |||
| ) |
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.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const Timetable & | object | |||
| ) |
| Timetable_ConstIterator bdlt::operator++ | ( | Timetable_ConstIterator & | iterator, | |
| int | ||||
| ) |
Advance the specified iterator to refer to the next transition in the referenced timetable, and return an iterator referring to the original element (before the advancement). The behavior is undefined unless, on entry, iterator references a valid transition.
| Timetable_ConstIterator bdlt::operator-- | ( | Timetable_ConstIterator & | iterator, | |
| int | ||||
| ) |
Regress the specified iterator to refer to the previous transition in the referenced timetable, and return an iterator referring to the original element (before the decrementation). The behavior is undefined unless, on entry, iterator references a valid transition that is not the first transition of the associated timetable.
| bool bdlt::operator== | ( | const Timetable_ConstIterator & | lhs, | |
| const Timetable_ConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two Timetable_ConstIterator iterators have the same value if they refer to the same timetable and the same transition.
| bool bdlt::operator!= | ( | const Timetable_ConstIterator & | lhs, | |
| const Timetable_ConstIterator & | rhs | |||
| ) |
Return true if the specified lhs and rhs iterators do not have the same value, and false otherwise. Two Timetable_ConstIterator iterators do not have the same value if they do not refer to the same timetable, or do not refer to the same transition.
| bool bdlt::operator== | ( | const TimeTz & | lhs, | |
| const TimeTz & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two TimeTz objects have the same value if their corresponding localTime and offset attributes have the same values.
| bool bdlt::operator!= | ( | const TimeTz & | lhs, | |
| const TimeTz & | rhs | |||
| ) |
Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. Two TimeTz objects do not have the same value if any of their corresponding localTime and offset attributes have different values.
| bsl::ostream& bdlt::operator<< | ( | bsl::ostream & | stream, | |
| const TimeTz & | object | |||
| ) |
Write the value of the specified object to the specified output stream in a single-line format, and return a reference providing modifiable access to stream. If stream is not valid on entry, this operation has no effect. Note that this human-readable format is not fully specified and can change without notice. Also note that this method has the same behavior as object.print(stream, 0, -1), but with the attribute names elided.
| void bdlt::hashAppend | ( | HASHALG & | hashAlg, | |
| const TimeTz & | object | |||
| ) |
Pass the specified object to the specified hashAlg. This function integrates with the bslh modular hashing system and effectively provides a bsl::hash specialization for TimeTz. Note that two objects which represent the same UTC time but have different offsets will not (necessarily) hash to the same value.
1.7.1