bsl::optional

Synopsis

Declared in <bslstl_optional.h>

template<class t_TYPE>
class optional
    : public BloombergLP::bslstl::Optional_Base<t_TYPE>

Base Classes

Name

Description

BloombergLP::bslstl::Optional_Base<t_TYPE>

This component‐private class template implements the functionality of bsl::optional. The primary template is instantiated when TYPE is allocator‐aware, and holds the allocator that is used to create the stored object.

Type Aliases

Name

Description

allocator_type

This typedef is an alias to bsl::allocator<char>.

value_type

value_type is an alias for the underlying TYPE upon which this template class is instantiated, and represents the type of the managed object. The name is chosen so it is compatible with the std::optional implementation.

Member Functions

Name

Description

optional [constructor]

Constructors

Assignment operators

and_then overloads

emplace overloads

Return allocator used for construction of value_type.

has_value

Return false if this object is disengaged, and true otherwise.

operator*

Dereference operators

operator‐>

Member access operators

or_else

or_else overloads

reset

Reset this object to the default constructed state (i.e., to a disengaged state).

swap

Efficiently exchange the value of this object with the value of the specified other object. This method provides the no‐throw exception‐safety guarantee if the template parameter t_TYPE provides that guarantee and the result of the hasValue method for the two objects being swapped is the same. The behavior is undefined unless this object was created with the same allocator as other.

transform

transform overloads

value

value overloads

value_or

value_or overloads

operator BloombergLP::bslmf::NestedTraitDeclaration<Optional_Base, IsBitwiseCopyable, BloombergLP::bslmf::IsBitwiseCopyable<t_TYPE>::value>

Nested trait declaration for bslmf::IsBitwiseCopyable.

operator BloombergLP::bslmf::NestedTraitDeclaration<Optional_Base, IsBitwiseMoveable, BloombergLP::bslmf::IsBitwiseMoveable<t_TYPE>::value>

Nested trait declaration for bslmf::IsBitwiseMoveable.

operator BloombergLP::bslmf::NestedTraitDeclaration<Optional_Base, UsesAllocatorArgT>

Nested trait declaration for bslmf::UsesAllocatorArgT.

operator BloombergLP::bslmf::NestedTraitDeclaration<Optional_Base, UsesBslmaAllocator>

Nested trait declaration for bslma::UsesBslmaAllocator.

operator BloombergLP::bslmf::NestedTraitDeclaration<optional, IsBitwiseCopyable, BloombergLP::bslmf::IsBitwiseCopyable<t_TYPE>::value>

Nested trait declaration for bslmf::IsBitwiseCopyable.

operator BloombergLP::bslmf::NestedTraitDeclaration<optional, IsBitwiseMoveable, BloombergLP::bslmf::IsBitwiseMoveable<t_TYPE>::value>

Nested trait declaration for bslmf::IsBitwiseMoveable.

operator BloombergLP::bslmf::NestedTraitDeclaration<optional, UsesAllocatorArgT, BloombergLP::bslma::UsesBslmaAllocator<t_TYPE>::value>

Nested trait declaration for bslmf::UsesAllocatorArgT.

operator BloombergLP::bslmf::NestedTraitDeclaration<optional, UsesBslmaAllocator, BloombergLP::bslma::UsesBslmaAllocator<t_TYPE>::value>

Nested trait declaration for bslma::UsesBslmaAllocator.

operator bool

Return false if this object is disengaged, and true otherwise.

Protected Type Aliases

Name

Description

AllocType

This typedef is an alias to allocator_type.

Protected Member Functions

Name

Description

assignOrEmplace

If *this holds an object, assign to that object the value of the specified rhs, converted to t_TYPE. Otherwise, construct a held object from rhs, converted to t_TYPE. The allocators of *this and rhs remain unchanged.

dereferenceRaw

dereferenceRaw overloads

Deduction Guides

Name

Description

optional<t_TYPE>

Deduce the specified type t_TYPE from the corresponding type supplied to the constructor of optional.

optional<t_TYPE>

Deduce the specified type t_TYPE from the corresponding type supplied to the constructor of optional. This guide does not participate in deduction unless the deduced type t_TYPE supports the bslma allocator model, and the specified t_ALLOC can be implicitly converted to bsl::allocator<char>.

optional<t_TYPE>

Deduce the specified type t_TYPE from the corresponding template parameter type supplied to the constructor of optional. This guide does not participate in deduction unless the deduced type t_TYPE supports the bslma allocator model, and the specified t_ALLOC can be implicitly converted to bsl::allocator<char>.

Friends

Name

Description

bsl::optional

Non-Member Functions

Name

Description

PrintTo

Write the specified value to the specified *stream, surrounded by double quotes.

make_optional

Return an optional object containing a TYPE object created by invoking a bsl::optional in_place_t constructor with the specified arg and args as the constructor arguments. If t_TYPE uses an allocator, the default allocator will be used for the optional object. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

make_optional

Return an optional object containing a value‐initialized t_TYPE object. If t_TYPE uses an allocator, the default allocator will be used for the optional object. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

make_optional

Return an optional object containing a t_TYPE object created by invoking a bsl::optional in_place_t constructor with the specified il and args as the constructor arguments. If t_TYPE uses an allocator, the default allocator will be used for the optional object. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

make_optional

Return an optional object containing a t_TYPE object created by invoking a bsl::optional allocator‐extended in_place_t constructor with the specified alloc as the allocator argument, and specified rhs as the constructor argument. Note that this function will fail to compile if t_TYPE doesn't use allocators.

make_optional

Return an optional object containing a t_TYPE object created by invoking a bsl::optional allocator‐extended in_place_t constructor with the specified alloc as the allocator argument, and specified il and args as the constructor arguments. Note that this function will fail to compile if t_TYPE doesn't use allocators.

make_optional

Return an optional object containing a t_TYPE object created by invoking a bsl::optional constructor with the specified rhs as the constructor argument. If t_TYPE uses an allocator, the default allocator will be used for the optional object. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

make_optional

Return an optional object containing a t_TYPE object created by invoking a bsl::optional allocator‐extended in_place_t constructor with the specified alloc as the allocator argument, and specified args as constructor arguments. Note that this function will fail to compile if t_TYPE doesn't use allocators.

operator!=

Return true if the specified lhs and rhs optional objects do not have the same value, and false otherwise. Two optional objects do not have the same value if one is disengaged and the other is engaged, or if both are engaged and the values of their underlying objects do not compare equal. This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator!=

Return true if the specified lhs and rhs optional objects do not have the same value, and false otherwise. Two optional objects do not have the same value if one is disengaged and the other is engaged, or if both are engaged and the values of their underlying objects do not compare equal. Note that this function will fail to compile if t_LHS_TYPE and t_RHS_TYPE are not compatible. These functions can be called in constant expressions only if the bsl::optional's value type is not allocator‐aware.

operator!=

Return true if the specified lhs and rhs objects do not have the same value, and false otherwise. An optional object and a value of some type do not have the same value if either the optional object is disengaged, or its underlying value does not compare equal to the other value. These function can be called in constant expressions only if the optional's value type is not allocator‐aware.

operator<

Return true if the specified lhs optional object is ordered before the specified rhs, and false otherwise. lhs is ordered before rhs if lhs is disengaged or lhs.value() is ordered before rhs. This function can be called in constant expressions only if t_LHS_TYPE is not allocator‐aware.

operator<

Return true if the specified lhs optional object is ordered before the specified rhs optional object, and false otherwise. lhs is ordered before rhs if lhs is disengaged and rhs is engaged or if both are engaged and lhs.value() is ordered before rhs.value(). Note that this function will fail to compile if t_LHS_TYPE and t_RHS_TYPE are not compatible. These functions can be called in constant expressions only if the bsl::optional's value type is not allocator‐aware.

operator<

Return true if the specified lhs optional object is ordered before the specified rhs optional object, and false otherwise. lhs is ordered before rhs if lhs is disengaged and rhs is engaged or if both are engaged and lhs.value() is ordered before rhs.value(). This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator<=

Return true if the specified lhs optional object is ordered before the specified rhs or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) This function can be called in constant expressions only if t_LHS_TYPE is not allocator‐aware.

operator<=

Return true if the specified lhs is ordered before the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) Note that this function will fail to compile if t_LHS_TYPE and t_RHS_TYPE are not compatible. These functions can be called in constant expressions only if the bsl::optional's value type is not allocator‐aware.

operator<=

Return true if the specified lhs optional object is ordered before the specified rhs optional object or if lhs and rhs have the same value, and false otherwise. (See operator< and operator==.) This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator<=>

Perform a three‐way comparison of the specified lhs and the specified rhs objects by using the comparison operators of t_LHS and t_RHS; return the result of that comparison. This function can be called in constant expressions only if neither t_LHS nor t_RHS is allocator‐aware.

operator<=>

Perform a three‐way comparison of the specified value and nullopt; return the result of that comparison. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

operator==

Return true if the specified lhs and rhs objects have the same value, and false otherwise. An optional object and a value of some type have the same value if the optional object is engaged and its underlying value compares equal to the other value. These functions can be called in constant expressions only if the optional's value type is not allocator‐aware.

operator==

Return true if the specified lhs and rhs optional objects have the same value, and false otherwise. Two optional objects have the same value if both are disengaged, or if both are engaged and the values of their underlying objects compare equal. This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator==

Compare a std::optional with a bsl::optional for equality.

operator==

Return true if the specified value is disengaged, and false otherwise. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

operator>

Return true if the specified lhs optional object is ordered after the specified rhs, and false otherwise. lhs is ordered after rhs if lhs is engaged and lhs.value() is ordered after rhs. This function can be called in constant expressions only if t_LHS_TYPE is not allocator‐aware.

operator>

Return true if the specified lhs optional object is ordered after the specified rhs optional object, and false otherwise. lhs is ordered after rhs if lhs is engaged and rhs is disengaged or if both are engaged and lhs.value() is ordered after rhs.value(). Note that this function will fail to compile if t_LHS_TYPE and t_RHS_TYPE are not compatible. These functions can be called in constant expressions only if the bsl::optional's value type is not allocator‐aware.

operator>

Return true if the specified lhs optional object is ordered after the specified rhs optional object, and false otherwise. lhs is ordered after rhs if lhs is engaged and rhs is disengaged or if both are engaged and lhs.value() is ordered after rhs.value(). This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator>=

Return true if the specified lhs optional object is ordered after the specified rhs optional object or if lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) This function can be called in constant expressions only if neither t_LHS_TYPE nor t_RHS_TYPE is allocator‐aware.

operator>=

Return true if the specified lhs optional object is ordered after the specified rhs or if lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) This function can be called in constant expressions only if t_LHS_TYPE is not allocator‐aware.

operator>=

Return true if the specified lhs optional object is ordered after the specified rhs optional object or lhs and rhs have the same value, and false otherwise. (See operator> and operator==.) Note that this function will fail to compile if t_LHS_TYPE and t_RHS_TYPE are not compatible. These functions can be called in constant expressions only if the bsl::optional's value type is not allocator‐aware.

swap

Efficiently exchange the values of the specified lhs and rhs objects. This method provides the no‐throw exception‐safety guarantee if the template parameter t_TYPE provides that guarantee and the result of the hasValue method for lhs and rhs is the same. This function can be called in constant expressions only if t_TYPE is not allocator‐aware.

swap

Efficiently exchange the values of the specified lhs and rhs objects. This method provides the no‐throw exception‐safety guarantee if the template parameter t_TYPE provides that guarantee, lhs and rhs have equal allocators, and lhs.hasValue() == rhs.hasValue().

swap

::BloombergLP::bdlb::nullableValue_acceptsBslOptional

Component‐private constraint helper for bsl::optional conversion.

::BloombergLP::bdlb::operator!=

Return true if the specified nullable objects do not have the same value.

::BloombergLP::bdlb::operator!=

Return true if the specified nullable objects do not have the same value.

::BloombergLP::bdlb::operator<

Return true if lhs is ordered before rhs, and false otherwise.

::BloombergLP::bdlb::operator<

If neither of the specified lhs and rhs contain a value, return false. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value < rhs.value().

::BloombergLP::bdlb::operator<=

If neither of the specified lhs and rhs contain a value, return true. If lhs contains a value, and rhs does not, return false. If lhs does not contains a value, rhs does, return true. Otherwise, return lhs.value <= rhs.value().

::BloombergLP::bdlb::operator<=

Return true if lhs is ordered before rhs or they are equal.

::BloombergLP::bdlb::operator==

Return true if the specified nullable objects have the same value.

::BloombergLP::bdlb::operator==

Return true if the specified nullable objects have the same value, and false otherwise.

::BloombergLP::bdlb::operator>

Return true if lhs is ordered after rhs, and false otherwise.

::BloombergLP::bdlb::operator>

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().

::BloombergLP::bdlb::operator>=

If neither of the specified lhs and rhs contain a value, return true. 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().

::BloombergLP::bdlb::operator>=

Return true if lhs is ordered after rhs or they are equal.

::BloombergLP::bslstl::optional_acceptsBslOptional

Component‐private constraint helper for Optional_DerivedFromBslOptional.

Derived Classes

Name

Description

NullableValue

This template class extends the set of values of its value‐semantic TYPE parameter to include the notion of a "null" value. If TYPE is fully value‐semantic, then the augmented type NullableValue<TYPE> will be as well. In addition to supporting all homogeneous value‐semantic operations, conversions between comparable underlying value types is also supported. 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‐null values compare equal. A null nullable object is considered ordered before any non‐null nullable object. Attempts to copy construct, copy assign, or compare incompatible values types will fail to compile. The NullableValue template cannot be instantiated on an incomplete type, a type that overloads unary operator&, or bsl::nullopt_t.

Created with MrDocs