[#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 specified `lhs` is greater than or equal to `rhs`&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 `lhs` is at least that of `rhs`&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 whether `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-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 whether `rhs` is null&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& lhs,
    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& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const& rhs) noexcept;
----

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

Return whether `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-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 whether `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-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 whether `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-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 whether the specified nullable value is null&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& lhs,
    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& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const& rhs) noexcept;
----

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

Return whether `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-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 whether `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-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 whether `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-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 whether the specified `lhs` is ordered after or equal to `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-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;_]#

Return whether the left&hyphen;hand operand is after or equal to the right&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;_]#

Return whether the left&hyphen;hand operand is after or equal to the right&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& nullopt,
    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& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const& nullopt) noexcept;
----

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

Return whether the left&hyphen;hand operand is after or equal to the right&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 whether the left&hyphen;hand operand is after or equal to the right&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 whether the left&hyphen;hand operand is after or equal to the right&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 whether the specified `lhs` is ordered after or equal to `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-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 whether the specified `lhs` is ordered after or equal to `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-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;_]#

== Return Value

* `true` if `lhs` is greater than or equal to `rhs`, and `false` otherwise
* `true` if the underlying iterator of `lhs` is greater than or equal to that of `rhs`, and `false` otherwise
* `true` if `lhs` is ordered after `rhs` or they have the same value, and `false` otherwise
* `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
* `true` if the specified `rhs` is null, and `false` otherwise
* `true`
* `true` if the specified `lhs` is wrapper after the specified `rhs` nullable object or `lhs` and `rhs` have the same value, and `false` otherwise
* `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs` or `lhs` and `rhs` have the same value, and `false` otherwise
* `true` if `lhs` is ordered after `rhs` or they are equal, and `false` otherwise
* `true` if `lhs` is ordered after or equal to `rhs`, and `false` otherwise
* `true` if `rhs` is null, and `false` otherwise
* `true` if `lhs` is ordered after `rhs` or they are equal

== Parameters

[cols="1,4"]
|===
| Name| Description
| *lhs*
| left&hyphen;hand operand
| *rhs*
| right&hyphen;hand operand
| *nullopt*
| disengaged&hyphen;optional tag&semi; value is unused
|===


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