[#BloombergLP-bdlb-operator_ge-064]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator&gt;&equals;
:relfileprefix: ../../
:mrdocs:

Greater&hyphen;than&hyphen;or&hyphen;equal operators

== Synopses

Declared in `&lt;bdlb&lowbar;guid&period;h&gt;`

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&period; Note that the comparison is accomplished using a lexicographic comparison of the internal representations&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_ge-05f.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& lhs,
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-05f.adoc[_» more&period;&period;&period;_]#

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&period; The behavior is undefined if comparing the underlying iterators in this way is undefined&period; Note that the functors are not compared&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class FUNCTOR,
    class ITERATOR&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0cf5.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator&lt;FUNCTOR, ITERATOR&gt;] const& lhs,
    xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator&lt;FUNCTOR, ITERATOR&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0cf5.adoc[_» more&period;&period;&period;_]#

See the overload above for contract&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-03d.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-03d.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)` when both operands are of `NullableValue` type&period; Also note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-09f9.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-09f9.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-09fe.adoc[operator&gt;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-09fe.adoc[_» more&period;&period;&period;_]#

Return `true`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-008.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;TYPE&gt;] const&,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-008.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-09c.adoc[operator&gt;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-09c.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0a.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0a.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)` when both operands are of `NullableValue` type&period; Also note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-035.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-035.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0b.adoc[operator&gt;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0b.adoc[_» more&period;&period;&period;_]#

Return `true`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0e.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;TYPE&gt;] const&,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0e.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-08c.adoc[operator&gt;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-08c.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-037.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-037.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)` when both operands are of `bsl&colon;&colon;optional` type&period; Also note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-05d.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-05d.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `&ast;lhs &gt;&equals; &ast;rhs` when both operands are of `NullableValue` type and have a value&period; Also note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-058.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-058.adoc[_» more&period;&period;&period;_]#

If neither of the specified `lhs` and `rhs` contain a value, return `true`&period; If `lhs` contains a value, and `rhs` does not, return `true`&period; If `lhs` does not contains a value, `rhs` does, return `false`&period; Otherwise, return `lhs&period;value &gt;&equals; rhs&period;value()`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-01d1.adoc[operator&gt;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-01d1.adoc[_» more&period;&period;&period;_]#

If neither of the specified `lhs` and `rhs` contain a value, return `true`&period; If `lhs` contains a value, and `rhs` does not, return `true`&period; If `lhs` does not contains a value, `rhs` does, return `false`&period; Otherwise, return `lhs&period;value &gt;&equals; rhs&period;value()`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-060.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-060.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-062.adoc[operator&gt;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-062.adoc[_» more&period;&period;&period;_]#

Return `true`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-003.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;TYPE&gt;] const&,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-003.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-01dd.adoc[operator&gt;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-01dd.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0cf2.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0cf2.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;) Note that this operator returns `!(lhs &lt; rhs)` when both operands are of `NullableValue` type&period; Also note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-04.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_ge-04.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;)


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-092.adoc[operator&gt;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires (!NullableValue&lowbar;DerivedFromOptional&lt;LHS&lowbar;TYPE&gt;) &amp;&amp;
    requires &lcub; &lcub; lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-092.adoc[_» more&period;&period;&period;_]#

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&period; (See `operator&gt;` and `operator&equals;&equals;`&period;)


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-07.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs)
requires (!NullableValue&lowbar;DerivedFromOptional&lt;RHS&lowbar;TYPE&gt;) &amp;&amp;
    requires &lcub; &lcub; &ast;lhs &gt;&equals; rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-07.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` is ordered after `rhs` or they are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-082.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    std::optional&lt;RHS&lowbar;TYPE&gt; const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-082.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` is ordered after `rhs` or they are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0f.adoc[operator&gt;&equals;](
    std::optional&lt;LHS&lowbar;TYPE&gt; const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0f.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` is ordered after `rhs` or they are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-0d.adoc[operator&gt;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-0d.adoc[_» more&period;&period;&period;_]#

Return `true` if `lhs` is ordered after `rhs` or they are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_ge-087.adoc[operator&gt;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &gt;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_ge-087.adoc[_» more&period;&period;&period;_]#


[.small]#Created with https://www.mrdocs.com[MrDocs]#
