BloombergLP::bdlb::operator<=

Less‐than‐or‐equal operators

Synopses

Declared in <bdlb_guid.h>

Return true if the value of the specified lhs guid object is less than or equal to 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 or equal to 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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) 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.

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

Return true if the specified lhs is null, and false otherwise.

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

Return true if the specified lhs is ordered before the specified rhs nullable wrapper or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) 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.

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

Return true if the specified lhs is null, and false otherwise.

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

Return true if the specified lhs is ordered before the specified rhs nullable wrapper or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) 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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns *lhs <= *rhs when both operands are of NullableValue type and have a value. Also 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 true. 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 true. 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.

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

Return true if the specified lhs is null, and false otherwise.

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

Return true if the specified lhs is ordered before the specified rhs nullable object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs).

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this operator returns !(rhs < lhs) when both operands are of NullableValue type. Also 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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.)

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 or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.)

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 or they are equal.

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 or they are equal.

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 or they are equal.

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 or they are equal.

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;
    };

Created with MrDocs