BloombergLP::bdlb::operator>

Greater‐than operators

Synopses

Declared in <bdlb_guid.h>

Return true if the value of the specified lhs guid object is greater 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 greater 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if lhs is non‐null and rhs is null or if both are non‐null and lhs.value() is ordered after rhs.value(). 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>(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

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

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

Return true if the specified lhs is not 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 after the specified rhs nullable wrapper, and false otherwise. lhs is ordered after rhs if rhs is null or lhs is ordered after rhs.value(). 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 after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is not null and lhs.value() is ordered after rhs. 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if lhs is non‐null and rhs is null or if both are non‐null and lhs.value() is ordered after rhs.value(). 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>(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

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

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

Return true if the specified lhs is not 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 after the specified rhs nullable wrapper, and false otherwise. lhs is ordered after rhs if rhs is null or lhs is ordered after rhs.value(). 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 after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is not null and lhs.value() is ordered after rhs. 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if lhs is non‐null and rhs is null or if both are non‐null and lhs.value() is ordered after rhs.value(). Note that this operator returns rhs < lhs 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, and false otherwise. lhs is ordered after rhs if lhs is non‐null and rhs is null or if both are non‐null and lhs.value() is ordered after rhs.value(). Note that this operator returns *lhs > *rhs when both operands are of NullableValue type and both have values. 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 false. 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 false. 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 false. Note that bsl::nullopt never orders after a NullableAllocatedValue.

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

Return true if the specified lhs is not 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if rhs is null or lhs is ordered after rhs.value(). 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 after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is not null and lhs.value() is ordered after rhs. 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if lhs is non‐null and rhs is null or if both are non‐null and lhs.value() is ordered after rhs.value(). 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 after the specified rhs nullable object, and false otherwise. lhs is ordered after rhs if rhs is null or lhs is ordered after 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 after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is not null and lhs.value() is ordered after 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 after 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 after 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 after 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 after 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;
    };

Created with MrDocs