[#BloombergLP-bdlb-NullableValue]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::NullableValue
:relfileprefix: ../../
:mrdocs:

Value&hyphen;semantic wrapper that adds a null state to `TYPE`&period;

== Synopsis

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

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
class NullableValue
    : public xref:bsl/optional-072.adoc[bsl::optional&lt;TYPE&gt;]
----

== Description

This template class extends the set of values of its value&hyphen;semantic `TYPE` parameter to include the notion of a &quot;null&quot; value&period; If `TYPE` is fully value&hyphen;semantic, then the augmented type `NullableValue&lt;TYPE&gt;` will be as well&period; In addition to supporting all homogeneous value&hyphen;semantic operations, conversions between comparable underlying value types is also supported&period; Two nullable objects with different underlying types compare equal if their underlying types are comparable and either (1) both objects are null or (2) the non&hyphen;null values compare equal&period; A null nullable object is considered ordered before any non&hyphen;null nullable object&period; Attempts to copy construct, copy assign, or compare incompatible values types will fail to compile&period; The `NullableValue` template cannot be instantiated on an incomplete type, a type that overloads unary `operator&amp;`, or `bsl&colon;&colon;nullopt&lowbar;t`&period;

== Base Classes

[cols="1,4"]
|===
| Name| Description
| `xref:bsl/optional-072.adoc[bsl::optional&lt;TYPE&gt;]`
| Allocator&hyphen;aware nullable wrapper for an object of type `t&lowbar;TYPE`&period;
|===

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/NullableValue/Base.adoc[`Base`] 
| Base class of this type&period;
| xref:BloombergLP/bdlb/NullableValue/ValueType.adoc[`ValueType`] 
| `ValueType` is an alias for the underlying `TYPE` upon which this template class is instantiated, and represents the type of the managed object&period;
| xref:BloombergLP/bdlb/NullableValue/allocator_type.adoc[`allocator&lowbar;type`] 
| Allocator type used by this object&period;
| xref:BloombergLP/bslstl/Optional_Base-05/value_type.adoc[`value&lowbar;type`] 
| Alias for the managed object type of this optional&period;
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/NullableValue/2constructor-093.adoc[`NullableValue`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bdlb/NullableValue/operator_assign-087.adoc[`operator&equals;`] 
| Assignment operators
| xref:BloombergLP/bdlb/NullableValue/addressOr.adoc[`addressOr`] 
| Return the address of the contained object, or `address` if null&period;
| xref:bsl/optional-072/and_then-08d.adoc[`and&lowbar;then`] 
| `and&lowbar;then` overloads
| xref:BloombergLP/bdlb/NullableValue/bdexStreamIn.adoc[`bdexStreamIn`] 
| Assign to this object the value read from the specified `stream`&period;
| xref:BloombergLP/bdlb/NullableValue/bdexStreamOut.adoc[`bdexStreamOut`] 
| Write this object to the specified output `stream`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/emplace-02.adoc[`emplace`] 
| Destroy any contained value and construct a new one in place&period;
| xref:BloombergLP/bslstl/Optional_Base-05/get_allocator.adoc[`get&lowbar;allocator`] 
| Return allocator used for construction of `value&lowbar;type`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/has_value.adoc[`has&lowbar;value`] 
| Return `false` if this object is disengaged, and `true` otherwise&period;
| xref:BloombergLP/bdlb/NullableValue/isNull.adoc[`isNull`] 
| Return `true` if this object is null, and `false` otherwise&period;
| xref:BloombergLP/bdlb/NullableValue/makeValue-0b.adoc[`makeValue`] 
| `makeValue` overloads
| xref:BloombergLP/bdlb/NullableValue/makeValueInplace.adoc[`makeValueInplace`] 
| Construct a `TYPE` object in place from the specified `args`&period;
| xref:BloombergLP/bdlb/NullableValue/maxSupportedBdexVersion-0c.adoc[`maxSupportedBdexVersion`] 
| `maxSupportedBdexVersion` overloads
| xref:BloombergLP/bslstl/Optional_Base-05/operator_star-0b.adoc[`operator&ast;`] 
| Dereference operators
| xref:BloombergLP/bslstl/Optional_Base-05/operator_ptr-0a.adoc[`operator&hyphen;&gt;`] 
| Member access operators
| xref:bsl/optional-072/or_else-09.adoc[`or&lowbar;else`] 
| Return this optional if engaged&semi; otherwise invoke `func`&period;
| xref:BloombergLP/bdlb/NullableValue/print.adoc[`print`] 
| Format this object to the specified output `stream`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/reset.adoc[`reset`] 
| Reset this object to the default constructed state (i&period;e&period;, to a disengaged state)&period;
| xref:BloombergLP/bslstl/Optional_Base-05/swap.adoc[`swap`] 
| Exchange the values of two optionals&period;
| xref:bsl/optional-072/transform-09d.adoc[`transform`] 
| `transform` overloads
| xref:BloombergLP/bdlb/NullableValue/value-03.adoc[`value`] 
| `value` overloads
| xref:BloombergLP/bdlb/NullableValue/valueOr-03.adoc[`valueOr`] 
| `valueOr` overloads
| xref:BloombergLP/bdlb/NullableValue/valueOrNull.adoc[`valueOrNull`] 
| Return an address providing non&hyphen;modifiable access to the underlying object of a (template parameter) `TYPE` if this object is non&hyphen;null, and 0 otherwise&period;
| xref:BloombergLP/bslstl/Optional_Base-05/value_or-07.adoc[`value&lowbar;or`] 
| Return the contained value, or a converted fallback if disengaged&period;
| xref:BloombergLP/bdlb/NullableValue/2conversion-00.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;NullableValue, HasPrintMethod&gt;`] 
| `NullableValue` always provides a `print` method&period;
| xref:BloombergLP/bdlb/NullableValue/2conversion-03.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;NullableValue, IsBitwiseCopyable, bslmf&colon;&colon;IsBitwiseCopyable&lt;TYPE&gt;&colon;&colon;value&gt;`] 
| `NullableValue` is bitwise copyable when `TYPE` is bitwise copyable&period;
| xref:BloombergLP/bdlb/NullableValue/2conversion-09.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;NullableValue, IsBitwiseMoveable, bslmf&colon;&colon;IsBitwiseMoveable&lt;TYPE&gt;&colon;&colon;value&gt;`] 
| `NullableValue` is bitwise moveable when `TYPE` is bitwise moveable&period;
| xref:BloombergLP/bdlb/NullableValue/2conversion-07.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;NullableValue, UsesBslmaAllocator, bslma&colon;&colon;UsesBslmaAllocator&lt;TYPE&gt;&colon;&colon;value&gt;`] 
| `NullableValue` uses a `bslma&colon;&colon;Allocator` when `TYPE` does&period;
| xref:BloombergLP/bslstl/Optional_Base-05/2conversion-076.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;Optional&lowbar;Base, IsBitwiseCopyable, BloombergLP&colon;&colon;bslmf&colon;&colon;IsBitwiseCopyable&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;IsBitwiseCopyable`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/2conversion-04.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;Optional&lowbar;Base, IsBitwiseMoveable, BloombergLP&colon;&colon;bslmf&colon;&colon;IsBitwiseMoveable&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;IsBitwiseMoveable`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/2conversion-0a.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;Optional&lowbar;Base, UsesAllocatorArgT&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;UsesAllocatorArgT`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/2conversion-0b.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;Optional&lowbar;Base, UsesBslmaAllocator&gt;`] 
| Nested trait declaration for `bslma&colon;&colon;UsesBslmaAllocator`&period;
| xref:bsl/optional-072/2conversion-0af.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;optional, IsBitwiseCopyable, BloombergLP&colon;&colon;bslmf&colon;&colon;IsBitwiseCopyable&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;IsBitwiseCopyable`&period;
| xref:bsl/optional-072/2conversion-0a1.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;optional, IsBitwiseMoveable, BloombergLP&colon;&colon;bslmf&colon;&colon;IsBitwiseMoveable&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;IsBitwiseMoveable`&period;
| xref:bsl/optional-072/2conversion-0d.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;optional, UsesAllocatorArgT, BloombergLP&colon;&colon;bslma&colon;&colon;UsesBslmaAllocator&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslmf&colon;&colon;UsesAllocatorArgT`&period;
| xref:bsl/optional-072/2conversion-05.adoc[`operator BloombergLP::bslmf::NestedTraitDeclaration&lt;optional, UsesBslmaAllocator, BloombergLP&colon;&colon;bslma&colon;&colon;UsesBslmaAllocator&lt;t&lowbar;TYPE&gt;&colon;&colon;value&gt;`] 
| Nested trait declaration for `bslma&colon;&colon;UsesBslmaAllocator`&period;
| xref:BloombergLP/bslstl/Optional_Base-05/2conversion-071.adoc[`operator bool`] 
| Return `false` if this object is disengaged, and `true` otherwise&period;
|===


== Protected Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/Optional_Base-05/AllocType.adoc[`AllocType`] 
| This `typedef` is an alias to `allocator&lowbar;type`&period;
|===


== Protected Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/Optional_Base-05/assignOrEmplace.adoc[`assignOrEmplace`] 
| Assign or emplace a value into this optional&period;
| xref:BloombergLP/bslstl/Optional_Base-05/dereferenceRaw-049.adoc[`dereferenceRaw`] 
| Return a reference to the contained value without checking engagement&period;
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `BloombergLP::bdlb::NullableValue`
| Value&hyphen;semantic wrapper that adds a null state to `TYPE`&period;
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bdlb/nullableValue_acceptsBslOptional.adoc[`nullableValue&lowbar;acceptsBslOptional`]
| Component&hyphen;private constraint helper for `bsl&colon;&colon;optional` conversion&period;
| xref:BloombergLP/bdlb/operator_not_eq-03.adoc[`operator!&equals;`]
| Return `true` if the specified nullable objects do not have the same value&period;
| xref:BloombergLP/bdlb/operator_not_eq-044.adoc[`operator!&equals;`]
| Return whether the specified `lhs` and `rhs` do not have the same value&period;
| xref:BloombergLP/bdlb/operator_not_eq-0476.adoc[`operator!&equals;`]
| Return `true` if the specified nullable object and `std&colon;&colon;optional` do not have the same value&period;
| xref:BloombergLP/bdlb/operator_not_eq-060.adoc[`operator!&equals;`]
| Return whether the specified `lhs` and `rhs` do not have the same value&period;
| xref:BloombergLP/bdlb/operator_not_eq-07b.adoc[`operator!&equals;`]
| Return `true` if the specified nullable objects do not have the same value&period;
| xref:BloombergLP/bdlb/operator_not_eq-0a1.adoc[`operator!&equals;`]
| Return `true` if the specified nullable objects do not have the same value&period;
| xref:BloombergLP/bdlb/operator_lt-00.adoc[`operator&lt;`]
| Return whether the specified `lhs` is ordered before the specified `rhs`&period;
| xref:BloombergLP/bdlb/operator_lt-032.adoc[`operator&lt;`]
| Return `true` if `lhs` is ordered before `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_lt-07.adoc[`operator&lt;`]
| Return `true` if `lhs` is ordered before `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_lt-0a0.adoc[`operator&lt;`]
| Return `true` if `lhs` is ordered before `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_lt-0a1.adoc[`operator&lt;`]
| Return whether the specified `lhs` is ordered before the specified `rhs`&period;
| xref:BloombergLP/bdlb/operator_lt-0b.adoc[`operator&lt;`]
| Return whether the left&hyphen;hand operand is ordered before the right&period;
| xref:BloombergLP/bdlb/operator_le-023.adoc[`operator&lt;&equals;`]
| Return whether the specified `lhs` is ordered before or equal to `rhs`&period;
| xref:BloombergLP/bdlb/operator_le-041.adoc[`operator&lt;&equals;`]
| Return whether the left&hyphen;hand operand is before or equal to the right&period;
| xref:BloombergLP/bdlb/operator_le-047.adoc[`operator&lt;&equals;`]
| Return `true` if `lhs` is ordered before `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/operator_le-06b.adoc[`operator&lt;&equals;`]
| Return `true` if `lhs` is ordered before `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/operator_le-086.adoc[`operator&lt;&equals;`]
| Return `true` if `lhs` is ordered before `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/operator_le-08e.adoc[`operator&lt;&equals;`]
| Return whether the specified `lhs` is ordered before or equal to `rhs`&period;
| xref:BloombergLP/bdlb/operator_3way-03.adoc[`operator&lt;&equals;&gt;`]
| Return a three&hyphen;way comparison of the specified `lhs` and `rhs`&period;
| xref:BloombergLP/bdlb/operator_3way-04.adoc[`operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the specified nullable objects&period;
| xref:BloombergLP/bdlb/operator_3way-07.adoc[`operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the specified `value` and one of type `bsl&colon;&colon;nullopt&lowbar;t`&semi; return the result of that comparison&period;
| xref:BloombergLP/bdlb/operator_3way-0a.adoc[`operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the specified nullable objects&period;
| xref:BloombergLP/bdlb/operator_3way-0b.adoc[`operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the specified nullable object and value&period;
| xref:BloombergLP/bdlb/operator_eq-0108.adoc[`operator&equals;&equals;`]
| Return `true` if the specified `value` is null, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_eq-047.adoc[`operator&equals;&equals;`]
| Return `true` if the specified nullable objects have the same value&period;
| xref:BloombergLP/bdlb/operator_eq-052.adoc[`operator&equals;&equals;`]
| Return `true` if the specified nullable objects have the same value, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_eq-070.adoc[`operator&equals;&equals;`]
| Return `true` if the specified nullable objects have the same value&period;
| xref:BloombergLP/bdlb/operator_eq-0aa.adoc[`operator&equals;&equals;`]
| Return whether the specified `lhs` and `rhs` have the same value&period;
| xref:BloombergLP/bdlb/operator_eq-0da.adoc[`operator&equals;&equals;`]
| Return whether the specified `lhs` and `rhs` have the same value&period;
| xref:BloombergLP/bdlb/operator_eq-0f6c.adoc[`operator&equals;&equals;`]
| Return `true` if the specified nullable objects have the same value, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_gt-00.adoc[`operator&gt;`]
| Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_gt-013.adoc[`operator&gt;`]
| Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_gt-03.adoc[`operator&gt;`]
| Return `true` if `lhs` is ordered after `rhs`, and `false` otherwise&period;
| xref:BloombergLP/bdlb/operator_gt-04b.adoc[`operator&gt;`]
| Return whether the left&hyphen;hand operand is ordered after the right&period;
| xref:BloombergLP/bdlb/operator_gt-075.adoc[`operator&gt;`]
| Return whether the specified `lhs` is ordered after the specified `rhs`&period;
| xref:BloombergLP/bdlb/operator_gt-0da.adoc[`operator&gt;`]
| Return whether the specified `lhs` is ordered after the specified `rhs`&period;
| xref:BloombergLP/bdlb/operator_ge-01d1.adoc[`operator&gt;&equals;`]
| Return whether the left&hyphen;hand operand is after or equal to the right&period;
| xref:BloombergLP/bdlb/operator_ge-058.adoc[`operator&gt;&equals;`]
| Return whether the specified `lhs` is ordered after or equal to `rhs`&period;
| xref:BloombergLP/bdlb/operator_ge-07.adoc[`operator&gt;&equals;`]
| Return whether the specified `lhs` is ordered after or equal to `rhs`&period;
| xref:BloombergLP/bdlb/operator_ge-082.adoc[`operator&gt;&equals;`]
| Return `true` if `lhs` is ordered after `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/operator_ge-087.adoc[`operator&gt;&equals;`]
| Return `true` if `lhs` is ordered after `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/operator_ge-0d.adoc[`operator&gt;&equals;`]
| Return `true` if `lhs` is ordered after `rhs` or they are equal&period;
| xref:BloombergLP/bdlb/swap-02.adoc[`swap`]
| Exchange the values of the specified `lhs` and `rhs` objects when `TYPE` does not use a `bslma&colon;&colon;Allocator`&period;
| xref:BloombergLP/bdlb/swap-03.adoc[`swap`]
| Exchange the values of the specified `lhs` and `rhs` objects&period;
| xref:bsl/PrintTo-0f.adoc[`&colon;&colon;bsl&colon;&colon;PrintTo`]
| Write the specified `value` to the specified `&ast;stream`, surrounded by double quotes&period;
| xref:bsl/operator_not_eq-0c3.adoc[`&colon;&colon;bsl&colon;&colon;operator!&equals;`]
| Return whether the operands do not have the same value&period;
| xref:bsl/operator_not_eq-0cf.adoc[`&colon;&colon;bsl&colon;&colon;operator!&equals;`]
| Return whether the operands do not have the same value&period;
| xref:bsl/operator_not_eq-0e.adoc[`&colon;&colon;bsl&colon;&colon;operator!&equals;`]
| Return whether the operands do not have the same value&period;
| xref:bsl/operator_lt-00.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;`]
| Return whether the left&hyphen;hand operand is ordered before the right&period;
| xref:bsl/operator_lt-010.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;`]
| Return whether the left&hyphen;hand operand is ordered before the right&period;
| xref:bsl/operator_lt-0b.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;`]
| Return whether the left&hyphen;hand operand is ordered before the right&period;
| xref:bsl/operator_le-03.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;`]
| Return whether the left&hyphen;hand operand is before or equal to the right&period;
| xref:bsl/operator_le-04.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;`]
| Return whether the left&hyphen;hand operand is before or equal to the right&period;
| xref:bsl/operator_le-0c.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;`]
| Return whether the left&hyphen;hand operand is before or equal to the right&period;
| xref:bsl/operator_3way-00.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the operands&period;
| xref:bsl/operator_3way-070.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the operands&period;
| xref:bsl/operator_3way-0a.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the operands&period;
| xref:bsl/operator_3way-0d1.adoc[`&colon;&colon;bsl&colon;&colon;operator&lt;&equals;&gt;`]
| Perform a three&hyphen;way comparison of the operands&period;
| xref:bsl/operator_eq-02a.adoc[`&colon;&colon;bsl&colon;&colon;operator&equals;&equals;`]
| Return whether the operands have the same value&period;
| xref:bsl/operator_eq-097.adoc[`&colon;&colon;bsl&colon;&colon;operator&equals;&equals;`]
| Return whether the operands have the same value&period;
| xref:bsl/operator_eq-09de.adoc[`&colon;&colon;bsl&colon;&colon;operator&equals;&equals;`]
| Compare a `std&colon;&colon;optional` with a `bsl&colon;&colon;optional` for equality&period;
| xref:bsl/operator_eq-0db.adoc[`&colon;&colon;bsl&colon;&colon;operator&equals;&equals;`]
| Return whether the operands have the same value&period;
| xref:bsl/operator_gt-04.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;`]
| Return whether the left&hyphen;hand operand is ordered after the right&period;
| xref:bsl/operator_gt-07.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;`]
| Return whether the left&hyphen;hand operand is ordered after the right&period;
| xref:bsl/operator_gt-0bc.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;`]
| Return whether the left&hyphen;hand operand is ordered after the right&period;
| xref:bsl/operator_ge-05.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;&equals;`]
| Return whether the left&hyphen;hand operand is after or equal to the right&period;
| xref:bsl/operator_ge-06.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;&equals;`]
| Return whether the left&hyphen;hand operand is after or equal to the right&period;
| xref:bsl/operator_ge-088.adoc[`&colon;&colon;bsl&colon;&colon;operator&gt;&equals;`]
| Return whether the left&hyphen;hand operand is after or equal to the right&period;
| xref:bsl/swap-00c.adoc[`&colon;&colon;bsl&colon;&colon;swap`]
| Exchange the values of two optionals&period;
| xref:bsl/swap-04d.adoc[`&colon;&colon;bsl&colon;&colon;swap`]
| Exchange the values of two optionals&period;
| xref:bsl/swap-0f3.adoc[`&colon;&colon;bsl&colon;&colon;swap`]
| Exchange the values of two optionals&period;
| xref:BloombergLP/bdlat_NullableValueFunctions/bdlat_nullableValueAccessValue-0c3.adoc[`&colon;&colon;BloombergLP&colon;&colon;bdlat&lowbar;NullableValueFunctions&colon;&colon;bdlat&lowbar;nullableValueAccessValue`]
| Default customization&hyphen;point implementation of `accessValue` for `bdlb&colon;&colon;NullableValue`&period;
| xref:BloombergLP/bdlat_NullableValueFunctions/bdlat_nullableValueIsNull-05.adoc[`&colon;&colon;BloombergLP&colon;&colon;bdlat&lowbar;NullableValueFunctions&colon;&colon;bdlat&lowbar;nullableValueIsNull`]
| Return whether the specified nullable `object` is null&period;
| xref:BloombergLP/bdlat_NullableValueFunctions/bdlat_nullableValueMakeValue-0b.adoc[`&colon;&colon;BloombergLP&colon;&colon;bdlat&lowbar;NullableValueFunctions&colon;&colon;bdlat&lowbar;nullableValueMakeValue`]
| Default customization&hyphen;point implementation of `makeValue` for `bdlb&colon;&colon;NullableValue`&period;
| xref:BloombergLP/bdlat_NullableValueFunctions/bdlat_nullableValueManipulateValue-041.adoc[`&colon;&colon;BloombergLP&colon;&colon;bdlat&lowbar;NullableValueFunctions&colon;&colon;bdlat&lowbar;nullableValueManipulateValue`]
| Default customization&hyphen;point implementation of `manipulateValue` for `bdlb&colon;&colon;NullableValue`&period;
| xref:BloombergLP/bslstl/optional_acceptsBslOptional.adoc[`&colon;&colon;BloombergLP&colon;&colon;bslstl&colon;&colon;optional&lowbar;acceptsBslOptional`]
| Component&hyphen;private constraint helper for `Optional&lowbar;DerivedFromBslOptional`&period;
|===


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