BloombergLP::bdlb::operator<

Synopses

Declared in <bdlb_guid.h>

Return true if the value of the specified lhs guid object is less than the value of the specified rhs guid object, and false otherwise. Note that the comparison is accomplished using a lexicographic comparison of the internal representations.

bool
operator<(
    Guid const& lhs,
    Guid const& rhs);

Return true if the underlying iterator of the specified lhs compares less than the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<
    class FUNCTOR,
    class ITERATOR>
bool
operator<(
    TransformIterator<FUNCTOR, ITERATOR> const& lhs,
    TransformIterator<FUNCTOR, ITERATOR> const& rhs);

See the overload above for contract.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable wrapper is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any ConstNullableValueRef that is not null.

template<class TYPE>
bool
operator<(
    bsl::nullopt_t const&,
    ConstNullableValueRef<TYPE> const& rhs) noexcept;

Return false. bsl::nullopt never orders after a ConstNullableValueRef.

template<class TYPE>
bool
operator<(
    ConstNullableValueRef<TYPE> const&,
    bsl::nullopt_t const&) noexcept;

Return true if the specified lhs is ordered before the specified rhs nullable wrappers, and false otherwise. lhs is ordered before rhs if rhs is not null and lhs is ordered before rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    LHS_TYPE const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable wrapper is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is null or lhs.value() is ordered before rhs.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

Return true if the specified lhs nullable wrapper is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any NullableValueRef that is not null.

template<class TYPE>
bool
operator<(
    bsl::nullopt_t const&,
    NullableValueRef<TYPE> const& rhs) noexcept;

Return false. bsl::nullopt never orders after a NullableValueRef.

template<class TYPE>
bool
operator<(
    NullableValueRef<TYPE> const&,
    bsl::nullopt_t const&) noexcept;

Return true if the specified lhs is ordered before the specified rhs nullable wrappers, and false otherwise. lhs is ordered before rhs if rhs is not null and lhs is ordered before rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    LHS_TYPE const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable wrapper is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is null or lhs.value() is ordered before rhs.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValueRef<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

Return true if the specified lhs nullable wrapper is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable object is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValue<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs < *rhs } -> NullableValue_ConvertibleToBool;
    };

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value < rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    bsl::optional<LHS_TYPE> const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value < rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    bsl::optional<RHS_TYPE> const& rhs);

Return true if the specified rhs is not null, and false otherwise. Note that bsl::nullopt is ordered before any NullableAllocatedValue that is not null.

template<class TYPE>
bool
operator<(
    bsl::nullopt_t const&,
    NullableAllocatedValue<TYPE> const& rhs) noexcept;

Return false. Note that bsl::nullopt never orders after a NullableAllocatedValue.

template<class TYPE>
bool
operator<(
    NullableAllocatedValue<TYPE> const&,
    bsl::nullopt_t const&) noexcept;

Return true if the specified lhs is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if rhs is not null and lhs is ordered before rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    LHS_TYPE const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable object is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is null or lhs.value() is ordered before rhs.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

Return true if the specified lhs nullable object is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if lhs is null and rhs is non-null or if both are non-null and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

Return true if the specified lhs is ordered before the specified rhs nullable object, and false otherwise. lhs is ordered before rhs if rhs is not null and lhs is ordered before rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    LHS_TYPE const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires (!NullableValue_DerivedFromOptional<LHS_TYPE>) &&
    requires { { lhs < *rhs } -> NullableValue_ConvertibleToBool; };

Return true if the specified lhs nullable object is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is null or lhs.value() is ordered before rhs.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValue<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs)
requires (!NullableValue_DerivedFromOptional<RHS_TYPE>) &&
    requires { { *lhs < rhs } -> NullableValue_ConvertibleToBool; };

Return true if lhs is ordered before rhs, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValue<LHS_TYPE> const& lhs,
    std::optional<RHS_TYPE> const& rhs)
requires requires {
        { *lhs < *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if lhs is ordered before rhs, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    std::optional<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs < *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if lhs is ordered before rhs, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    NullableValue<LHS_TYPE> const& lhs,
    bsl::optional<RHS_TYPE> const& rhs)
requires requires {
        { *lhs < *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if lhs is ordered before rhs, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator<(
    bsl::optional<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs < *rhs } -> NullableValue_ConvertibleToBool;
    };