[#BloombergLP-bdlb-operator_gt-0dc]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator&gt;
:relfileprefix: ../../
:mrdocs:

Greater&hyphen;than 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 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_gt-0f6.adoc[operator&gt;](
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& lhs,
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& rhs);
----

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

Return `true` if the underlying iterator of the specified `lhs` compares greater than 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_gt-011b.adoc[operator&gt;](
    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_gt-011b.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_gt-0110.adoc[operator&gt;](
    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_gt-0110.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is non&hyphen;null and `rhs` is null or if both are non&hyphen;null and `lhs&period;value()` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs` 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_gt-098.adoc[operator&gt;](
    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_gt-098.adoc[_» more&period;&period;&period;_]#

Return `false`&period; `bsl&colon;&colon;nullopt` never orders after a `NullableValueRef`&period;


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

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

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


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

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

Return `true` if the specified `lhs` is ordered after the specified `rhs` nullable wrapper, and `false` otherwise&period; `lhs` is ordered after `rhs` if `rhs` is null or `lhs` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs`, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is not null and `lhs&period;value()` is ordered after `rhs`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is non&hyphen;null and `rhs` is null or if both are non&hyphen;null and `lhs&period;value()` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs` 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_gt-0b0.adoc[operator&gt;](
    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_gt-0b0.adoc[_» more&period;&period;&period;_]#

Return `false`&period; `bsl&colon;&colon;nullopt` never orders after a `NullableValueRef`&period;


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

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

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


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

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

Return `true` if the specified `lhs` is ordered after the specified `rhs` nullable wrapper, and `false` otherwise&period; `lhs` is ordered after `rhs` if `rhs` is null or `lhs` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs`, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is not null and `lhs&period;value()` is ordered after `rhs`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable wrapper is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is non&hyphen;null and `rhs` is null or if both are non&hyphen;null and `lhs&period;value()` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs` 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_gt-0c5e.adoc[operator&gt;](
    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_gt-0c5e.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` nullable object is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is non&hyphen;null and `rhs` is null or if both are non&hyphen;null and `lhs&period;value()` is ordered after `rhs&period;value()`&period; Note that this operator returns `&ast;lhs &gt; &ast;rhs` when both operands are of `NullableValue` type and both have values&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_gt-0da.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

If neither of the specified `lhs` and `rhs` contain a value, return `false`&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; 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_gt-04b.adoc[operator&gt;](
    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_gt-04b.adoc[_» more&period;&period;&period;_]#

If neither of the specified `lhs` and `rhs` contain a value, return `false`&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; 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_gt-07b.adoc[operator&gt;](
    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_gt-07b.adoc[_» more&period;&period;&period;_]#

Return `false`&period; Note that `bsl&colon;&colon;nullopt` never orders after a `NullableAllocatedValue`&period;


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

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

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


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

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

Return `true` if the specified `lhs` is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `rhs` is null or `lhs` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable object is ordered after the specified `rhs`, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is not null and `lhs&period;value()` is ordered after `rhs`&period; Note that this operator returns `rhs &lt; lhs`&period;


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

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

Return `true` if the specified `lhs` nullable object is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is non&hyphen;null and `rhs` is null or if both are non&hyphen;null and `lhs&period;value()` is ordered after `rhs&period;value()`&period; Note that this operator returns `rhs &lt; lhs` 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_gt-054.adoc[operator&gt;](
    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_gt-054.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` is ordered after the specified `rhs` nullable object, and `false` otherwise&period; `lhs` is ordered after `rhs` if `rhs` is null or `lhs` is ordered after `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_gt-0bb.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

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

Return `true` if the specified `lhs` nullable object is ordered after the specified `rhs`, and `false` otherwise&period; `lhs` is ordered after `rhs` if `lhs` is not null and `lhs&period;value()` is ordered after `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_gt-075.adoc[operator&gt;](
    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; rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

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

Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_gt-013.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_gt-04a.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_gt-03.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_gt-00.adoc[operator&gt;](
    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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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


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