BloombergLP::bdlb::operator>=

Greater‐than‐or‐equal operators

Synopses

Declared in <bdlb_guid.h>

Return true if the value of the specified lhs guid object is greater 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 greater 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 object is ordered after 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 !(lhs < rhs) 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>=(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

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

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

Return true.

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

Return true if the specified lhs is wrapper after 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).

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 after the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this operator returns !(lhs < 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 object is ordered after 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 !(lhs < rhs) 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>=(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

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

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

Return true.

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

Return true if the specified lhs is wrapper after 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).

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 after the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this operator returns !(lhs < 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 object is ordered after 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 !(lhs < rhs) when both operands are of bsl::optional 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>=(
    NullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs nullable object is ordered after 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 true. If lhs does not contains a value, rhs does, return false. 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 true. If lhs does not contains a value, rhs does, return false. 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 null, and false otherwise.

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

Return true.

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

Return true if the specified lhs is ordered after 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).

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